MeVis/Foundation/Sources/DicomTree/MLDicomTree/DCMTree_Tree.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// **InsertLicense** code
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

#ifndef CLASS_DCMTREE_TREE
#define CLASS_DCMTREE_TREE

#include "DCMTree_Lib.h"
#include "DCMTree_TagId.h"
#include "DCMTree_Defines.h"

#ifdef _MSC_VER
  // 4365: signed/unsigned mismatch
  // 4548: expression before comma has no effect; expected expression with side-effect
  #pragma warning (push)
  #pragma warning (disable : 4365 4548)
#endif
#include <iostream>
#include <fstream>
#include <set>
#ifdef _MSC_VER
  #pragma warning (pop)
#endif

namespace DCMTree
{
    class DCMTREE_EXPORT Tree:public DCMTree_Serialization::Serializable,public DCMTree_Serialization::Deserializable
    {
    public:
        Tree();

        Tree (const Tree &other);

        Tree (Const_TreePtr parent);

        virtual ~Tree();

        Const_TreePtr parent() const;

        Const_TreePtr root () const;

        bool hasParent() const;

        bool hasDict() const;

        Const_DictPtr getDict () const;

        void setDict (Const_DictPtr dictPtr);

        Tree &operator= (const Tree &other);

        const TagPtrMap &tags();

        boost::uint32_t tagsSize() const;

        TagIdVectorPtr tagIds (TagSelector sel=AllTags) const;

        TagIdVectorPtr tagIds (const TagId &fromtag, const TagId &totag, TagSelector sel=AllTags) const;

        bool hasTag (const TagId &tagid, TagSelector sel=AllTags) const;

        bool hasTag (const std::string& tagName, TagSelector sel=AllTags) const;

        Const_TagPtr getTag (const TagId &tagid, TagSelector sel=AllTags) const;

        Const_TagPtr getTag (const TagId &tagid, const std::string& privateCreator, Vr privateVr=UN, TagSelector sel=AllTags) const;

        Const_TagPtr getTag (const std::string& tagName, TagSelector sel=AllTags) const;
        
        TagPtr getTag_rw (const TagId &tagid);

        Const_TagPtrMapPtr getTags (TagSelector sel=AllTags) const;

        Const_TagPtrMapPtr getTags (const TagId &fromtag, const TagId &totag, TagSelector sel=AllTags) const;
        
        void setTag (const TagId &tagid, Const_TagPtr tagdata);
        void setTag (Const_TagPtr tagdata);

        void setTags (Const_TreePtr tags);

        void addTag (const TagId &tagid, TagPtr tagdata);
        void addTag (TagPtr tagdata);

        /* add the given tags to this, NO copy, parent tags are ignored **/
        void addTags (TreePtr tags);

        void removeTag (const TagId &tagid);

        void removeTags (TagIdVectorPtr tags);
        
        TreePtr copy() const;

        TreePtr copy (const TagId &fromtag, const TagId &totag) const;

        TreePtr copy (TagIdVectorPtr tags) const;

        TreePtr mergedCopy (TagSelector sel) const;


        std::string getPrivateCreator (TagId tagId) const;

        unsigned short findPrivateSlot (unsigned short groupid, const std::string &creator, 
                                        bool newOrExisting = false) const;

        unsigned short getPrivateSlot (unsigned short groupid, const std::string &creator);

        void removePrivateTags (unsigned short groupId, unsigned short slot);

        void convertCharacterSet (const std::string &originalcharacterset,const std::string &newcharacterset);

        void fromStream (std::istream &in, bool readName=false);

        void toStream (std::ostream &out, bool writeName=false) const;

        virtual void serializeX (DCMTree_Serialization::Sink &sink) const;
        virtual void deserializeX (DCMTree_Serialization::Source &source);


    private:

        void addTagsToSet (std::set<RawTagId> &tagIdSet, TagSelector sel, const TagId &fromtag, const TagId &totag) const;

        void addTagsToMap (Const_TagPtrMap &tagMap, TagSelector sel, const TagId &fromtag, const TagId &totag) const;

        Const_TagPtr const_tag4tagid (const TagId &tagid,const TagSelector sel) const;

        TagPtr tag4tagid (const TagId &tagid);

        void checkForTag (const TagId &tagid,const TagSelector sel) const;

        bool isDeleted (const TagId &tagid) const;

        void markAsDeleted (const TagId &tagid);

        void undelete (const TagId &tagid);


        TagPtrMap _tags;

        std::set<RawTagId> _deletedtags;

        Const_TreePtr _parent;

        Const_DictPtr _dictionary;
    };


    inline std::ostream &operator << (std::ostream &out,const Tree &t)
    {
        t.toStream (out, false);
        return out;
    }


    inline std::istream &operator >> (std::istream &in,Tree &t)
    {
        t.fromStream (in, false);
        return in;
    }
}

#endif