xsens_janitors.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSENS_JANITORS_H
#define XSENS_JANITORS_H
 
#ifndef __AVR32__
        #include <functional>
#endif
 
// required for gnu c++ compiler versions due to difference in attribute declarations
#if defined(__AVR32__)
        #define __cdecl
        #define __stdcall
#elif defined(_ADI_COMPILER)
        #define __cdecl
        #define __stdcall
#elif defined(__GNUC__) && !defined(HAVE_CDECL)
        #if !defined(__cdecl)
                #if defined(__x86_64__)
                        #define __cdecl
                #else
                        #define __cdecl __attribute__((cdecl))
                #endif
        #endif
        #if !defined(__stdcall)
                #if defined(__x86_64__)
                        #define __stdcall
                #else
                        #define __stdcall __attribute__((stdcall))
                #endif
        #endif
#endif
 
namespace xsens
{
 
#ifndef NOT_FOR_PUBLIC_RELEASE
 
template <class T>
class JanitorRestore
{
private:
        T& m_control;
        T  m_value;
        bool m_enabled;
public:
 
        JanitorRestore<T>(T& control, bool enabl = true) :
                m_control(control), m_value(control), m_enabled(enabl) {}
 
        ~JanitorRestore()
        {
                if (m_enabled)
                        m_control = m_value;
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class T>
class JanitorFree
{
private:
        T* m_control;
        bool m_enabled;
public:
 
        JanitorFree<T>(T* control, bool enabl = true) :
                m_control(control), m_enabled(enabl) {}
 
        ~JanitorFree()
        {
                if (m_enabled)
                        free(m_control);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class T>
class JanitorDelete
{
private:
        T* m_control;
        bool m_enabled;
public:
 
        JanitorDelete<T>() :
                m_control(NULL),
                m_enabled(true)
        {
 
        }
 
        JanitorDelete<T>(T* control, bool enabl = true) :
                m_control(control),
                m_enabled(enabl)
        {
 
        }
 
        ~JanitorDelete()
        {
                if (m_enabled)
                        delete m_control;
        }
 
        void setControl(T* control)
        {
                m_control = control;
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
 
        const T* operator->() const
        {
                return m_control;
        }
 
        T* operator->()
        {
                return m_control;
        }
};
 
 
template <class T>
class JanitorDeleteNull
{
private:
        T*& m_control;
        bool m_enabled;
public:
 
        JanitorDeleteNull<T>(T*& control, bool enabl = true) :
                m_control(control),
                m_enabled(enabl)
        {
 
        }
 
        ~JanitorDeleteNull()
        {
                if (m_enabled)
                {
                        delete m_control;
                        m_control = 0;
                }
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
 
        const T* operator->() const
        {
                return m_control;
        }
 
        T* operator->()
        {
                return m_control;
        }
};
 
 
template <class T>
class JanitorDeleteArray
{
private:
        T* m_control;
        bool m_enabled;
public:
 
        JanitorDeleteArray<T>(T* control, bool enabl = true) :
                m_control(control), m_enabled(enabl) {}
 
        ~JanitorDeleteArray()
        {
                if (m_enabled)
                        delete[] m_control;
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
#endif
 
 
template <class T, typename R = void>
class JanitorClassFunc
{
public:
        typedef R(T::*t_func_JanitorClassFunc)(void);  
private:
        const JanitorClassFunc& operator = (const JanitorClassFunc&);
 
        T& m_control;
        t_func_JanitorClassFunc m_funcJCF;
        bool m_enabled;
public:
 
        JanitorClassFunc<T, R>(T& control, t_func_JanitorClassFunc func, bool enabl = true) :
                m_control(control), m_funcJCF(func), m_enabled(enabl)
        {
        }
 
        ~JanitorClassFunc()
        {
                if (m_enabled)
                        (m_control.*m_funcJCF)();
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class T, typename P1, typename R = void>
class JanitorClassFuncP1
{
public:
        typedef R(T::*t_func_JanitorClassFunc)(P1);  
private:
        const JanitorClassFuncP1& operator = (const JanitorClassFuncP1&);
 
        T& m_control;
        P1 m_param1;
        t_func_JanitorClassFunc m_funcJCF;
        bool m_enabled;
public:
 
        JanitorClassFuncP1<T, P1, R>(T& control, P1 p1, t_func_JanitorClassFunc func, bool enabl = true) :
                m_control(control), m_param1(p1), m_funcJCF(func), m_enabled(enabl)
        {
        }
 
        ~JanitorClassFuncP1()
        {
                if (m_enabled)
                        (m_control.*m_funcJCF)(m_param1);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
#ifndef NOT_FOR_PUBLIC_RELEASE
 
template <typename ResultType = void>
class JanitorFunc0
{
public:
        typedef ResultType(__cdecl* t_func_JanitorFunc)(void);   
private:
        const JanitorFunc0& operator = (const JanitorFunc0&);
        t_func_JanitorFunc m_funcJF;
        bool m_enabled;
public:
 
        JanitorFunc0<ResultType>(t_func_JanitorFunc func, bool enabl = true) :
                m_funcJF(func), m_enabled(enabl) {}
 
        ~JanitorFunc0()
        {
                if (m_enabled)
                        (*m_funcJF)();
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
#ifndef __AVR32__
 
template <typename ResultType = void>
class JanitorStdFunc0
{
public:
        typedef std::function<ResultType(void)> t_func_JanitorFunc;  
private:
        const JanitorStdFunc0& operator = (const JanitorStdFunc0&);
        t_func_JanitorFunc m_funcJF;
        bool m_enabled;
public:
 
        JanitorStdFunc0<ResultType>(t_func_JanitorFunc func, bool enabl = true) :
                m_funcJF(func), m_enabled(enabl) {}
 
        ~JanitorStdFunc0()
        {
                if (m_enabled)
                        m_funcJF();
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
#endif
 
 
template <class ParamType, typename ResultType = void>
class JanitorFunc1
{
public:
        typedef ResultType(__cdecl* t_func_JanitorFunc)(ParamType);   
private:
        const JanitorFunc1& operator = (const JanitorFunc1&);
        ParamType m_control;
        t_func_JanitorFunc m_funcJF;
        bool m_enabled;
public:
 
        JanitorFunc1<ParamType, ResultType>(t_func_JanitorFunc func, ParamType control, bool enabl = true) :
                m_control(control), m_funcJF(func), m_enabled(enabl) {}
 
        ~JanitorFunc1()
        {
                if (m_enabled)
                        (*m_funcJF)(m_control);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class ParamType, typename ResultType = void>
class JanitorFunc1R
{
public:
        typedef ResultType(__cdecl* t_func_JanitorFunc)(ParamType);   
private:
        const JanitorFunc1R& operator = (const JanitorFunc1R&);
        ParamType& m_control;
        t_func_JanitorFunc m_funcJF;
        bool m_enabled;
public:
 
        JanitorFunc1R<ParamType, ResultType>(t_func_JanitorFunc func, ParamType& control, bool enabl = true) :
                m_control(control), m_funcJF(func), m_enabled(enabl) {}
 
        ~JanitorFunc1R()
        {
                if (m_enabled)
                        (*m_funcJF)(m_control);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class Param1Type, class Param2Type, typename ResultType = void>
class JanitorFunc2
{
public:
        typedef ResultType(__cdecl* t_func_JanitorFunc)(Param1Type, Param2Type);  
private:
        const JanitorFunc2& operator = (const JanitorFunc2&);
        Param1Type m_control1;
        Param2Type m_control2;
        t_func_JanitorFunc m_funcJF;
        bool m_enabled;
public:
 
        JanitorFunc2<Param1Type, Param2Type, ResultType>(t_func_JanitorFunc func, Param1Type control1, Param2Type control2, bool enabl = true) :
                m_funcJF(func), m_control1(control1), m_control2(control2), m_enabled(enabl) {}
 
        ~JanitorFunc2()
        {
                if (m_enabled)
                        (*m_funcJF)(m_control1, m_control2);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class Param1Type, class Param2Type, typename ResultType = void>
class JanitorFunc2R
{
public:
        typedef ResultType(__cdecl* t_func_JanitorFunc)(Param1Type, Param2Type);  
private:
        const JanitorFunc2R& operator = (const JanitorFunc2R&);
        Param1Type& m_control1;
        Param2Type& m_control2;
        t_func_JanitorFunc m_funcJF;
        bool m_enabled;
public:
 
        JanitorFunc2R<Param1Type, Param2Type, ResultType>(t_func_JanitorFunc func, Param1Type& control1, Param2Type& control2, bool enabl = true) :
                m_funcJF(func), m_control1(control1), m_control2(control2), m_enabled(enabl) {}
 
        ~JanitorFunc2R()
        {
                if (m_enabled)
                        (*m_funcJF)(m_control1, m_control2);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class T, class C, typename R = void>
class JanitorLogFunc
{
public:
        typedef R(__cdecl* t_func_JanitorLogFunc)(const char*, const char*, ...);   
private:
        const JanitorLogFunc& operator = (const JanitorLogFunc&);
        t_func_JanitorLogFunc m_funcJF;
        const char* m_filter;
        const char* m_str;
        const char* m_functionName;
        T& m_control;
        bool m_enabled;
public:
 
        JanitorLogFunc<T, C, R>(t_func_JanitorLogFunc func, const char* filter, const char* str, const char* functionName, T& control, bool enable = true) :
                m_funcJF(func), m_filter(filter), m_str(str), m_functionName(functionName), m_control(control), m_enabled(enable)
        {}
 
        JanitorLogFunc<T, C, R>(t_func_JanitorLogFunc func, const char* filter, const char* str, T& control, bool enable = true) :
                m_funcJF(func), m_filter(filter), m_str(str), m_functionName(0), m_control(control), m_enabled(enable) {}
 
        ~JanitorLogFunc()
        {
                if (m_enabled)
                {
                        if (m_functionName)
                                (*m_funcJF)(m_filter, m_str, m_functionName, (C) m_control);
                        else
                                (*m_funcJF)(m_filter, m_str, (C) m_control);
                }
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <typename R = void>
class JanitorSimpleLogFunc
{
public:
        typedef R(__cdecl* t_func_JanitorSimpleLogFunc)(const char*, const char*, ...);   
private:
        const JanitorSimpleLogFunc& operator = (const JanitorSimpleLogFunc&);
        t_func_JanitorSimpleLogFunc m_funcJF;
        const char* m_filter;
        const char* m_str;
        const char* m_functionName;
        bool m_enabled;
public:
 
        JanitorSimpleLogFunc<R>(t_func_JanitorSimpleLogFunc func, const char* filter, const char* str, const char* functionName, bool enable = true) :
                m_funcJF(func), m_filter(filter), m_str(str), m_functionName(functionName), m_enabled(enable)
        {}
 
        JanitorSimpleLogFunc<R>(t_func_JanitorSimpleLogFunc func, const char* filter, const char* str, bool enable = true) :
                m_funcJF(func), m_filter(filter), m_str(str), m_functionName(0), m_enabled(enable) {}
 
        ~JanitorSimpleLogFunc()
        {
                if (m_enabled)
                {
                        if (m_functionName)
                                (*m_funcJF)(m_filter, m_str, m_functionName);
                        else
                                (*m_funcJF)(m_filter, m_str);
                }
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class ParamType, typename ResultType = void>
class JanitorFuncStdCall
{
public:
#ifndef __ANDROID_API__
        typedef ResultType(__stdcall* t_func_JanitorFuncStdCall)(ParamType);   
#else
        typedef ResultType(*t_func_JanitorFuncStdCall)(ParamType);   
#endif
private:
        const JanitorFuncStdCall& operator = (const JanitorFuncStdCall&);
        ParamType& m_control;
        t_func_JanitorFuncStdCall m_funcJFSC;
        bool m_enabled;
public:
 
        JanitorFuncStdCall<ParamType, ResultType>(t_func_JanitorFuncStdCall func, ParamType& control, bool enabl = true) :
                m_funcJFSC(func), m_control(control), m_enabled(enabl) {}
 
        ~JanitorFuncStdCall()
        {
                if (m_enabled)
                        (*m_funcJFSC)(m_control);
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
template <class T>
class JanitorSet
{
private:
        const JanitorSet& operator = (const JanitorSet&);
        T& m_control;
        T  m_value;
        bool m_enabled;
public:
 
        JanitorSet<T>(T& control, const T& val, bool enabl = true) :
                m_control(control), m_value(val), m_enabled(enabl) {}
 
        ~JanitorSet()
        {
                if (m_enabled)
                        m_control = m_value;
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
};
 
 
 
template <typename T>
class JanitorRCDeallocationPolicy_Delete
{
public:
        static void Deallocate(T* p)
        {
                delete p;
        }
protected:
        ~JanitorRCDeallocationPolicy_Delete() {}
};
 
template <typename T>
class JanitorRCDeallocationPolicy_Free
{
public:
        static void Deallocate(T* p)
        {
                free(p);
        }
protected:
        ~JanitorRCDeallocationPolicy_Free() {}
};
 
template <class T, template <class> class DeallocationPolicy>
class JanitorRCDeallocation
{
public:
        typedef JanitorRCDeallocation<T, DeallocationPolicy> ThisType;  
        typedef T ElementType;                                                                                  
        typedef void (*PostDeallocateFunc)();                                                   
 
        JanitorRCDeallocation(ElementType* target = 0, bool enabled = true)
                : m_target(target)
                , m_refCounter(0)
                , m_enabled(enabled)
        {
                addRef();
        }
 
        JanitorRCDeallocation(const ThisType& j, bool enabled = true)
                : m_target(j.m_target)
                , m_refCounter(j.m_refCounter)
                , m_enabled(enabled)
        {
                addRef();
        }
 
        virtual ~JanitorRCDeallocation()
        {
                removeRef();
        }
 
        JanitorRCDeallocation& operator=(const JanitorRCDeallocation& rhs)
        {
                if (m_target != rhs.m_target)
                {
                        removeRef();
                        m_target = rhs.m_target;
                        m_refCounter = rhs.m_refCounter;
                        addRef();
                }
                return *this;
        }
        ElementType* operator->() const
        {
                return m_target;
        }
 
        ElementType& operator*() const
        {
                return *m_target;
        }
 
        void disable(void)
        {
                m_enabled = false;
        }
 
        void enable(void)
        {
                m_enabled = true;
        }
 
        ElementType* get() const throw()
        {
                return m_target;
        }
 
        void swap(JanitorRCDeallocation& other) throw()
        {
                using std::swap;
                swap(m_target, other.m_target);
                swap(m_refCounter, other.m_refCounter);
                swap(m_enabled, other.m_enabled);
        }
#ifndef SWIG
 
        inline friend void swap(JanitorRCDeallocation& first, JanitorRCDeallocation& second)
        {
                first.swap(second);
        }
#endif
 
        void reset(ElementType* p = 0) throw()
        {
                if (m_target != p)
                        ThisType(p).swap(*this);
        }
 
private:
 
        void addRef(void)
        {
                if (m_target)
                {
                        if (!m_refCounter)
                                m_refCounter = new int(0);
                        (*m_refCounter)++;
                }
        }
 
        void removeRef(void)
        {
                if (m_refCounter)
                {
                        if (*m_refCounter > 1)
                                (*m_refCounter)--;
                        else
                        {
                                delete m_refCounter;
                                DeallocationPolicy<ElementType>::Deallocate(m_target);
                        }
                }
        }
 
        ElementType* m_target;
        int* m_refCounter;
        bool m_enabled;
};
 
template <class T, template <class> class DeallocationPolicy = JanitorRCDeallocationPolicy_Free>
class JanitorRCFree : public JanitorRCDeallocation<T, DeallocationPolicy>
{
public:
 
        JanitorRCFree(T* target = 0, bool enabled = true): JanitorRCDeallocation<T, DeallocationPolicy>(target, enabled) {}
};
 
template <class T, template <class> class DeallocationPolicy = JanitorRCDeallocationPolicy_Delete>
class JanitorRCDelete : public JanitorRCDeallocation<T, DeallocationPolicy>
{
public:
 
        JanitorRCDelete(T* target = 0, bool enabled = true): JanitorRCDeallocation<T, DeallocationPolicy>(target, enabled) {}
};
 
#endif
 
}
 
#endif