Option.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------




/* @{ */


#ifndef __MIP_OPTION_
#define __MIP_OPTION_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <assert.h>
#include <stdlib.h>
#include <map>
#include <set>

#include <Types.h>
#include <R2.h>
#include <SsUtils.h>

// For MIPObject
#include <LogTrace.h>

using namespace std;

enum OptionGroupsType {
 OPT_GRP_COMM,
 OPT_GRP_RESO,
 OPT_GRP_TASK,
 OPT_GRP_ALGO,
 OPT_GRP_OTHE,
 NUM_OPT_GRP
};

static const char* OptionGroupsNames[NUM_OPT_GRP] = {
  "Common",
  "Resources",
  "Tasks",
  "Algorithms",
  "Others" };

enum OptionValueType {
 OVT_UNDEF,
 OVT_DECIMAL,
 OVT_POSITION,
 OVT_POSITION3D,
 OVT_POSE,
 OVT_POSE3D,
 OVT_ARRAY_DECIMAL,
 OVT_STRING,
 OVT_INT,
 OVT_BOOL,
 NUM_OVT
};

static const char* OVTNames[NUM_OVT] = {
  "Undef",
  "Decimal",
  "Position",
  "Position3D",
  "Pose",
  "Pose3D",
  "ArrayDecimal",
  "string",
  "int",
  "bool" };

enum ScenarioType {
 KHEPERA_SCEN,
 WEBOTS_SCEN,
 PLAYER_SCEN,
 SCENARIO_NUMS
};

static const char* scenarioNames[SCENARIO_NUMS] = {
  "khepera\0",
  "webots\0",
  "player\0" };


// Forward Declaration for Options this is important.
class Options;

// Forward for GenericOptionListener
class GenericOption;

class DecimalOption;
class PositionOption;
class Position3DOption;
class PoseOption;
class Pose3DOption;    // Added by Marco Cognetti
class DecimalArrayOption; // Added by Marco Cognetti
class StringOption;
class IntOption;
class BoolOption;

// GenericOptionHandler
class OptionListener {
public:
 // does not have to implement all
 virtual void optionChanged(GenericOption* option) {};
 virtual void optionChanged(DecimalOption* option) {};
 virtual void optionChanged(PositionOption* option) {};
 virtual void optionChanged(Position3DOption* option) {};
 virtual void optionChanged(PoseOption* option) {};
 virtual void optionChanged(DecimalArrayOption* option) {};
 virtual void optionChanged(Pose3DOption* option) {};
 virtual void optionChanged(StringOption* option) {};
 virtual void optionChanged(IntOption* option) {};
 virtual void optionChanged(BoolOption* option) {};
};

typedef set<OptionListener*> OptionListenerSet;

// reimplementation of GenericOption
class GenericOption : public MIPObject {
protected:

 string _name;
 string _description;

 OptionListenerSet _optionsListenerSet;
 mutable pthread_mutex_t _valueMutex;

 // for OptionsListener
 virtual void notifyOptionListeners() = 0;

 // protected contstuctor
 GenericOption(const string& name, const string& description, Options* optionsContainer);

 // Every Option knows its Container
 Options* _optionsContainer;

public:
 // No public Contstuctor
 virtual string getObjectName() const {
  return "GenericOption";
 }


 string getName() const {
  return _name;
 }

 string getDescription() const {
  return _description;
 }

 virtual OptionValueType getType() const = 0;

 virtual void setValue(const string& s) = 0;

 virtual string print() const = 0;

 virtual string printValue() const = 0;

 // OptionListener Functions
 void registerOptionListener(OptionListener* optionListener);

 void unRegisterOptionListener(OptionListener* optionListener);

 // return Optionscontainer
 const Options& getContainer() { return *_optionsContainer; }
};

class DecimalOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_DECIMAL;
 Decimal _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 DecimalOption(const string& name, const string& description, Options* optionsContainer, const Decimal& value);

 DecimalOption(const DecimalOption& rhs);

public:
 DecimalOption& operator=(const DecimalOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "DecimalOption";
 }

 void setValue(const string& s);

 void setValue(const Decimal& v);

 Decimal getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class PositionOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_POSITION;
 Position _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 PositionOption(const string& name, const string& description, Options* optionsContainer, const Position& value);

 PositionOption(const PositionOption& rhs);

public:
 PositionOption& operator=(const PositionOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "PositionOption";
 }

 void setValue(const string& s);

 void setValue(const Position& v);

 Position getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class Position3DOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_POSITION3D;
 Position3D _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();


 Position3DOption(const string& name, const string& description, Options* optionsContainer, const Position3D& value);

 Position3DOption(const Position3DOption& rhs);

public:

 Position3DOption& operator=(const Position3DOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "Position3DOption";
 }

 void setValue(const string& s);

 void setValue(const Position3D& v);

 Position3D getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class PoseOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_POSE;
 Pose _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 PoseOption(const string& name, const string& description, Options* optionsContainer, const Pose& value);

 PoseOption(const PoseOption& rhs);

public:

 PoseOption& operator=(const PoseOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "PoseOption";
 }

 void setValue(const string& s);

 void setValue(const Pose& v);

 Pose getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class Pose3DOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_POSE3D;
 Pose3D _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 Pose3DOption(const string& name, const string& description, Options* optionsContainer, const Pose3D& value);

 Pose3DOption(const Pose3DOption& rhs);

public:

 Pose3DOption& operator=(const Pose3DOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "Pose3DOption";
 }

 void setValue(const string& s);

 void setValue(const Pose3D& v);

 Pose3D getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class DecimalArrayOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_ARRAY_DECIMAL;
 vector<Decimal> _valueVec;
 string _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 DecimalArrayOption(const string& name, const string& description, Options* optionsContainer, const string& value);

 DecimalArrayOption(const DecimalArrayOption& rhs);

public:
 DecimalArrayOption& operator=(const DecimalArrayOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "DecimalArrayOption";
 }

 void setValue(const string& s);

 void setValue(const vector<Decimal>& v);

 string getValue() const;
 
 bool fromString();
 
 vector<Decimal> getValueVec();
 
 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class IntOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_INT;
 int _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 IntOption(const string& name, const string& description, Options* optionsContainer, const int& value);

 IntOption(const IntOption& rhs);

public:
 IntOption& operator=(const IntOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "IntOption";
 }

 void setValue(const string& s);

 void setValue(const int& v);

 int getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class StringOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_STRING;
 string _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 StringOption(const string& name, const string& description, Options* optionsContainer, const string& value);

 StringOption(const StringOption& rhs);

public:

 StringOption& operator=(const StringOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "StringOption";
 }

 void setValue(const string& v);

 //   void setValue(string& v);

 string getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};

class BoolOption: public GenericOption {
private:
 static const OptionValueType TYPE = OVT_BOOL;
 bool _value;

 // for OptionsListener (overwrite to GenericOptions)
 void notifyOptionListeners();

 BoolOption(const string& name, const string& description, Options* optionsContainer, const bool& value);

 BoolOption(const BoolOption& rhs);

public:
 BoolOption& operator=(const BoolOption& rhs);

 OptionValueType getType() const;
 
 virtual string getObjectName() const {
  return "BoolOption";
 }

 void setValue(const string& s);

 void setValue(const bool& v);

 bool getValue() const;

 string print() const;

 string printValue() const;

 // only Option can construct
 friend class Options;
};



// fires AFTER a new Option class got created, or just BEFORE it is destroyed.
class GlobalOptionsListener : public OptionListener
{
public:
 // Creation
 virtual void optionWasCreated(GenericOption* option) {};
 virtual void optionWasCreated(DecimalOption* option) {};
 virtual void optionWasCreated(PositionOption* option) {};
 virtual void optionWasCreated(Position3DOption* option) {};
 virtual void optionWasCreated(PoseOption* option) {};
 virtual void optionWasCreated(Pose3DOption* option) {};
 virtual void optionWasCreated(DecimalArrayOption* option) {};
 virtual void optionWasCreated(StringOption* option) {};
 virtual void optionWasCreated(IntOption* option) {};
 virtual void optionWasCreated(BoolOption* option) {};

 // Deletion
 virtual void optionWillBeDeleted(GenericOption* option) {};
 virtual void optionWillBeDeleted(DecimalOption* option) {};
 virtual void optionWillBeDeleted(PositionOption* option) {};
 virtual void optionWillBeDeleted(Position3DOption* option) {};
 virtual void optionWillBeDeleted(PoseOption* option) {};
 virtual void optionWillBeDeleted(Pose3DOption* option) {};
 virtual void optionWillBeDeleted(DecimalArrayOption* option) {};
 virtual void optionWillBeDeleted(StringOption* option) {};
 virtual void optionWillBeDeleted(IntOption* option) {};
 virtual void optionWillBeDeleted(BoolOption* option) {};
};

typedef set<Options*> GlobalOptionsSet;
typedef set<GlobalOptionsListener*> GlobalOptionsListenerSet;


typedef set<DecimalOption*> DecimalOptionSet;
typedef set<PositionOption*> PositionOptionSet;
typedef set<Position3DOption*> Position3DOptionSet;
typedef set<PoseOption*> PoseOptionSet;
typedef set<Pose3DOption*> Pose3DOptionSet;
typedef set<DecimalArrayOption*> DecimalArrayOptionSet;
typedef set<IntOption*> IntOptionSet;
typedef set<StringOption*> StringOptionSet;
typedef set<BoolOption*> BoolOptionSet;

typedef map<string, GenericOption*> GenericOptionNameMap;
typedef set<GenericOption*> GenericOptionSet;


// New Options.
class Options: public MIPObject {
private:
 // Static OptionSet
 static GlobalOptionsSet _globalOptionsSet;
 static GlobalOptionsListenerSet _globalOptionsListenerSet;

 // All Options, referenced by Name
 GenericOptionNameMap _genericOptionNameMap;

 // Duplication for fast access to type specific types
 DecimalOptionSet _decimalOptionSet;
 PositionOptionSet _positionOptionSet;
 Position3DOptionSet _position3DOptionSet;
 PoseOptionSet _poseOptionSet;
 Pose3DOptionSet _pose3DOptionSet;
 DecimalArrayOptionSet _decimalArrayOptionSet;
 IntOptionSet _intOptionSet;
 StringOptionSet _stringOptionSet;
 BoolOptionSet _boolOptionSet;

 // Set that keeps track of options that are mandatory to Update
 GenericOptionSet _updateMandatorySet;

 // Notification Helper Function
 void notifyWasCreatedGlobalOptionsListener(DecimalOption* option);
 void notifyWasCreatedGlobalOptionsListener(PositionOption* option);
 void notifyWasCreatedGlobalOptionsListener(Position3DOption* option);
 void notifyWasCreatedGlobalOptionsListener(PoseOption* option);
 void notifyWasCreatedGlobalOptionsListener(Pose3DOption* option);
 void notifyWasCreatedGlobalOptionsListener(DecimalArrayOption* option);
 void notifyWasCreatedGlobalOptionsListener(StringOption* option);
 void notifyWasCreatedGlobalOptionsListener(IntOption* option);
 void notifyWasCreatedGlobalOptionsListener(BoolOption* option);

 void notifyWillBeDeletedGlobalOptionsListener(DecimalOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(PositionOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(Position3DOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(PoseOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(Pose3DOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(DecimalArrayOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(StringOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(IntOption* option);
 void notifyWillBeDeletedGlobalOptionsListener(BoolOption* option);

public:
 Options();

 virtual ~Options();
 virtual string getObjectName() const = 0;

 virtual OptionGroupsType getGroup() {
  return OPT_GRP_OTHE;
 }

 // Returns String Interpretation
 string toString() const;

 // Prints all variables to screen.
 void print() const;

 // Accessing Option Elements
 GenericOption* getOptionWithName(const string& name);
 bool hasOptionWithName(const string& name);

 // Creating & Deleting Option Elements
 DecimalOption* createDecimalOption(const string& name,
   const string& description, const Decimal& value,
   bool updateMandatory = false);
 PositionOption* createPositionOption(const string& name,
   const string& description, const Position& value,
   bool updateMandatory = false);
 Position3DOption* createPosition3DOption(const string& name,
   const string& description, const Position3D& value,
   bool updateMandatory = false);
 PoseOption* createPoseOption(const string& name, const string& description,
   const Pose& value, bool updateMandatory = false);
 Pose3DOption* createPose3DOption(const string& name, const string& description,
   const Pose3D& value, bool updateMandatory = false);
 DecimalArrayOption* createDecimalArrayOption(const string& name, const string& description,
   const string& value, bool updateMandatory = false);
 IntOption* createIntOption(const string& name, const string& description,
   int value, bool updateMandatory = false);
 StringOption* createStringOption(const string& name,
   const string& description, const string& value,
   bool updateMandatory = false);
 BoolOption* createBoolOption(const string& name, const string& description,
   bool value, bool updateMandatory = false);

 bool removeOption(GenericOption* genericOption);
 bool removeDecimalOption(DecimalOption* decimalOption);
 bool removePositionOption(PositionOption* positionOption);
 bool removePosition3DOption(Position3DOption* position3DOption);
 bool removePoseOption(PoseOption* poseOption);
 bool removePose3DOption(Pose3DOption* poseOption);
 bool removeDecimalArrayOption(DecimalArrayOption* DecimalArrayOption);
 bool removeIntOption(IntOption* intOption);
 bool removeStringOption(StringOption* stringOption);
 bool removeBoolOption(BoolOption* boolOption);

 // update already registered names (with the derived class)
 void updateValues(bool checkForUpdateMandatroy = true);
 void updateValue(const string& name, const string& value);

 // static functions. Apply to all Option Objects.
 static const GlobalOptionsSet& getGlobalOptionsSet() {
  return _globalOptionsSet;
 }

 static GenericOption* globalGetOptionWithName(const string& name);


 // GlobalOptionsListener Functions
 static void registerGlobalOptionsListener(GlobalOptionsListener* globalOptionsListener);

 static void unRegisterGlobalOptionsListener(GlobalOptionsListener* globalOptionsListener);
};

#endif // __MIP_OPTION_