Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	include/sot/core/variadic-op.hh	Lines:	0	63	0.0 %
Date:	2023-03-13 12:09:37	Branches:	0	114	0.0 %


/*
 * Copyright 2018,
 * Mirabel Joseph
 *
 * CNRS/AIST
 *
 */

#ifndef SOT_CORE_VARIADICOP_HH
#define SOT_CORE_VARIADICOP_HH

/* --------------------------------------------------------------------- */
/* --- INCLUDE --------------------------------------------------------- */
/* --------------------------------------------------------------------- */

/* Matrix */
#include <dynamic-graph/linear-algebra.h>

/* SOT */
#include <dynamic-graph/all-signals.h>
#include <dynamic-graph/entity.h>

#include <sot/core/flags.hh>
#include <sot/core/matrix-geometry.hh>
#include <sot/core/pool.hh>

/* STD */
#include <boost/function.hpp>
#include <string>

namespace dynamicgraph {
namespace sot {

/* --------------------------------------------------------------------- */
/* --- CLASS ----------------------------------------------------------- */
/* --------------------------------------------------------------------- */

template <typename Tin, typename Tout, typename Time>
class VariadicAbstract : public Entity {
 public: /* --- CONSTRUCTION --- */
  static std::string getTypeInName(void);
  static std::string getTypeOutName(void);

  VariadicAbstract(const std::string &name, const std::string &className)
      : Entity(name),
        SOUT(className + "(" + name + ")::output(" + getTypeOutName() +
             ")::sout"),
        baseSigname(className + "(" + name + ")::input(" + getTypeInName() +
                    ")::") {
    signalRegistration(SOUT);
  }

  virtual ~VariadicAbstract(void) {
    for (std::size_t i = 0; i < signalsIN.size(); ++i) {
      _removeSignal(i);
    }
  };

 public: /* --- SIGNAL --- */
  typedef SignalPtr<Tin, int> signal_t;
  SignalTimeDependent<Tout, int> SOUT;

  std::size_t addSignal() {
    std::ostringstream oss;
    oss << "sin" << signalsIN.size();
    return addSignal(oss.str());
  }

  std::size_t addSignal(const std::string &name) {
    signal_t *sig = new signal_t(NULL, baseSigname + name);
    try {
      _declareSignal(sig);
      signalsIN.push_back(sig);
      // names.push_back (name);
      return signalsIN.size() - 1;
    } catch (const ExceptionAbstract &) {
      delete sig;
      throw;
    }
  }

  void removeSignal() {
    assert(signalsIN.size() > 0);
    _removeSignal(signalsIN.size() - 1);
    // names.pop_back();
    signalsIN.pop_back();
  }

  void setSignalNumber(const int &n) {
    assert(n >= 0);
    const std::size_t oldSize = signalsIN.size();
    for (std::size_t i = n; i < oldSize; ++i) _removeSignal(i);
    signalsIN.resize(n, NULL);
    // names.resize(n);

    for (std::size_t i = oldSize; i < (std::size_t)n; ++i) {
      assert(signalsIN[i] == NULL);
      std::ostringstream oss;
      oss << baseSigname << "sin" << i;
      // names[i] = oss.str();
      // signal_t* s = new signal_t (NULL,names[i]);
      signal_t *s = new signal_t(NULL, oss.str());
      signalsIN[i] = s;
      _declareSignal(s);
    }
    updateSignalNumber(n);
  }

  int getSignalNumber() const { return (int)signalsIN.size(); }

  signal_t *getSignalIn(int i) {
    if (i < 0 || i >= (int)signalsIN.size())
      throw std::out_of_range("Wrong signal index");
    return signalsIN[i];
  }

 protected:
  std::vector<signal_t *> signalsIN;
  // Use signal->shortName instead
  // std::vector< std::string > names;

  virtual void updateSignalNumber(int n) { (void)n; };

 private:
  void _removeSignal(const std::size_t i) {
    // signalDeregistration(names[i]);
    signalDeregistration(signalsIN[i]->shortName());
    SOUT.removeDependency(*signalsIN[i]);
    delete signalsIN[i];
  }
  void _declareSignal(signal_t *s) {
    signalRegistration(*s);
    SOUT.addDependency(*s);
  }
  const std::string baseSigname;
};

template <typename Operator>
class VariadicOp : public VariadicAbstract<typename Operator::Tin,
                                           typename Operator::Tout, int> {
  typedef typename Operator::Tin Tin;
  typedef typename Operator::Tout Tout;
  typedef VariadicOp<Operator> Self;

 public: /* --- CONSTRUCTION --- */
  Operator op;

  typedef VariadicAbstract<Tin, Tout, int> Base;

  // static std::string getTypeInName ( void ) { return Operator::nameTypeIn ();
  // } static std::string getTypeOutName( void ) { return
  // Operator::nameTypeOut(); }
  static const std::string CLASS_NAME;
  virtual const std::string &getClassName() const { return CLASS_NAME; }
  std::string getDocString() const { return op.getDocString(); }

  VariadicOp(const std::string &name) : Base(name, CLASS_NAME) {
    this->SOUT.setFunction(boost::bind(&Self::computeOperation, this, _1, _2));
    op.initialize(this, this->commandMap);
  }

  virtual ~VariadicOp(void){};

 protected:
  Tout &computeOperation(Tout &res, int time) {
    std::vector<const Tin *> in(this->signalsIN.size());
    for (std::size_t i = 0; i < this->signalsIN.size(); ++i) {
      const Tin &x = this->signalsIN[i]->access(time);
      in[i] = &x;
    }
    op(in, res);
    return res;
  }

  inline void updateSignalNumber(int n) { op.updateSignalNumber(n); }
};
}  // namespace sot
}  // namespace dynamicgraph

#endif  // #ifndef SOT_CORE_VARIADICOP_HH


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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
23			#include <sot/core/flags.hh>
24			#include <sot/core/matrix-geometry.hh>
25			#include <sot/core/pool.hh>
26
27			/* STD */
28			#include <boost/function.hpp>
29			#include <string>
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),
46			SOUT(className + "(" + name + ")::output(" + getTypeOutName() +
47			")::sout"),
48			baseSigname(className + "(" + name + ")::input(" + getTypeInName() +
49			")::") {
50			signalRegistration(SOUT);
51			}
52
53			virtual ~VariadicAbstract(void) {
54			for (std::size_t i = 0; i < signalsIN.size(); ++i) {
55			_removeSignal(i);
56			}
57			};
58
59			public: /* --- SIGNAL --- */
60			typedef SignalPtr<Tin, int> signal_t;
61			SignalTimeDependent<Tout, int> SOUT;
62
63			std::size_t addSignal() {
64			std::ostringstream oss;
65			oss << "sin" << signalsIN.size();
66			return addSignal(oss.str());
67			}
68
69			std::size_t addSignal(const std::string &name) {
70			signal_t *sig = new signal_t(NULL, baseSigname + name);
71			try {
72			_declareSignal(sig);
73			signalsIN.push_back(sig);
74			// names.push_back (name);
75			return signalsIN.size() - 1;
76			} catch (const ExceptionAbstract &) {
77			delete sig;
78			throw;
79			}
80			}
81
82			void removeSignal() {
83			assert(signalsIN.size() > 0);
84			_removeSignal(signalsIN.size() - 1);
85			// names.pop_back();
86			signalsIN.pop_back();
87			}
88
89			void setSignalNumber(const int &n) {
90			assert(n >= 0);
91			const std::size_t oldSize = signalsIN.size();
92			for (std::size_t i = n; i < oldSize; ++i) _removeSignal(i);
93			signalsIN.resize(n, NULL);
94			// names.resize(n);
95
96			for (std::size_t i = oldSize; i < (std::size_t)n; ++i) {
97			assert(signalsIN[i] == NULL);
98			std::ostringstream oss;
99			oss << baseSigname << "sin" << i;
100			// names[i] = oss.str();
101			// signal_t* s = new signal_t (NULL,names[i]);
102			signal_t *s = new signal_t(NULL, oss.str());
103			signalsIN[i] = s;
104			_declareSignal(s);
105			}
106			updateSignalNumber(n);
107			}
108
109			int getSignalNumber() const { return (int)signalsIN.size(); }
110
111			signal_t *getSignalIn(int i) {
112			if (i < 0 \|\| i >= (int)signalsIN.size())
113			throw std::out_of_range("Wrong signal index");
114			return signalsIN[i];
115			}
116
117			protected:
118			std::vector<signal_t *> signalsIN;
119			// Use signal->shortName instead
120			// std::vector< std::string > names;
121
122			virtual void updateSignalNumber(int n) { (void)n; };
123
124			private:
125			void _removeSignal(const std::size_t i) {
126			// signalDeregistration(names[i]);
127			signalDeregistration(signalsIN[i]->shortName());
128			SOUT.removeDependency(*signalsIN[i]);
129			delete signalsIN[i];
130			}
131			void _declareSignal(signal_t *s) {
132			signalRegistration(*s);
133			SOUT.addDependency(*s);
134			}
135			const std::string baseSigname;
136			};
137
138			template <typename Operator>
139			class VariadicOp : public VariadicAbstract<typename Operator::Tin,
140			typename Operator::Tout, int> {
141			typedef typename Operator::Tin Tin;
142			typedef typename Operator::Tout Tout;
143			typedef VariadicOp<Operator> Self;
144
145			public: /* --- CONSTRUCTION --- */
146			Operator op;
147
148			typedef VariadicAbstract<Tin, Tout, int> Base;
149
150			// static std::string getTypeInName ( void ) { return Operator::nameTypeIn ();
151			// } static std::string getTypeOutName( void ) { return
152			// Operator::nameTypeOut(); }
153			static const std::string CLASS_NAME;
154			virtual const std::string &getClassName() const { return CLASS_NAME; }
155			std::string getDocString() const { return op.getDocString(); }
156
157			VariadicOp(const std::string &name) : Base(name, CLASS_NAME) {
158			this->SOUT.setFunction(boost::bind(&Self::computeOperation, this, _1, _2));
159			op.initialize(this, this->commandMap);
160			}
161
162			virtual ~VariadicOp(void){};
163
164			protected:
165			Tout &computeOperation(Tout &res, int time) {
166			std::vector<const Tin *> in(this->signalsIN.size());
167			for (std::size_t i = 0; i < this->signalsIN.size(); ++i) {
168			const Tin &x = this->signalsIN[i]->access(time);
169			in[i] = &x;
170			}
171			op(in, res);
172			return res;
173			}
174
175			inline void updateSignalNumber(int n) { op.updateSignalNumber(n); }
176			};
177			} // namespace sot
178			} // namespace dynamicgraph
179
180			#endif // #ifndef SOT_CORE_VARIADICOP_HH