Variable.h

Go to the documentation of this file.

#ifndef _OCRABASE_VARIABLE_H_
#define _OCRABASE_VARIABLE_H_

#include "ocra/optim/ObserverSubject.h"
#include "ocra/optim/Composite.h"

#include <Eigen/Eigen>
namespace ocra{using namespace Eigen;}

#include <boost/noncopyable.hpp>

#include <string>
#include <vector>

namespace ocra
{
  class CompositeVariable;
  // ------------------------------------------------------------
  // --- HELPERS ------------------------------------------------
  // ------------------------------------------------------------


  class VariableHasRestrictedClassDerivation
  {
    VariableHasRestrictedClassDerivation() {}
    friend class Variable;
    friend class BaseVariable;
    friend class CompositeVariable;
  };


  struct VariableParenthood
  {
    size_t startIndexInParentMap;

    VariableParenthood() throw();
  };


  // ------------------------------------------------------------
  // --- VARIABLE -----------------------------------------------
  // ------------------------------------------------------------


  class Variable
    // --- Base classes ---
    : public Component<Variable, CompositeVariable, VariableParenthood>
    , public ObserverSubject
    // --- Constraints ---
    , boost::noncopyable
    , virtual VariableHasRestrictedClassDerivation
  {

    // --- Type ---------------------------------------------------
  public:
    typedef Component<Variable, CompositeVariable, VariableParenthood>::parenthood_t parenthood_t;
    // --- Construction/Destruction, accessors --------------------
  public:
    Variable(const std::string& name = "");

    virtual ~Variable() = 0;

    virtual const std::string& getName() const;

    virtual bool isBaseVariable() const;

    // --- Variables as functions in R^n --------------------------
  public:

    double operator[](size_t i) const;
    double at(size_t i) const;

    int getSize() const;

    operator const VectorXd& () const;

    const VectorXd& getValue() const;
    void setValue(const VectorXd& value);


    virtual Variable& getTimeDerivative();
    virtual Variable& getTimePrimitive();


    void createTimeDerivative(const std::string& name);
    void createTimePrimitive(const std::string& name);

    bool hasTimeDerivative() const;
    bool hasTimePrimitive() const;

    // --- Variables as trees (composites) ------------------------
  public:

    void getRelativeMappingOf(const Variable& subVariable, std::vector<int>& mapping) const;

    size_t getNumberOfChildren() const;

    void printNode(int depth, std::ostream& os) const;

  protected:

    void onAttachedParent(const parenthood_t& parent);
    void onDetachedParent(const parenthood_t& parent);

    // --- To overload in children classes ------------------------
  protected:
    virtual void do_setValue(const VectorXd& value) = 0;


    virtual Variable* do_createTimeDerivative(const std::string& name) = 0;
    virtual Variable* do_createTimePrimitive(const std::string& name) = 0;


    virtual size_t do_getNumberOfChildren() const = 0;

    // --- Additional interface for derived classes ---------------
  protected:

    static void callInsertInMemoryMap
      (Variable& obj, const parenthood_t& child, size_t whereInChild,
      std::vector<const double*>::const_iterator start, std::vector<const double*>::const_iterator end);

    static void callRemoveFromMemoryMap(Variable& obj, const parenthood_t& child, size_t whereInChild, size_t numElements);

    static std::vector<const double*>& getMemoryMap(Variable& obj);

  private:
    struct VariablePtr
    {
      Variable* var_;
      bool owns_;
      VariablePtr(Variable* var, bool owns): var_(var), owns_(owns) {}
      operator bool() const { return (var_ != 0x0); }
    };

    void insertInMemoryMap(const parenthood_t& child, size_t whereInChild, std::vector<const double*>::const_iterator start, std::vector<const double*>::const_iterator end);
    void removeFromMemoryMap(const parenthood_t& child, size_t whereInChild, size_t numElements);

    void updateValue() const;


    void onChildValueChanged(int timestamp);

  private:
    std::vector<const double*> memoryMap_;
    std::string name_;
    VariablePtr timeDerivative_;
    VariablePtr timePrimitive_;
    mutable VectorXd value_;
    mutable bool updateValue_;
  };


  // ------------------------------------------------------------
  // --- BASE VARIABLE ------------------------------------------
  // ------------------------------------------------------------

  /*
  This class is part of the Variable hierarchy and correspond to the leaves of a tree
  of CompositeVariable instances. They embed the memory pointed by the composite variables
  which they are part of.

  All the methods here are documented in ocra::Variable.
  \sa ocra::Variable

  \warning When a BaseVariable is part of several trees (it has more than one parent),
  then modifying one parent variable will result in modifying the other one(s), since
  all parents share the same memory (the one embedded in BaseVariable).

  \internal Most of the behavior is implemented in ocra::Variable. This class implements
  the abstract methods defined in ocra::Variable and overloads the methods that handle
  the internal memory of the variable.
  */
  class BaseVariable
    : public Leaf<BaseVariable>
    , public Variable
  {
  public:

    BaseVariable(const std::string& name, size_t size);

    bool isBaseVariable() const;

    void resize(size_t newSize);

    BaseVariable& getTimeDerivative();
    BaseVariable& getTimePrimitive();

    int isAncestorOf(const Variable& var) const;
    void printSubTree(int depth, std::ostream& os) const;

  protected:
    void do_setValue(const VectorXd& value);

    Variable* do_createTimeDerivative(const std::string& name);
    Variable* do_createTimePrimitive(const std::string& name);

    size_t do_getNumberOfChildren() const;

  private:
    std::vector<double> memory_;
  };


  // ------------------------------------------------------------
  // --- COMPOSITE VARIABLE -------------------------------------
  // ------------------------------------------------------------

  /*
  This class is part of the Variable hierarchy and correspond to the nodes of a tree
  of CompositeVariable instances.

  Most methods declared here are documented in ocra::Variable.
  \sa ocra::Variable

  \internal Most of the behavior is implemented in ocra::Variable.
  */
  class CompositeVariable
    : public Composite<Variable, CompositeVariable, VariableParenthood>
    , public Variable
  {
  public:
    CompositeVariable(const std::string& name);
    CompositeVariable(const std::string& name, Variable& var);
    CompositeVariable(const std::string& name, Variable& var1, Variable& var2);
    CompositeVariable(const std::string& name, const std::vector<Variable*>& vars);

    void clear();

    Variable& operator()(size_t i);

    CompositeVariable& addByMerge(Variable& v);

    CompositeVariable& getTimeDerivative();
    CompositeVariable& getTimePrimitive();

    CompositeVariable& add(Variable& child);
    CompositeVariable& remove(Variable& child);
    const Variable& operator()(size_t i) const;

    int isAncestorOf(const Variable& var) const;
    void printSubTree(int depth, std::ostream& os) const;

  protected:
    void do_setValue(const VectorXd& value);

  protected:

    void onAttachedChild(const parenthood_t& child);
    void onDetachedChild(const parenthood_t& child);

  protected:
    Variable* do_createTimeDerivative(const std::string& name);
    Variable* do_createTimePrimitive(const std::string& name);

    size_t do_getNumberOfChildren() const;
  };
}

#endif //_OCRABASE_VARIABLE_H_

// cmake:sourcegroup=Variable