name: AlgorithmContainer : public AlgorithmBase

synopsis:

g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_algo.a

#include <AlgorithmContainer.h>

AlgorithmContainer();
AlgorithmContainer(const AlgorithmContainer& arg);
boolean eq(const AlgorithmContainer& arg);
boolean setAlgorithm(ALGORITHM algorithm);

quick start:

AlgorithmContainer lab;
lab.setGraphTag(14);

description:

The AlgorithmContainer class is used as a dummy placeholder for subgraphs. This class allows container objects to be specified in a recipe (via isip_transform_builder) and to be read by isip_transform.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"AlgorithmContainer";

define the algorithm choices:

enum ALGORITHM { SUB_GRAPH = 0, DEF_ALGORITHM = SUB_GRAPH };

define the implementation choices:

enum IMPLEMENTATION { EXPAND = 0, DEF_IMPLEMENTATION = EXPAND };

define static NameMap objects

static const NameMap ALGO_MAP(L"SUB_GRAPH");

static const NameMap IMPL_MAP(L"EXPAND");

define i/o related constants:

static const String DEF_PARAM = L"";

static const String PARAM_ALGORITHM = L"algorithm";

static const String PARAM_IMPLEMENTATION = L"implementation";

static const String PARAM_GRAPH_TAG = L"graph_tag";

static const String PARAM_VARIABLE = L"variable";

define default value(s) of the class data:
```
static const long DEF_GRAPH_TAG = -1;
```
define default argument(s):
```
none.
```

error codes:

error code indicating AlgorithmContainer class general error:
```
static const long ERR = 73200;
```

protected data:

data common to all algorithms and implementations:

define an algorithm name:
ALGORITHM algorithm_d;

define an implementation name:
IMPLEMENTATION implementation_d;

the graph tag
Long graph_tag_d;

the container variable name
String varname_d;

static memory manager:
static MemoryManager mgr_d;
algorithm and implementation specific variables:
```
none.
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods: setDebug method is inherited from base class
```
boolean debug(const unichar* message) const;
```

destructor/constructor(s):

~AlgorithmContainer();

AlgorithmContainer(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION, long graph_tag = DEF_GRAPH_TAG);

AlgorithmContainer(const AlgorithmContainer& arg);

assign methods:

boolean assign(const AlgorithmContainer& arg);

operator= methods:

AlgorithmContainer& operator= (const AlgorithmContainer& arg);

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);

boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;

boolean readData(Sof& sof, const String& pname = DEF_PARAM, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

equality methods:

boolean eq(const AlgorithmContainer& arg) const;

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);

class-specific public methods:

set methods:

boolean setAlgorithm(ALGORITHM algorithm);

boolean setImplementation(IMPLEMENTATION implementation);

boolean setVariable(const String& name);

boolean setGraphTag(long arg);

boolean set(ALGORITHM algorithm = DEF_ALGORITHM, IMPLEMENTATION implementation = DEF_IMPLEMENTATION,long graph_tag = DEF_GRAPH_TAG);

get methods:

ALGORITHM getAlgorithm() const;

IMPLEMENTATION getImplementation() const;

const String& getVariable() const;

long getGraphTag() const;

boolean get(ALGORITHM& algorithm, IMPLEMENTATION& implementation, long& graph_tag) const;

AlgorithmBase interface contract methods:

boolean assign(const AlgorithmBase& arg);

boolean eq(const AlgorithmBase& arg) const;

const String& className() const;

boolean apply(Vector<AlgorithmData>& output, const Vector<AlgorithmData>& input);

boolean setParser(SofParser* parser);

private methods:

none

examples:

none

notes:

This class is not used by standard Algorithm classes for computational purposes. Instead, it simply exists to allow for containers to be specified in a recipe used by isip_transform.