mitkDICOMTagPath.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef mitkDICOMTagPath_h
#define mitkDICOMTagPath_h

#include <vector>

#include <mitkDICOMTag.h>

#include <MitkDICOMReaderExports.h>


namespace mitk
{
  class MITKDICOMREADER_EXPORT DICOMTagPath
  {
  public:
    typedef int ItemSelectionIndex;

    struct MITKDICOMREADER_EXPORT NodeInfo
    {
      enum class NodeType
      {
        Invalid = 0,  //*< Node is non existant or invalid.
        Element,  //*< Selects an specific element given the node name.
        SequenceSelection, //*< Selects an specific item in a sequence of items and has a item selector ("[n]").
        AnySelection, //*< Selects all items of a specific element ("[*]").
        AnyElement,  //*< Selects any element/item. Node name is wildcarded ("*"); item selection as well implictily.
      };

      NodeType type;
      DICOMTag tag;
      ItemSelectionIndex selection;

      NodeInfo();
      NodeInfo(const DICOMTag& tag, NodeType type = NodeType::Element, ItemSelectionIndex index = 0);
      bool Matches(const NodeInfo& right) const;

      bool operator == (const NodeInfo& right) const;
    };

    typedef std::vector<NodeInfo> NodeInfoVectorType;
    typedef NodeInfoVectorType::size_type PathIndexType;

    bool IsEmpty() const;

    bool IsExplicit() const;

    bool HasItemSelectionWildcardsOnly() const;

    PathIndexType Size() const;

    PathIndexType AddNode(const NodeInfo& newNode);

    const NodeInfo& GetNode(const PathIndexType& index) const;

    NodeInfo& GetNode(const PathIndexType& index);

    NodeInfo& GetFirstNode();

    const NodeInfo& GetFirstNode() const;

    NodeInfo& GetLastNode();

    const NodeInfo& GetLastNode() const;

    const NodeInfoVectorType& GetNodes() const;

    std::string ToStr() const;

    DICOMTagPath& FromStr(const std::string& pathStr);

    bool operator == (const DICOMTagPath& path) const;

    bool operator < (const DICOMTagPath& right) const;

    bool Equals(const DICOMTagPath& path) const;

    DICOMTagPath& operator = (const DICOMTagPath& path);

    DICOMTagPath& AddAnyElement();
    DICOMTagPath& AddElement(unsigned int group, unsigned int element);
    DICOMTagPath& AddAnySelection(unsigned int group, unsigned int element);
    DICOMTagPath& AddSelection(unsigned int group, unsigned int element, ItemSelectionIndex index);

    DICOMTagPath();
    DICOMTagPath(const DICOMTagPath& path);
    DICOMTagPath(const DICOMTag& tag);
    explicit DICOMTagPath(unsigned int group, unsigned int element);

    ~DICOMTagPath();

    virtual void Reset();

  protected:
    NodeInfoVectorType m_NodeInfos;

    static bool DICOMTagPathesMatch(const DICOMTagPath& left, const DICOMTagPath& right);
  };

  typedef std::vector<DICOMTagPath> DICOMTagPathList;

  MITKDICOMREADER_EXPORT std::ostream& operator<<(std::ostream& os, const DICOMTagPath& path);

  MITKDICOMREADER_EXPORT std::string DICOMTagPathToPropertyRegEx(const DICOMTagPath& tagPath);
  MITKDICOMREADER_EXPORT std::string DICOMTagPathToPersistenceKeyRegEx(const DICOMTagPath& tagPath);
  MITKDICOMREADER_EXPORT std::string DICOMTagPathToPersistenceKeyTemplate(const DICOMTagPath& tagPath);
  MITKDICOMREADER_EXPORT std::string DICOMTagPathToPersistenceNameTemplate(const DICOMTagPath& tagPath);

  MITKDICOMREADER_EXPORT std::string DICOMTagPathToDCMTKSearchPath(const DICOMTagPath& tagPath);

  MITKDICOMREADER_EXPORT DICOMTagPath PropertyNameToDICOMTagPath(const std::string& propertyName);
  MITKDICOMREADER_EXPORT std::string DICOMTagPathToPropertyName(const DICOMTagPath& tagPath);
}

#endif