Essentia  2.1-beta5-dev
AccumulatorAlgorithm Class Referenceabstract

#include <accumulatoralgorithm.h>

Inheritance diagram for AccumulatorAlgorithm:
Algorithm Configurable

Public Member Functions

 AccumulatorAlgorithm ()
 
AlgorithmStatus process ()
 
void reset ()
 
virtual void consume ()=0
 
virtual void finalProduce ()=0
 
void declareInputStream (SinkBase &sink, const std::string &name, const std::string &desc, int preferredAcquireSize=4096)
 
void declareOutputResult (SourceBase &source, const std::string &name, const std::string &desc)
 
- Public Member Functions inherited from Algorithm
 Algorithm ()
 
virtual ~Algorithm ()
 
SinkBaseinput (const std::string &name)
 
SourceBaseoutput (const std::string &name)
 
SinkBaseinput (int idx)
 
SourceBaseoutput (int idx)
 
const InputMapinputs () const
 
const OutputMapoutputs () const
 
std::vector< std::string > inputNames () const
 
std::vector< std::string > outputNames () const
 
virtual void shouldStop (bool stop)
 
virtual bool shouldStop () const
 
void disconnectAll ()
 
AlgorithmStatus acquireData ()
 
void releaseData ()
 
- Public Member Functions inherited from Configurable
virtual ~Configurable ()
 
const std::string & name () const
 
void setName (const std::string &name)
 
virtual void declareParameters ()=0
 
virtual void setParameters (const ParameterMap &params)
 
virtual void configure (const ParameterMap &params)
 
virtual void configure ()
 
const ParameterMapdefaultParameters () const
 
const Parameterparameter (const std::string &key) const
 

Protected Member Functions

void declareInput ()
 
void declareOutput ()
 
- Protected Member Functions inherited from Algorithm
void declareInput (SinkBase &sink, const std::string &name, const std::string &desc)
 
void declareInput (SinkBase &sink, int n, const std::string &name, const std::string &desc)
 
void declareInput (SinkBase &sink, int acquireSize, int releaseSize, const std::string &name, const std::string &desc)
 
void declareOutput (SourceBase &source, const std::string &name, const std::string &desc)
 
void declareOutput (SourceBase &source, int n, const std::string &name, const std::string &desc)
 
void declareOutput (SourceBase &source, int acquireSize, int releaseSize, const std::string &name, const std::string &desc)
 
- Protected Member Functions inherited from Configurable
void declareParameter (const std::string &name, const std::string &desc, const std::string &range, const Parameter &defaultValue)
 

Protected Attributes

int _preferredSize
 
SinkBase_inputStream
 
- Protected Attributes inherited from Algorithm
bool _shouldStop
 
OutputMap _outputs
 
InputMap _inputs
 
int nProcess
 
- Protected Attributes inherited from Configurable
std::string _name
 
ParameterMap _params
 
ParameterMap _defaultParams
 

Additional Inherited Members

- Public Types inherited from Algorithm
typedef OrderedMap< SinkBaseInputMap
 
typedef OrderedMap< SourceBaseOutputMap
 
- Public Attributes inherited from Algorithm
DescriptionMap inputDescription
 
DescriptionMap outputDescription
 
- Public Attributes inherited from Configurable
DescriptionMap parameterDescription
 
DescriptionMap parameterRange
 
- Static Public Attributes inherited from Algorithm
static const std::string processingMode
 

Detailed Description

An AccumulatorAlgorithm is a special class of streaming algorithm that behaves in the following way:

  • during most of the processing, it just consumes whatever comes in on its defined input (unique), and use that to maintain an internal state
  • when the end of the stream is reached, it computes a resulting value and outputs it on its defined source(s).

By subclassing the AccumulatorAlgorithm class, you get all the buffering and data management done for you. In exchange, you just need to implement 2 methods:

  • void consume(); which will be called during the processing. When called, you can safely assume that the data has already been acquired on your defined input sink
  • void finalProduce(); which will be called at the end of the stream, when all the tokens will have been fed to the consume() method. You will have to explicitly push your result

You will also need to declare your input sink and output source using the specialized declareInputStream and declareOutputResult methods, instead of the standard declareInput and declareOutput ones.

As an example, please refer to the source code of the TCToTotal algorithm.

WARNING: declaring multiple input streams will result in undefined behavior. Multiple output results are fine, though.

WARNING: if you overload the reset() method, do not forget to call the base class implementation in it.

Constructor & Destructor Documentation

◆ AccumulatorAlgorithm()

Member Function Documentation

◆ consume()

virtual void consume ( )
pure virtual

◆ declareInput()

void declareInput ( )
protected

◆ declareInputStream()

void declareInputStream ( SinkBase sink,
const std::string &  name,
const std::string &  desc,
int  preferredAcquireSize = 4096 
)

◆ declareOutput()

void declareOutput ( )
protected

◆ declareOutputResult()

void declareOutputResult ( SourceBase source,
const std::string &  name,
const std::string &  desc 
)

◆ finalProduce()

virtual void finalProduce ( )
pure virtual

◆ process()

AlgorithmStatus process ( )
virtual

Implements Algorithm.

◆ reset()

void reset ( )
virtual

This function will be called when doing batch computations between each file that is processed. That is, if your algorithm is some sort of state machine, it allows you to reset it to its original state to process another file without having to delete and reinstantiate it. This function should not be called directly. Use resetNetwork instead to reset a network of connected Algorithms.

Reimplemented from Algorithm.

Member Data Documentation

◆ _inputStream

SinkBase* _inputStream
protected

◆ _preferredSize

int _preferredSize
protected

The documentation for this class was generated from the following file: