ddldescription.h

Go to the documentation of this file.

 
#ifndef _DDL_DESCRIPTION_H_INCLUDED_
#define _DDL_DESCRIPTION_H_INCLUDED_
 
#include <adtfddl/pkg_ddl_deprecated.h>
 
namespace adtf_ddl
{    
    class cDDLDescription : public cDDL
    {
    public:
        PKG_ADTF_DDL_DEPRECATED("Use ddl::dd::DataDefinition instead.")
        cDDLDescription(cDDLHeader* poHeader,
                        const tDDLUnitVec& vecDDLUnits = tDDLUnitVec(),
                        const tDDLBaseunitVec& vecDDLBaseunits = tDDLBaseunitVec(),
                        const tDDLPrefixVec& vecDDLPrefixes = tDDLPrefixVec(),
                        const tDDLDTVec& vecDTs = tDDLDTVec(),
                        const tDDLComplexVec& vecStructs = tDDLComplexVec(),
                        const tDDLStreamVec& vecStreams = tDDLStreamVec(),
                        const tDDLEnumVec& vecEnums = tDDLEnumVec(),
                        bool bMergeDefaults = true);
 
        virtual ~cDDLDescription();
 
        tResult Accept(IDDLVisitor *poVisitor);
 
        bool IsInitialized() const;
 
        const A_UTILS_NS::cString& GetName() const;
 
        tResult Create(cDDLHeader* poHeader,
                        tDDLUnitVec vecDDLUnits = tDDLUnitVec(),
                        tDDLBaseunitVec vecDDLBaseunits = tDDLBaseunitVec(),
                        tDDLPrefixVec vecDDLPrefixes = tDDLPrefixVec(),
                        tDDLDTVec vecDTs = tDDLDTVec(), 
                        tDDLComplexVec vecStructs = tDDLComplexVec(),
                        tDDLStreamVec vecStreams = tDDLStreamVec(),
                        tDDLEnumVec vecEnums = tDDLEnumVec());
 
        cDDLHeader * GetHeader() const;
 
        void CloneUnits(const tDDLUnitVec& vecDDLUnits);
 
        void RefUnits(tDDLUnitVec& vecDDLUnits);
 
        void MergeUnits(tDDLUnitVec vecDDLUnits, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void AddUnit(cDDLUnit* poUnit, int nPos = -1);
 
        tDDLUnitVec& GetUnits();
 
        const tDDLUnitVec& GetUnits() const;
 
 
        const cDDLUnit* GetUnitByName(const A_UTILS_NS::cString& strName) const;
 
        cDDLUnit* GetUnitByName(const A_UTILS_NS::cString& strName);
 
        void CloneBaseunits(const tDDLBaseunitVec& vecDDLBaseunits);
 
        void RefBaseunits(tDDLBaseunitVec& vecDDLBaseunits);
 
        void MergeBaseunits(tDDLBaseunitVec vecDDLBaseunits, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void AddBaseunit(cDDLBaseunit* poBaseunit, int nPos = -1);
 
        tDDLBaseunitVec GetBaseunits() const;
 
        const cDDLBaseunit* GetBaseunitByName(const A_UTILS_NS::cString& strName) const;
 
        cDDLBaseunit* GetBaseunitByName(const A_UTILS_NS::cString& strName);
 
        void ClonePrefixes(const tDDLPrefixVec& vecDDLPrefixes);
 
        void RefPrefixes(tDDLPrefixVec& vecDDLPrefixes);
 
        void MergePrefixes(tDDLPrefixVec vecDDLPrefixes, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void AddPrefix(cDDLPrefix* poPrefix, int nPos = -1);
 
        tDDLPrefixVec GetPrefixes() const;
 
        cDDLPrefix* GetPrefixByName(const A_UTILS_NS::cString& strName);
 
        const cDDLPrefix* GetPrefixByName(const A_UTILS_NS::cString& strName) const;
 
        void CloneDatatypes(const tDDLDTVec& vecDDLDataTypes);
 
        void RefDatatypes(tDDLDTVec& vecDDLDataTypes);
 
        
        void RefEnums(tDDLEnumVec& vecDDLEnum);
 
        void MergeEnums(tDDLEnumVec vecDDLEnum, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void CloneEnums(const tDDLEnumVec& vecDDLEnums);
 
        void AddEnum(cDDLEnum* poEnum, int nPos = -1);
 
        cDDLEnum* GetEnumByName(const A_UTILS_NS::cString& strName);
 
        const cDDLEnum* GetEnumByName(const A_UTILS_NS::cString& strName) const;
 
        void MergeDatatypes(tDDLDTVec vecDDLDataTypes, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void AddDatatype(cDDLDataType* poDatatype, int nPos = -1);
 
        tDDLDTVec& GetDatatypes();
 
        const tDDLDTVec& GetDatatypes() const;
 
        tDDLEnumVec& GetEnums();
 
        const tDDLEnumVec& GetEnums() const;
 
        cDDLDataType* GetDataTypeByName(const A_UTILS_NS::cString& strName);
 
        const cDDLDataType* GetDataTypeByName(const A_UTILS_NS::cString& strName) const;
 
        void CloneStructs(const tDDLComplexVec& vecStructs);
 
        void RefStructs(tDDLComplexVec& vecStructs);
 
        void MergeStructs(tDDLComplexVec vecStructs, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void AddStruct(cDDLComplex *poStruct, int nPos = -1);
 
        tDDLComplexVec& GetStructs();
 
        const tDDLComplexVec& GetStructs() const;
 
        const cDDLComplex * GetStructByName(const A_UTILS_NS::cString& strName) const;
 
        cDDLComplex* GetStructByName(const A_UTILS_NS::cString& strName);
 
        tResult RemoveType(const A_UTILS_NS::cString& strName);
 
        tResult RemoveDataType(const A_UTILS_NS::cString& strName);
 
        tResult RemoveComplexDataType(const A_UTILS_NS::cString& strName);
 
        tResult MoveHeaderExcDec(const int nFrom, const int nTo);
 
        tResult MoveBaseunit(const int nFrom, const int nTo);
 
        tResult MovePrefix(const int nFrom, const int nTo);
 
        tResult MoveUnit(const int nFrom, const int nTo);
 
        tResult MoveRefUnit(const int nFrom,
                            const int nTo,
                            const A_UTILS_NS::cString& strParent);
 
        tResult MoveEnum(const int nFrom, const int nTo);
 
        tResult MoveEnumElement(const int nFrom,
                                const int nTo,
                                const A_UTILS_NS::cString& strParent);
 
        tResult MoveDatatype(const int nFrom, const int nTo);
 
        tResult MoveComplexDataType(const int nFrom,
                                    const int nTo);
 
        tResult MoveComplexDataTypeElement(const int nFrom,
                                           const int nTo,
                                           const A_UTILS_NS::cString& strParent);
 
        tResult MoveStream(const int nFrom, const int nTo);
 
        tResult RemoveBaseunit(const A_UTILS_NS::cString& strName);
 
        tResult RemovePrefix(const A_UTILS_NS::cString& strName);
 
        tResult RemoveUnit(const A_UTILS_NS::cString& strName);
 
        tResult RemoveEnum(const A_UTILS_NS::cString& strName);
 
 
        void CloneStreams(const tDDLStreamVec& vecStreams);
 
        void RefStreams(tDDLStreamVec& vecStreams);
 
        void MergeStreams(tDDLStreamVec vecStreams, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
        
        void AddStream(cDDLStream* poStream, int nPos = -1);
 
        tDDLStreamVec& GetStreams();
 
        const tDDLStreamVec& GetStreams() const;
 
        cDDLStream * GetStreamByName(const A_UTILS_NS::cString& strName);
 
        const cDDLStream * GetStreamByName(const A_UTILS_NS::cString& strName) const;
 
        tResult RenameStream(const A_UTILS_NS::cString& strOldName, const A_UTILS_NS::cString& strNewName);
 
        tResult RemoveStream(const A_UTILS_NS::cString& strName);
 
        void CloneStreamMetaTypes(const tDDLStreamMetaTypeVec& vecStreams);
 
        void RefStreamMetaTypes(tDDLStreamMetaTypeVec& vecStreams);
 
        void MergeStreamMetaTypes(tDDLStreamMetaTypeVec vecStreams, uint32_t ui32JoinFlags = 0, tDDLVec* pvecDeleteData = NULL);
 
        void AddStreamMetaType(cDDLStreamMetaType* poStream, int nPos = -1);
 
        tDDLStreamMetaTypeVec& GetStreamMetaTypes();
 
        const tDDLStreamMetaTypeVec& GetStreamMetaTypes() const;
 
        cDDLStreamMetaType * GetStreamMetaTypeByName(const A_UTILS_NS::cString& strName);
 
        const cDDLStreamMetaType * GetStreamMetaTypeByName(const A_UTILS_NS::cString& strName) const;
 
        tResult RenameStreamMetaType(const A_UTILS_NS::cString& strOldName, const A_UTILS_NS::cString& strNewName);
 
        tResult RemoveStreamMetaType(const A_UTILS_NS::cString& strName);
 
        tResult Merge(cDDLDescription &oDDL, uint32_t ui32JoinFlags = 0);
 
        tResult RestoreLevel (int const nLevel);
 
        static cDDLDescription * CreateDefault(int const nCreationLevel = 1, bool bSorted = true);
 
        static cDDLDescription * CreateDefault(double fVersion, int const nCreationLevel, bool bSorted = true);
 
    private:    // methods
        cDDLDescription();
 
        template<typename T>
        static bool MergePart(cDDLContainer<T> &vecMemberData,
                               cDDLContainer<T> &vecOtherData,
                               uint32_t ui32JoinFlags,
                               tDDLVec* pvecDeleteDataMem,
                               cDDLDescription* pDesc,
                               const bool& bRefs,
                               const bool& bDeleteNonOverwritten = false);
 
    private:    // members
        cDDLHeader * m_poHeader;
        tDDLUnitVec m_vecDDLUnits;
        tDDLBaseunitVec m_vecDDLBaseunits;
        tDDLPrefixVec m_vecDDLPrefixes;
        tDDLDTVec m_vecDDLDataTypes;
        tDDLEnumVec m_vecDDLEnums;
        tDDLComplexVec m_vecStructs;
        tDDLStreamVec m_vecStreams;
        tDDLStreamMetaTypeVec m_vecStreamMetaTypes;
        bool m_bInitFlag;
        bool m_bMergeDefaults;
    };
 
    template < class vectorType > class cDDLAutoVec
    {
        private:
            std::vector < vectorType* >* m_pSyncVec;
        public:
            cDDLAutoVec(std::vector< vectorType* >* pSyncVec)
            {
                Set(pSyncVec);
            };
            ~cDDLAutoVec()
            {
                AutoDelete();
            };
            void Reset()
            {
                m_pSyncVec = NULL;
            }
            void Set(std::vector< vectorType* >* pSyncVec)
            {
                Reset();
                m_pSyncVec = pSyncVec;
            }
        private:
            void AutoDelete()
            {
                if (m_pSyncVec)
                {
                    std::transform(m_pSyncVec->begin(), m_pSyncVec->end(), m_pSyncVec->begin(), cDDLDescription::DeleteChild< vectorType > );
                }
            }
    };
 
}   // namespace adtf_ddl
 
#endif  // _DDL_DESCRIPTION_H_INCLUDED_