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,           
      Implicit_Data = 1,  
      Connected_Data = 2, 
      Connected_ID = 4    
    };

    static PropertyKeyPath GetRootKeyPath();

    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;

    RelationType HasRelation(const IPropertyProvider *source, const IPropertyProvider *destination) const;

    RelationUIDVectorType GetExistingRelations(const IPropertyProvider *source) 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 minimalRelation = RelationType::Implicit_Data) const;
    NodePredicateBase::ConstPointer GetDestinationsDetector(
      const IPropertyProvider *source, RelationType minimalRelation = RelationType::Implicit_Data) const;
    NodePredicateBase::ConstPointer GetDestinationDetector(const IPropertyProvider *source,
                                                           RelationUIDType relationUID) const;

    void Disconnect(IPropertyOwner *source, const IPropertyProvider *destination) const;
    void Disconnect(IPropertyOwner *source, RelationUIDType relationUID) const;

  protected:
    PropertyRelationRuleBase() = default;
    ~PropertyRelationRuleBase() override = default;

    using InstanceIDType = std::string;
    using InstanceIDVectorType = std::vector<InstanceIDType>;
    static InstanceIDType NULL_INSTANCE_ID();

    InstanceIDVectorType GetInstanceID_IDLayer(const IPropertyProvider *source,
                                                                         const IPropertyProvider *destination) const;

    virtual InstanceIDVectorType GetInstanceID_datalayer(const IPropertyProvider *source,
                                                         const IPropertyProvider *destination) const = 0;

    virtual bool HasImplicitDataRelation(const IPropertyProvider *source,
                                         const IPropertyProvider *destination) 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 InstanceIDType &instanceID) 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;

    itk::LightObject::Pointer InternalClone() const override;

    static std::vector<std::string> GetPropertyKeys(const mitk::IPropertyProvider *owner);

  private:
    static RelationUIDType CreateRelationUID();

    InstanceIDType CreateNewRelationInstance(IPropertyOwner *source, const RelationUIDType &relationUID) const;
  };

  class NoPropertyRelationException : public Exception
  {
  public:
    mitkExceptionClassMacro(NoPropertyRelationException, Exception)
  };

} // namespace mitk

#endif