AlgoSequence.h

Go to the documentation of this file.

/*
 * AlgoSequence.h
 *
 *  Created on: 23 Apr 2013
 *      Author: Nicola Mori
 */

#ifndef ALGOSEQUENCE_H_
#define ALGOSEQUENCE_H_

#include "algorithm/Algorithm.h"

#include <vector>

namespace EA {

class AlgoSequence : public Algorithm {

public:
  using Algorithms = std::vector<std::unique_ptr<Algorithm>>;

  AlgoSequence(const std::string &name);

  bool AddAlgorithm(std::unique_ptr<Algorithm> &&algo);

  observer_ptr<Algorithm> GetAlgorithm(const std::string name);

  const Algorithms &GetAlgorithms() const;

  Algorithms &GetAlgorithms();

  bool Initialize();

  bool Process();

  bool Finalize();

  IterateRequest Iterate();

  // STL-like container facilities
  using iterator = Algorithms::iterator;
  using const_iterator = Algorithms::const_iterator;
  iterator begin() { return GetAlgorithms().begin(); }
  iterator end() { return GetAlgorithms().end(); }
  const_iterator begin() const { return GetAlgorithms().begin(); }
  const_iterator end() const { return GetAlgorithms().end(); }
  size_t size() { return GetAlgorithms().size(); }

  bool SetDataStoreManager(observer_ptr<DataStoreManager> dsManager);

  bool SetEventLoopProxy(observer_ptr<EventLoopProxy> loopProxy);

protected:
  friend class AlgoSequenceDecorator; // For supporting AlgoSequenceDecorator

  virtual bool ProcessAlgo(size_t iAlgo);

  class Representation {
    friend class AlgoSequence;
    Algorithms algorithms;
  };

  AlgoSequence(const std::shared_ptr<Filter::Representation> &filterRepr,
               const std::shared_ptr<Info::Representation> &infoRepr,
               const std::shared_ptr<Configurable::Representation> &confRepr,
               const std::shared_ptr<DataStoreUser::Representation> &dsuRepr,
               const std::shared_ptr<ObjectProducer::Representation> &opRepr,
               const std::shared_ptr<ObjectConsumer::Representation> &ocRepr,
               const std::shared_ptr<Algorithm::Representation> &algoRepr)
      : Algorithm{filterRepr, infoRepr, confRepr, dsuRepr, opRepr, ocRepr, algoRepr},
        _repr{std::make_shared<Representation>()} {}

  std::shared_ptr<Representation> &GetRepresentation() { return _repr; }

private:
  std::shared_ptr<Representation> _repr;

private:
};

} // namespace EA

#endif /* ALGOSEQUENCE_H_ */