otbWrapperParameter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt for details.


     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __otbWrapperParameter_h
#define __otbWrapperParameter_h

#include "otbMacro.h"
#include "itkObject.h"
#include "boost/any.hpp"
#include "itkObjectFactory.h"

#include "otbWrapperTypes.h"

namespace otb
{
namespace Wrapper
{
enum DefaultValueMode
  {
    DefaultValueMode_UNKNOWN,
    DefaultValueMode_RELATIVE,

    DefaultValueMode_ABSOLUTE
  };


class Parameter
  : public itk::Object
{
public:
  typedef Parameter                     Self;
  typedef itk::Object                   Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(Parameter, itk::Object);

  itkSetStringMacro(Name);

  itkGetStringMacro(Name);

  itkSetStringMacro(Description);

  itkGetStringMacro(Description);

  itkSetStringMacro(Key);

  itkGetStringMacro(Key);

  itkSetMacro(Active, bool);

  itkGetConstMacro(Active, bool);

  itkSetMacro(Mandatory, bool);

  itkGetConstMacro(Mandatory, bool);

  itkBooleanMacro(Mandatory);

  itkSetMacro(AutomaticValue, bool);

  itkGetConstMacro(AutomaticValue, bool);

  itkBooleanMacro(AutomaticValue);

  itkSetEnumMacro(DefaultValueMode, DefaultValueMode);

  itkGetEnumMacro(DefaultValueMode, DefaultValueMode);

  itkSetEnumMacro(UserLevel, UserLevel);

  itkGetEnumMacro(UserLevel, UserLevel);

  itkSetEnumMacro(Role, Role);

  itkGetEnumMacro(Role, Role);

  virtual void Reset()
  {
  }

  virtual bool HasValue() const
  {
    itkExceptionMacro(<<"HasValue() method must be re-implemented by sub-classes.");
  }

  virtual bool HasUserValue() const
  {
    return HasValue() && m_UserValue;
  }

  virtual void SetUserValue(bool isUserValue)
  {
    m_UserValue = isUserValue;
  }

  virtual void ClearValue()
  {
    itkExceptionMacro(<<"ClearValue() method must be re-implemented by sub-classes.");
  }
  
  virtual void SetRoot(const Parameter::Pointer  root)
  {
    m_Root = root.GetPointer();
  }

  virtual const Parameter::Pointer GetRoot()
  {
    return m_Root.GetPointer();
  }

  virtual bool IsRoot()
  {
    return (this == m_Root.GetPointer());
  }

  virtual void AddChild(Parameter::Pointer child)
  {
    m_ChildrenList.push_back(child);
  }

  virtual std::vector<Parameter::Pointer > GetChildrenList()
  {
    return m_ChildrenList;
  }

  virtual bool IsChecked()
  {
    return m_IsChecked;
  }

  virtual void SetChecked(const bool value)
  {
    m_IsChecked = value;
  }

protected:
  Parameter() : m_Name(""),
                m_Description(""),
                m_Key(""),
                m_Mandatory(true),
                m_Active(false),
                m_UserValue(false),
                m_AutomaticValue(false),
                m_DefaultValueMode(DefaultValueMode_UNKNOWN),
                m_UserLevel(UserLevel_Basic),
                m_Role(Role_Input),
                m_Root(this),
                m_IsChecked(false)
  {}

  virtual ~Parameter()
  {}

  std::string                        m_Name;

  std::string                        m_Description;

  std::string                        m_Key;

  bool                               m_Mandatory;

  bool                               m_Active;

  bool                               m_UserValue;

  bool                               m_AutomaticValue;

  DefaultValueMode                   m_DefaultValueMode;

  UserLevel                          m_UserLevel;

  Role                               m_Role;

  itk::WeakPointer<Parameter>        m_Root;

  std::vector<Parameter::Pointer >   m_ChildrenList;

  bool                               m_IsChecked;

private:
  Parameter(const Parameter &); //purposely not implemented
  void operator =(const Parameter&); //purposely not implemented

}; // End class Parameter

} // End namespace Wrapper
} // End namespace otb

#endif