builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/extern/pkg_ddl/include/adtfddl/ddlrepresentation/ddl.h

Go to the documentation of this file.

 
#ifndef _DDL_H_INCLUDED_
#define _DDL_H_INCLUDED_
 
namespace adtf_ddl
{
 
    class cDDL : public IDDL
    {
    public:
 
        virtual ~cDDL(){}
 
        virtual bool IsInitialized() const;
 
        virtual bool IsPredefined() const;
 
        virtual bool IsOverwriteable() const;
 
        virtual int GetCreationLevel() const;
 
        template<typename T>
        static T* DeleteChild(T *pvObj)
        {
            if (NULL != pvObj)
            {
                if (pvObj->IsPredefined())
                {
                    return pvObj;
                }
                else
                {
                    delete pvObj;
                }
            }
            return NULL;
        }
 
        template<typename T>
        static tResult MoveChild(T *pvObj, const int nFrom, const int nTo)
        {
            RETURN_IF_POINTER_NULL(pvObj);
 
            if (-1 == nFrom || -1 == nTo ||
                (int)pvObj->size() < nFrom || (int)pvObj->size() < nTo)
            {
                RETURN_ERROR(ERR_OUT_OF_RANGE);
            }
 
            if (nFrom != nTo)
            {
                if (nFrom < nTo)
                {
                    std::rotate(pvObj->begin() + nFrom,
                        pvObj->begin() + nFrom + 1,
                        pvObj->begin() + nTo + 1);
                }
                else
                {
                    std::rotate(pvObj->begin() + nTo,
                        pvObj->begin() + nFrom,
                        pvObj->begin() + nFrom + 1);
                }
            }
            RETURN_NOERROR;
        }
 
        template<typename T>
        static T* Clone(T* pvObj)
        {
            if (NULL != pvObj)
            {
                if (pvObj->IsPredefined())
                {
                    return Ref<T>(pvObj);
                }
                return new T(*pvObj);
            }
            return NULL;
        }
 
        template<typename T>
        static T* Ref(T* pvObj)
        {
            if (NULL != pvObj)
            {
                return pvObj;
            }
            return NULL;
        }
 
        static bool IsEqual(IDDL* poLHS, IDDL* poRHS);
 
        static bool IsSorted(IDDL* poLHS, IDDL* poRHS);
    };
 
    template<typename T = IDDL>
    struct cDDLCompareFunctor
    {
        const A_UTILS_NS::cString& m_strPattern;
 
        cDDLCompareFunctor(const A_UTILS_NS::cString& strPattern): m_strPattern(strPattern)
        {
        }
 
        bool operator()(const T* poEntry)
        {
            if (NULL == poEntry)
            {
                return false;
            }
            return m_strPattern.IsEqual(poEntry->GetName());
        }
    };
 
}   // namespace adtf_ddl
 
#endif  // _DDL_H_INCLUDED_