mitkPropertyRelationRuleBase.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 mitkPropertyRelationRuleBase_h
#define mitkPropertyRelationRuleBase_h
 
#include <mitkIPropertyOwner.h>
#include <mitkIdentifiable.h>
 
#include <mitkException.h>
#include <mitkNodePredicateBase.h>
#include <mitkPropertyKeyPath.h>
 
#include <MitkCoreExports.h>
 
#include <string>
 
namespace mitk
{
  class MITKCORE_EXPORT PropertyRelationRuleBase : public itk::Object
  {
  public:
    mitkClassMacroItkParent(PropertyRelationRuleBase, itk::Object);
    itkCloneMacro(Self);
    itkCreateAnotherMacro(Self);
 
    using RuleIDType = std::string;
    using RelationUIDType = Identifiable::UIDType;
    using RelationUIDVectorType = std::vector<RelationUIDType>;
 
    enum class RelationType
    {
      None = 0,           
      Data = 1,  
      ID = 2,    
      Complete = 3    
    };
    using RelationVectorType = std::vector<RelationType>;
 
    static PropertyKeyPath GetRootKeyPath();
 
    using InstanceIDType = std::string;
    static PropertyKeyPath GetRIIPropertyKeyPath(const std::string propName, const InstanceIDType& instanceID);
    static PropertyKeyPath GetRIIRelationUIDPropertyKeyPath(const InstanceIDType& instanceID = "");
    static PropertyKeyPath GetRIIRuleIDPropertyKeyPath(const InstanceIDType& instanceID = "");
    static PropertyKeyPath GetRIIDestinationUIDPropertyKeyPath(const InstanceIDType& instanceID = "");
 
    virtual RuleIDType GetRuleID() const = 0;
 
    virtual std::string GetDisplayName() const = 0;
 
    virtual std::string GetSourceRoleName() const = 0;
    virtual std::string GetDestinationRoleName() const = 0;
 
    virtual bool IsAbstract() const;
 
    virtual bool IsSourceCandidate(const IPropertyProvider *owner) const;
 
    virtual bool IsDestinationCandidate(const IPropertyProvider *owner) const;
 
    bool IsSource(const IPropertyProvider *owner) const;
 
    RelationVectorType GetRelationTypes(const IPropertyProvider* source, const IPropertyProvider* destination) const;
 
    bool HasRelation(const IPropertyProvider *source, const IPropertyProvider *destination, RelationType requiredRelation = RelationType::None) const;
 
    RelationUIDVectorType GetExistingRelations(const IPropertyProvider *source, RelationType layer = RelationType::None) const;
 
    RelationUIDVectorType GetRelationUIDs(const IPropertyProvider *source, const IPropertyProvider *destination) const;
 
    RelationUIDType GetRelationUID(const IPropertyProvider *source, const IPropertyProvider *destination) const;
 
    NodePredicateBase::ConstPointer GetSourceCandidateIndicator() const;
    NodePredicateBase::ConstPointer GetDestinationCandidateIndicator() const;
    NodePredicateBase::ConstPointer GetConnectedSourcesDetector() const;
    NodePredicateBase::ConstPointer GetSourcesDetector(
      const IPropertyProvider *destination, RelationType exclusiveRelation = RelationType::None) const;
    NodePredicateBase::ConstPointer GetDestinationsDetector(
      const IPropertyProvider *source, RelationType exclusiveRelation = RelationType::None) const;
    NodePredicateBase::ConstPointer GetDestinationDetector(const IPropertyProvider *source,
                                                           RelationUIDType relationUID) const;
 
    void Disconnect(IPropertyOwner *source, const IPropertyProvider *destination, RelationType layer = RelationType::Complete) const;
    void Disconnect(IPropertyOwner *source, RelationUIDType relationUID, RelationType layer = RelationType::Complete) const;
 
    std::vector<PropertyKeyPath> GetRelationPropertyPaths(const IPropertyProvider* source,
      RelationUIDType relationUID, RelationType layer = RelationType::Data) const;
 
  protected:
    PropertyRelationRuleBase() = default;
    PropertyRelationRuleBase(const PropertyRelationRuleBase &) {}
    ~PropertyRelationRuleBase() override = default;
 
    using InstanceIDVectorType = std::vector<InstanceIDType>;
    static InstanceIDType NULL_INSTANCE_ID();
 
    InstanceIDVectorType GetInstanceID_IDLayer(const IPropertyProvider *source,
                                                                         const IPropertyProvider *destination) const;
 
    using DataRelationUIDVectorType = std::vector< std::pair<RelationUIDType, RuleIDType> >;
    virtual DataRelationUIDVectorType GetRelationUIDs_DataLayer(const IPropertyProvider * source,
      const IPropertyProvider * destination, const InstanceIDVectorType& instances_IDLayer) const = 0;
 
    RelationUIDType GetRelationUIDByInstanceID(const IPropertyProvider *source, const InstanceIDType &instanceID) const;
    InstanceIDType GetInstanceIDByRelationUID(const IPropertyProvider *source,
                                              const RelationUIDType &relationUID) const;
 
    RelationUIDType Connect(IPropertyOwner *source, const IPropertyProvider *destination) const;
 
    virtual void Connect_datalayer(IPropertyOwner *source,
                                   const IPropertyProvider *destination,
                                   const InstanceIDType &instanceID) const = 0;
 
    virtual void Disconnect_datalayer(IPropertyOwner *source, const RelationUIDType & relationUID) const = 0;
 
    virtual bool IsSupportedRuleID(const RuleIDType& ruleID) const;
 
    std::string GetRIIPropertyRegEx(const std::string propName = "", const InstanceIDType &instanceID = "") const;
 
    static InstanceIDType GetInstanceIDByPropertyName(const std::string propName);
 
    RuleIDType GetRuleIDByInstanceID(const IPropertyProvider *source,
      const InstanceIDType &instanceID) const;
    std::string GetDestinationUIDByInstanceID(const IPropertyProvider * source,
      const InstanceIDType & instanceID) const;
 
    static std::vector<std::string> GetPropertyKeys(const IPropertyProvider *owner);
 
    const Identifiable* CastProviderAsIdentifiable(const mitk::IPropertyProvider* provider) const;
 
  private:
    static RelationUIDType CreateRelationUID();
 
    InstanceIDType CreateNewRelationInstance(IPropertyOwner *source, const RelationUIDType &relationUID) const;
  };
 
  class NoPropertyRelationException : public Exception
  {
  public:
    mitkExceptionClassMacro(NoPropertyRelationException, Exception)
  };
 
} // namespace mitk
 
#endif