algorithm.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */

#ifndef CARTOBASE_ALGORITHM_ALGORITHM_H
#define CARTOBASE_ALGORITHM_ALGORITHM_H


//===========================================================================//
//                                                                           //
// WARNING : All code here is under construction. Do not use it.             //
//                                                                           //
//===========================================================================//


#include <cartobase/object/object.h>
#include <cartobase/object/property.h>

namespace carto {

  //-----------------//
 //  BaseParameter  //
//-----------------//

class BaseParameter
{
public:
  virtual ~BaseParameter();
};


  //----------------//
 //  Parameter<T>  //
//----------------//

template <typename T>
  class ParameterModifier;

template <typename T>
class Parameter : public BaseParameter
{
 public:
  inline Parameter() {}
  inline Parameter( T &ref, const std::string &name, 
                    const std::string &doc ) :
    _pValue( &ref ),
    _name( name ),
    _documentation( doc ) {}
  virtual ~Parameter();
  
 private:
  
  friend class ParameterModifier<T>;
  
  T *_pValue;
  std::string _name;
  std::string _documentation;
  bool _input;
  bool _output;
  std::vector< std::pair< std::string, T > > _choices;
  bool _optional;
};


  //-------------//
 //  Algorithm  //
//-------------//

class Algorithm
{
public:

  Algorithm( const std::string &name );


protected:

  template <typename T>
  ParameterModifier<T> inputParameter( T &ref, const std::string &name, 
                                       const std::string &documentation );
  template <typename T>
  ParameterModifier<T> outputParameter( T &ref, const std::string &name, 
                                        const std::string &documentation );

private:

  std::string _name;

  // It is not going to be a vector in the future, maybe a kind of ParameterSet
  std::vector< rc_ptr< BaseParameter > > _parameters;
};


  //------------------------//
 //  ParameterModifier<T>  //
//------------------------//

template <typename T>
class ParameterModifier
{
public:
  
  inline ParameterModifier( const ParameterModifier<T> &pm ) :
  _parameter( pm._parameter ) {}

  inline ParameterModifier( Parameter<T> &p ) :
  _parameter( p ) {}
  
  inline ParameterModifier<T> optional( bool o = true ) 
  { 
    _parameter._optional = o;
    return *this;
  }
  
  inline ParameterModifier<T> choice( const T &value )
  {
    return choices( "", value );
  }

  inline ParameterModifier<T> choice( const std::string &label,
                                       const T &value )
  { 
    _parameter._choices.push_back( std::pair<std::string, T>( label,
                                                              value ) );
    return *this; 
  }
  
 private:
  
  Parameter<T> &_parameter;
};


  //-------------------//
 //  AlgorithmCaller  //
//-------------------//

class AlgorithmCaller
{
public:

  AlgorithmCaller( const std::string &algorithmName );
  template <typename T>
  AlgorithmCaller &operator <<( const T & );

  class LaunchExecution {};

private:

  std::string _name;
  std::vector< carto::Object > _unnamedParameters;
  carto::Object _namedParameters;
};

extern const AlgorithmCaller::LaunchExecution execute;

typedef AlgorithmCaller algo;





  //----------------//
 //  Parameter<T>  //
//----------------//

//-----------------------------------------------------------------------------
template <typename T>
Parameter<T>::~Parameter() {}


  //-------------//
 //  Algorithm  //
//-------------//

//-----------------------------------------------------------------------------
template <typename T>
ParameterModifier<T>
Algorithm::inputParameter( T &ref, const std::string &name, 
                           const std::string &doc )
{
  _parameters.push_back( rc_ptr<BaseParameter>( new Parameter<T>( ref, name, doc ) ) );
  // TODO set _input = true;
  return ParameterModifier<T>( static_cast< Parameter<T> &>( *_parameters.rbegin()->get() ) );
}


//-----------------------------------------------------------------------------
template <typename T>
ParameterModifier<T>
Algorithm::outputParameter( T &ref, const std::string &name, 
                            const std::string &doc )
{
  _parameters.push_back( rc_ptr<BaseParameter>( new Parameter<T>( ref, name, doc ) ) );
  // TODO set _output = true;
  return ParameterModifier<T>( static_cast< Parameter<T> &>( *_parameters.rbegin()->get() ) );
}


  //-------------------//
 //  AlgorithmCaller  //
//-------------------//

template <typename T>
AlgorithmCaller &AlgorithmCaller::operator <<( const T &v )
{
  _unnamedParameters.push_back( Object::value( v ) );
  return *this;
}

template <>
AlgorithmCaller &AlgorithmCaller::
operator <<( const  AlgorithmCaller::LaunchExecution & );



} // namespace carto


#endif //ifndef CARTOBASE_ALGORITHM_ALGORITHM_H