Algorithm.h

Go to the documentation of this file.

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

#ifndef ALGORITHM_H_
#define ALGORITHM_H_

#include "analysis/EventLoopProxy.h"
#include "core/Configurable.h"
#include "core/Filter.h"
#include "core/Info.h"
#include "data/DataStoreUser.h"
#include "data/ObjectConsumer.h"
#include "data/ObjectProducer.h"

namespace EA {

class Algorithm : public Filter,
                  public Info,
                  public Configurable,
                  public DataStoreUser,
                  public ObjectProducer,
                  public ObjectConsumer {
public:
  Algorithm(const std::string &name);

  virtual bool SetEventLoopProxy(observer_ptr<EventLoopProxy> loopProxy);

  virtual bool Initialize();

  virtual bool Process();

  virtual bool Finalize();

  enum class IterateRequest { YES, NO, WHATEVER, ERROR };

  virtual IterateRequest Iterate();

  observer_ptr<EventLoopProxy> GetEventLoopProxy() { return _repr->loopProxy; }

protected:
  class Representation {
    friend class Algorithm;
    observer_ptr<EventLoopProxy> loopProxy;
  };

  Algorithm(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)
      : Filter{filterRepr}, Info{infoRepr}, Configurable{confRepr}, DataStoreUser{dsuRepr}, ObjectProducer{opRepr},
        ObjectConsumer{ocRepr}, _repr{algoRepr} {}

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

private:
  std::shared_ptr<Representation> _repr;
};

} // namespace EA

#include "plugin/FactoryMacros.h"
#define RegisterAlgorithm(className) RegisterClass(EA::Algorithm, className, const std::string &)
#define RegisterNSAlgorithm(namespace, className)                                                                      \
  RegisterClassAs(EA::Algorithm, className, #namespace "::" #className, const std::string &)

#endif /* ALGORITHM_H_ */