mitkGenericProperty.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 mitkGenericProperty_h
#define mitkGenericProperty_h
 
#include <sstream>
#include <cstdlib>
#include <string>
 
#include "mitkBaseProperty.h"
#include "mitkNumericTypes.h"
#include <MitkCoreExports.h>
 
namespace mitk
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4522)
#endif
 
  template <typename T>
  class MITK_EXPORT GenericProperty : public BaseProperty
  {
  public:
    mitkClassMacro(GenericProperty, BaseProperty);
    mitkNewMacro1Param(GenericProperty<T>, T);
    itkCloneMacro(Self);
 
      typedef T ValueType;
 
    itkSetMacro(Value, T);
    itkGetConstMacro(Value, T);
 
    std::string GetValueAsString() const override
    {
      std::stringstream myStr;
      myStr << GetValue();
      return myStr.str();
    }
 
    bool ToJSON(nlohmann::json&) const override
    {
      return false;
    }
 
    bool FromJSON(const nlohmann::json&) override
    {
      return false;
    }
 
    using BaseProperty::operator=;
 
  protected:
    GenericProperty() {}
    GenericProperty(T x) : m_Value(x) {}
    GenericProperty(const GenericProperty &other) : BaseProperty(other), m_Value(other.m_Value) {}
    T m_Value;
 
  private:
    // purposely not implemented
    GenericProperty &operator=(const GenericProperty &);
 
    itk::LightObject::Pointer InternalClone() const override
    {
      itk::LightObject::Pointer result(new Self(*this));
      result->UnRegister();
      return result;
    }
 
    bool IsEqual(const BaseProperty &other) const override
    {
      return (this->m_Value == static_cast<const Self &>(other).m_Value);
    }
 
    bool Assign(const BaseProperty &other) override
    {
      this->m_Value = static_cast<const Self &>(other).m_Value;
      return true;
    }
  };
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
} // namespace mitk
 
#define mitkDeclareGenericProperty(PropertyName, Type, Export)                                                         \
                                                                                                                       \
  class Export PropertyName : public GenericProperty<Type>                                                             \
                                                                                                                       \
  {                                                                                                                    \
  public:                                                                                                              \
    mitkClassMacro(PropertyName, GenericProperty<Type>);                                                               \
    itkFactorylessNewMacro(Self);                                                                                      \
    itkCloneMacro(Self);                                                                                               \
    mitkNewMacro1Param(PropertyName, Type);                                                                            \
                                                                                                                       \
    bool ToJSON(nlohmann::json& j) const override;                                                                     \
    bool FromJSON(const nlohmann::json& j) override;                                                                   \
                                                                                                                       \
    using BaseProperty::operator=;                                                                                     \
                                                                                                                       \
  protected:                                                                                                           \
    PropertyName();                                                                                                    \
    PropertyName(const PropertyName &);                                                                                \
    PropertyName(Type x);                                                                                              \
                                                                                                                       \
  private:                                                                                                             \
    itk::LightObject::Pointer InternalClone() const override;                                                          \
  };
 
#define mitkDefineGenericProperty(PropertyName, Type, DefaultValue)                                                    \
  mitk::PropertyName::PropertyName() : Superclass(DefaultValue) {}                                                     \
  mitk::PropertyName::PropertyName(const PropertyName &other) : GenericProperty<Type>(other) {}                        \
  mitk::PropertyName::PropertyName(Type x) : Superclass(x) {}                                                          \
  itk::LightObject::Pointer mitk::PropertyName::InternalClone() const                                                  \
  {                                                                                                                    \
    itk::LightObject::Pointer result(new Self(*this));                                                                 \
    result->UnRegister();                                                                                              \
    return result;                                                                                                     \
  }                                                                                                                    \
  bool mitk::PropertyName::ToJSON(nlohmann::json& j) const                                                             \
  {                                                                                                                    \
    j = this->GetValue();                                                                                              \
    return true;                                                                                                       \
  }                                                                                                                    \
                                                                                                                       \
  bool mitk::PropertyName::FromJSON(const nlohmann::json& j)                                                           \
  {                                                                                                                    \
    this->SetValue(j.get<Type>());                                                                                     \
    return true;                                                                                                       \
  }
 
#endif