DCMTree_Tree.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef DCM_TREE_TREE_H
#define DCM_TREE_TREE_H
 
#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
  // 4623: default constructor was implicitly defined as deleted because a base class default constructor is inaccessible or deleted
  #pragma warning (push)
  #pragma warning (disable : 4365 4548 4623)
#endif
#include "DCMTree_Tag.h"
 
#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(Tree&& other) noexcept = default;
 
        Tree (Const_TreePtr parent);
 
        ~Tree() override = default;
 
        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);
        Tree& operator=(Tree&& other) noexcept = default;
 
        const TagPtrMap &tags();
 
        const TagPtrMap &constTags_rw() const;
 
        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);
 
        bool convertCharacterSet (const std::string &originalcharacterset,const std::string &newcharacterset);
 
        void fromStream (std::istream &in, bool readName=false, size_t maxSize = 0);
 
        void toStream (std::ostream &out, bool writeName=false) const;
 
        void serializeX (DCMTree_Serialization::Sink &sink) const override;
        void deserializeX (DCMTree_Serialization::Source &source) override;
 
 
    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 convertCharacterSet (Const_CharacterSetConverterPtr converter);
 
        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;
    }
 
    template <typename T, T (Tag::*Access)(unsigned) const>
    T value_or(const Tree& tree, TagId id, unsigned index, T alternative)
    {
      T result;
      if (const auto tag = tree.getTag(id); tag && index < tag->numberOfValues() && !tag->isNull(index))
      {
        result = ((*tag).*Access)(index);
      }
      else
      {
        result = std::move(alternative);
      }
      return result;
    }
 
    DCMTREE_EXPORT int value_or(const Tree& tree, TagId id, unsigned index, int alternative);
 
    DCMTREE_EXPORT unsigned int value_or(const Tree& tree, TagId id, unsigned index, unsigned int alternative);
 
    DCMTREE_EXPORT signed short value_or(const Tree& tree, TagId id, unsigned index, signed short alternative);
 
    DCMTREE_EXPORT unsigned short value_or(const Tree& tree, TagId id, unsigned index, unsigned short alternative);
 
    DCMTREE_EXPORT double value_or(const Tree& tree, TagId id, unsigned index, double alternative);
 
    DCMTREE_EXPORT std::string value_or(const Tree& tree, TagId id, unsigned index, std::string alternative);
 
    template <typename T>
    T value_or(const Tree& tree, TagId id, T alternative)
    {
      return value_or(tree, id, 0, std::move(alternative));
    }
}
 
#endif