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 <mitkExceptionMacro.h>

#include <MitkCoreExports.h>

namespace mitk
{
  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();

    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);
} // namespace mitk

#endif