sot-core  4.10.1
Hierarchical task solver plug-in for dynamic-graph.
variadic-op.hh
Go to the documentation of this file.
1 /*
2  * Copyright 2018,
3  * Mirabel Joseph
4  *
5  * CNRS/AIST
6  *
7  */
8 
9 #ifndef SOT_CORE_VARIADICOP_HH
10 #define SOT_CORE_VARIADICOP_HH
11 
12 /* --------------------------------------------------------------------- */
13 /* --- INCLUDE --------------------------------------------------------- */
14 /* --------------------------------------------------------------------- */
15 
16 /* Matrix */
17 #include <dynamic-graph/linear-algebra.h>
18 
19 /* SOT */
20 #include <dynamic-graph/all-signals.h>
21 #include <dynamic-graph/entity.h>
22 #include <sot/core/flags.hh>
24 #include <sot/core/pool.hh>
25 
26 /* STD */
27 #include <string>
28 
29 #include <boost/function.hpp>
30 
31 namespace dynamicgraph {
32 namespace sot {
33 
34 /* --------------------------------------------------------------------- */
35 /* --- CLASS ----------------------------------------------------------- */
36 /* --------------------------------------------------------------------- */
37 
38 template <typename Tin, typename Tout, typename Time>
39 class VariadicAbstract : public Entity {
40 public: /* --- CONSTRUCTION --- */
41  static std::string getTypeInName(void);
42  static std::string getTypeOutName(void);
43 
44  VariadicAbstract(const std::string &name, const std::string &className)
45  : Entity(name), SOUT(className + "(" + name + ")::output(" +
46  getTypeOutName() + ")::sout"),
47  baseSigname(className + "(" + name + ")::input(" + getTypeInName() +
48  ")::") {
49  signalRegistration(SOUT);
50  }
51 
52  virtual ~VariadicAbstract(void) {
53  for (std::size_t i = 0; i < signalsIN.size(); ++i) {
54  _removeSignal(i);
55  }
56  };
57 
58 public: /* --- SIGNAL --- */
59  SignalTimeDependent<Tout, int> SOUT;
60 
61  std::size_t addSignal() {
62  std::ostringstream oss;
63  oss << "sin" << signalsIN.size();
64  return addSignal(oss.str());
65  }
66 
67  std::size_t addSignal(const std::string &name) {
68  signal_t *sig = new signal_t(NULL, baseSigname + name);
69  try {
70  _declareSignal(sig);
71  signalsIN.push_back(sig);
72  // names.push_back (name);
73  return signalsIN.size() - 1;
74  } catch (const ExceptionAbstract &) {
75  delete sig;
76  throw;
77  }
78  }
79 
80  void removeSignal() {
81  assert(signalsIN.size() > 0);
82  _removeSignal(signalsIN.size() - 1);
83  // names.pop_back();
84  signalsIN.pop_back();
85  }
86 
87  void setSignalNumber(const int &n) {
88  assert(n >= 0);
89  const std::size_t oldSize = signalsIN.size();
90  for (std::size_t i = n; i < oldSize; ++i)
91  _removeSignal(i);
92  signalsIN.resize(n, NULL);
93  // names.resize(n);
94 
95  for (std::size_t i = oldSize; i < (std::size_t)n; ++i) {
96  assert(signalsIN[i] == NULL);
97  std::ostringstream oss;
98  oss << baseSigname << "sin" << i;
99  // names[i] = oss.str();
100  // signal_t* s = new signal_t (NULL,names[i]);
101  signal_t *s = new signal_t(NULL, oss.str());
102  signalsIN[i] = s;
103  _declareSignal(s);
104  }
105  }
106 
107  int getSignalNumber() const { return (int)signalsIN.size(); }
108 
109 protected:
110  typedef SignalPtr<Tin, int> signal_t;
111  std::vector<signal_t *> signalsIN;
112  // Use signal->shortName instead
113  // std::vector< std::string > names;
114 
115 private:
116  void _removeSignal(const std::size_t i) {
117  // signalDeregistration(names[i]);
118  signalDeregistration(signalsIN[i]->shortName());
119  SOUT.removeDependency(*signalsIN[i]);
120  delete signalsIN[i];
121  }
122  void _declareSignal(signal_t *s) {
123  signalRegistration(*s);
124  SOUT.addDependency(*s);
125  }
126  const std::string baseSigname;
127 };
128 
129 template <typename Operator>
130 class VariadicOp : public VariadicAbstract<typename Operator::Tin,
131  typename Operator::Tout, int> {
132  Operator op;
133  typedef typename Operator::Tin Tin;
134  typedef typename Operator::Tout Tout;
135  typedef VariadicOp<Operator> Self;
136 
137 public: /* --- CONSTRUCTION --- */
139 
140  // static std::string getTypeInName ( void ) { return Operator::nameTypeIn ();
141  // } static std::string getTypeOutName( void ) { return
142  // Operator::nameTypeOut(); }
143  static const std::string CLASS_NAME;
144  virtual const std::string &getClassName() const { return CLASS_NAME; }
145  std::string getDocString() const { return op.getDocString(); }
146 
147  VariadicOp(const std::string &name) : Base(name, CLASS_NAME) {
148  this->SOUT.setFunction(boost::bind(&Self::computeOperation, this, _1, _2));
149  op.initialize(this, this->commandMap);
150  }
151 
152  virtual ~VariadicOp(void){};
153 
154 protected:
155  Tout &computeOperation(Tout &res, int time) {
156  std::vector<const Tin *> in(this->signalsIN.size());
157  for (std::size_t i = 0; i < this->signalsIN.size(); ++i) {
158  const Tin &x = this->signalsIN[i]->access(time);
159  in[i] = &x;
160  }
161  op(in, res);
162  return res;
163  }
164 };
165 } // namespace sot
166 } // namespace dynamicgraph
167 
168 #endif // #ifndef SOT_CORE_VARIADICOP_HH
void setSignalNumber(const int &n)
Definition: variadic-op.hh:87
static std::string getTypeInName(void)
static std::string getTypeOutName(void)
VariadicAbstract< Tin, Tout, int > Base
Definition: variadic-op.hh:138
std::vector< signal_t * > signalsIN
Definition: variadic-op.hh:111
VariadicOp(const std::string &name)
Definition: variadic-op.hh:147
Tout & computeOperation(Tout &res, int time)
Definition: variadic-op.hh:155
std::size_t addSignal()
Definition: variadic-op.hh:61
Definition: exception-abstract.hh:35
Definition: variadic-op.hh:39
VariadicAbstract(const std::string &name, const std::string &className)
Definition: variadic-op.hh:44
SignalPtr< Value, int > signal_t
Definition: variadic-op.hh:110
virtual ~VariadicAbstract(void)
Definition: variadic-op.hh:52
SignalTimeDependent< Tout, int > SOUT
Definition: variadic-op.hh:56
void removeSignal()
Definition: variadic-op.hh:80
virtual ~VariadicOp(void)
Definition: variadic-op.hh:152
std::string getDocString() const
Definition: variadic-op.hh:145
std::size_t addSignal(const std::string &name)
Definition: variadic-op.hh:67
Definition: variadic-op.hh:130
Definition: abstract-sot-external-interface.hh:17
static const std::string CLASS_NAME
Definition: variadic-op.hh:143
int getSignalNumber() const
Definition: variadic-op.hh:107
virtual const std::string & getClassName() const
Definition: variadic-op.hh:144