name: Recipe

synopsis:

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

#include <Recipe.h>

Recipe();
Recipe(const Recipe& arg);
boolean isEmpty() const;
boolean readGraph(Sof& sof, long graph_tag = 0);

quick start:

Recipe rcp;
Sof sof;
sof.open(L"diagnose_container.sof");
rcp.readGraph(sof);

description:

The Recipe class is used by the FrontEnd class to allow the user to specify an arbitrary signal flow graph for front end processing. The user specifies what processing should take place to transform input to output by specifying a graph using the transform_builder. This class is responsible for reading in Component graph and finding the appropriate processing paths through the graph.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"Recipe";

define i/o related constants:

static const String PARAM_RECIPE = L"recipe";

define default value(s) of class data:

static const String INPUT_PREFIX = L"__input_";

static const String OUTPUT_PREFIX = L"__output_";
       static const String SAMPLED_DATA_NAME = L"__input_SAMPLED_DATA";
       static const String DUMMY_OUTPUT_NAME = L"__output_FEATURES";

error codes:

general error codes:
```
static const long ERR = 80400;
```
multiple component paths exist to output:
```
static const long ERR_MPATH = 80401;
```
no component path exists to output:
```
static const long ERR_NORPATH = 80402;
```

protected data:

recipe pool:

DiGraph<Component> recipe_d;

static debug level:

static Integral::DEBUG debug_level_d = Integral::NONE;

static memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean debug(const unichar* message) const;

static boolean setDebug(Integral::DEBUG debug_level);

destructor/constructor(s):

~Recipe();

Recipe();

Recipe(const Recipe& arg);

assign methods:
```
boolean assign(const Recipe& 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 Recipe& 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 and get methods:

boolean setAllocationMode(DstrBase::ALLOCATION alloc);

DstrBase::ALLOCATION getAllocationMode() const;

methods to manipulate graphs:

boolean readGraph(Sof& sof, long graph_tag);

boolean isEmpty() const;

boolean findRecipe(SingleLinkedList<Component>& comp, const FrontEndBase& fend, const String& cname);

boolean findComponent(SingleLinkedList<Component>& comp, const FrontEndBase& fend, Vector<String>& inputs);

boolean delayComponent(Vector<SingleLinkedList<Component> >& dcomp, FtrBuffer& buf, const FrontEndBase& fend, SingleLinkedList<Component>& temp_list);

private methods:

topological sort methods:

boolean topologicalSort(SingleLinkedList<Component>& sorted_data, boolean partial = false);

color hash table creation methods:

boolean makeColorHash(Integral::COLOR col = Integral::DEF_COLOR);

path related methods:

boolean reverseVisitDfs(const FrontEndBase& fend, const String& cname);

support methods for readRecipeGraph:

boolean checkInputs();

boolean expandSubGraphs(Sof& sof);

boolean readSubGraph(GraphVertex<Component>*& sub_in, GraphVertex<Component>*& sub_out, Sof& sof, long graph_tag);

examples:

This example demonstrates how to use the Recipe class:

Recipe rcp;
Sof sof;
sof.open(L"diagnose_container.sof");
rcp.readGraph(sof);

SingleLinkedList algos(DstrBase::USER);
SingleLinkedList< Triple< Pair, Float, Boolean> > topo;

algos.read(sof, 0);
topo.read(sof, 0);
DiGraph expected;
expected.assign(algos, topo);
if (!rcp.recipe_d.eq(expected)) {
  rcp.recipe_pool_d.debug(L"recipe");
}
sof.close();

notes:

This class is not intended to be used by application programmers. It is a core class in the front end software, and is used heavily by isip_transform.