mitkPropertyKeyPath.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 mitkPropertyKeyPath_h
#define mitkPropertyKeyPath_h
 
#include <string>
#include <vector>
#include <map>
 
#include <mitkExceptionMacro.h>
 
#include <MitkCoreExports.h>
 
namespace mitk
{
  class IPropertyProvider;
 
  class MITKCORE_EXPORT PropertyKeyPath final
  {
  public:
    using ItemSelectionIndex = std::size_t;
    using ElementNameType = std::string;
 
    struct MITKCORE_EXPORT NodeInfo
    {
      enum class NodeType
      {
        Invalid = 0,      //*< Node does not exist or is invalid.
        Element,          //*< Selects an specific element given the node name.
        ElementSelection, //*< 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;
      ElementNameType name;
      ItemSelectionIndex selection;
 
      NodeInfo();
      NodeInfo(const ElementNameType &name, NodeType type = NodeType::Element, ItemSelectionIndex index = 0);
      bool Matches(const NodeInfo &right) const;
 
      bool operator==(const NodeInfo &right) const;
    };
 
    using NodeInfoVectorType = std::vector<NodeInfo>;
    using PathIndexType = NodeInfoVectorType::size_type;
 
    bool IsEmpty() const;
 
    bool IsExplicit() const;
 
    bool HasItemSelectionWildcardsOnly() const;
 
    PathIndexType GetSize() 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;
 
    bool operator==(const PropertyKeyPath &path) const;
 
    bool operator<(const PropertyKeyPath &right) const;
 
    bool operator<=(const PropertyKeyPath &right) const;
 
    bool operator>=(const PropertyKeyPath &right) const;
 
    bool operator>(const PropertyKeyPath &right) const;
 
    bool Equals(const PropertyKeyPath &path) const;
 
    PropertyKeyPath &operator=(const PropertyKeyPath &path);
 
    PropertyKeyPath &AddAnyElement();
    PropertyKeyPath &AddElement(const ElementNameType &name);
    PropertyKeyPath &AddAnySelection(const ElementNameType &name);
    PropertyKeyPath &AddSelection(const ElementNameType &name, ItemSelectionIndex index);
 
    PropertyKeyPath();
    PropertyKeyPath(const PropertyKeyPath &path);
    PropertyKeyPath(const std::initializer_list< ElementNameType >& list);
 
    ~PropertyKeyPath();
 
    void Reset();
 
  protected:
    NodeInfoVectorType m_NodeInfos;
 
    static bool PropertyKeyPathsMatch(const PropertyKeyPath &left, const PropertyKeyPath &right);
  };
 
  class MITKCORE_EXPORT InvalidPathNodeException : public mitk::Exception
  {
  public:
    mitkExceptionClassMacro(InvalidPathNodeException, mitk::Exception);
  };
 
  MITKCORE_EXPORT std::ostream &operator<<(std::ostream &os, const PropertyKeyPath &path);
 
  MITKCORE_EXPORT std::string PropertyKeyPathToPropertyRegEx(const PropertyKeyPath &tagPath);
  MITKCORE_EXPORT std::string PropertyKeyPathToPersistenceKeyRegEx(const PropertyKeyPath &tagPath);
  MITKCORE_EXPORT std::string PropertyKeyPathToPersistenceKeyTemplate(const PropertyKeyPath &tagPath);
  MITKCORE_EXPORT std::string PropertyKeyPathToPersistenceNameTemplate(const PropertyKeyPath &tagPath);
 
  MITKCORE_EXPORT PropertyKeyPath PropertyNameToPropertyKeyPath(const std::string &propertyName);
  MITKCORE_EXPORT std::string PropertyKeyPathToPropertyName(const PropertyKeyPath &tagPath);
 
  MITKCORE_EXPORT std::map<PropertyKeyPath::ItemSelectionIndex, std::string>
    FindIndexedPropertyNames(const IPropertyProvider* provider, const PropertyKeyPath& path);
 
} // namespace mitk
 
#endif