mitkDICOMTagPath.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkDICOMTagPath_h
#define mitkDICOMTagPath_h
 
#include <vector>
 
#include <mitkDICOMTag.h>
 
#include <MitkDICOMExports.h>
 
 
namespace mitk
{
  class MITKDICOM_EXPORT DICOMTagPath
  {
  public:
    typedef int ItemSelectionIndex;
 
    struct MITKDICOM_EXPORT NodeInfo
    {
      enum class NodeType
      {
        Invalid = 0,       
        Element,           
        SequenceSelection, 
        AnySelection,      
        AnyElement,        
      };
 
      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 operator + (const DICOMTagPath& right) const;
 
    DICOMTagPath operator + (const std::string& pathStr) const;
 
    DICOMTagPath& operator += (const DICOMTagPath& right);
 
    DICOMTagPath& operator += (const std::string& pathStr);
 
    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);
 
    virtual ~DICOMTagPath();
 
    virtual void Reset();
 
  protected:
    NodeInfoVectorType m_NodeInfos;
 
    static bool DICOMTagPathesMatch(const DICOMTagPath& left, const DICOMTagPath& right);
  };
 
  typedef std::vector<DICOMTagPath> DICOMTagPathList;
 
  MITKDICOM_EXPORT std::ostream& operator<<(std::ostream& os, const DICOMTagPath& path);
 
  MITKDICOM_EXPORT DICOMTagPath operator + (const std::string& pathStr, const DICOMTagPath& right);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToPropertyRegEx(const DICOMTagPath& tagPath);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToPersistenceKeyRegEx(const DICOMTagPath& tagPath);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToPersistenceKeyTemplate(const DICOMTagPath& tagPath);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToPersistenceNameTemplate(const DICOMTagPath& tagPath);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToDCMTKSearchPath(const DICOMTagPath& tagPath);
 
  MITKDICOM_EXPORT DICOMTagPath PropertyNameToDICOMTagPath(const std::string& propertyName);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToPropertyName(const DICOMTagPath& tagPath);
 
  MITKDICOM_EXPORT std::string DICOMTagPathToReadableName(
    const DICOMTagPath& tagPath,
    bool includeTagNumbers = false);
}
 
#endif