signal-array.h

// -*- mode: c++ -*-
// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
// JRL, CNRS/AIST.
//

#ifndef DYNAMIC_GRAPH_SIGNAL_ARRAY_H
#define DYNAMIC_GRAPH_SIGNAL_ARRAY_H
#include <dynamic-graph/dynamic-graph-api.h>
#include <dynamic-graph/signal-base.h>
#include <stdio.h>
#include <vector>

namespace dynamicgraph {

template <class Time> class SignalArray_const {

public:
  static const int DEFAULT_SIZE = 20;

protected:
  std::vector<const SignalBase<Time> *> const_array;
  unsigned int size, rank;

public:
  SignalArray_const<Time>(const unsigned int &sizeARG = DEFAULT_SIZE)
      : const_array(sizeARG), size(sizeARG), rank(0) {}

  SignalArray_const<Time>(const SignalBase<Time> &sig)
      : const_array(DEFAULT_SIZE), size(DEFAULT_SIZE), rank(0) {
    addElmt(&sig);
  }

  SignalArray_const<Time>(const SignalArray<Time> &siga)
      : const_array(siga.getSize()), size(siga.getSize()),
        rank(siga.getSize()) {
    for (unsigned int i = 0; i < rank; ++i)
      const_array[i] = &siga[i];
  }

  SignalArray_const<Time>(const SignalArray_const<Time> &siga)
      : const_array(siga.getSize()), size(siga.getSize()),
        rank(siga.getSize()) {
    for (unsigned int i = 0; i < rank; ++i)
      const_array[i] = &siga[i];
  }

  virtual ~SignalArray_const<Time>() {}

protected:
  void addElmt(const SignalBase<Time> *el) {
    if (rank >= size) {
      size += DEFAULT_SIZE;
      const_array.resize(size);
    }
    const_array[rank++] = el;
  }

public:
  virtual SignalArray_const<Time> &operator<<(const SignalBase<Time> &sig) {
    addElmt(&sig);
    return *this;
  }

public:
  virtual const SignalBase<Time> &operator[](const unsigned int &idx) const {
    return *const_array[idx];
  }
  virtual unsigned int getSize() const { return rank; }
};

template <class Time>
SignalArray_const<Time> operator<<(const SignalBase<Time> &sig1,
                                   const SignalBase<Time> &sig2) {
  SignalArray_const<Time> res(sig1);
  res << sig2;
  return res;
}

template <class Time> class SignalArray : public SignalArray_const<Time> {
public:
  using SignalArray_const<Time>::DEFAULT_SIZE;
  using SignalArray_const<Time>::size;
  using SignalArray_const<Time>::rank;

protected:
  mutable std::vector<SignalBase<Time> *> array;

public:
  SignalArray<Time>(const unsigned int &sizeARG = DEFAULT_SIZE)
      : SignalArray_const<Time>(0), array(sizeARG) {
    size = sizeARG;
  }

  SignalArray<Time>(SignalBase<Time> &sig)
      : SignalArray_const<Time>(0), array(DEFAULT_SIZE) {
    size = DEFAULT_SIZE;
    addElmt(&sig);
  }

  SignalArray<Time>(const SignalArray<Time> &siga)
      : SignalArray_const<Time>(siga.getSize()), array(siga.getSize()) {
    rank = siga.getSize();
    for (unsigned int i = 0; i < rank; ++i)
      array[i] = &siga[i];
  }

  virtual ~SignalArray<Time>() {}

protected:
  void addElmt(SignalBase<Time> *el) {
    if (rank >= size) {
      size += DEFAULT_SIZE;
      array.resize(size);
    }
    array[rank++] = el;
  }

public:
  virtual SignalArray<Time> &operator<<(SignalBase<Time> &sig) {
    addElmt(&sig);
    return *this;
  }

  virtual SignalArray_const<Time>
  operator<<(const SignalBase<Time> &sig) const {
    SignalArray_const<Time> res(*this);
    res << sig;
    return res;
  }

  virtual SignalBase<Time> &operator[](const unsigned int &idx) const {
    return *array[idx];
  }
};

template <class Time>
SignalArray<Time> operator<<(SignalBase<Time> &sig1, SignalBase<Time> &sig2) {
  SignalArray<Time> res(sig1);
  res << sig2;
  return res;
}

DYNAMIC_GRAPH_DLLAPI extern SignalArray<int> sotNOSIGNAL;

} // end of namespace dynamicgraph.

#endif