Using field lists with operators

You can use field lists when you specify the interface schema to an operator with a dynamic interface.

The following example defines one such operator, called DynamicOperator:

Figure 1. DynamicOperator

The operator has the following characteristics:

Takes a single data set as input.
Writes its results to a single output data set.
Has an input interface schema consisting of a single schema variable inRec and an output interface schema consisting of a single schema variable outRec.

To use this operator, you would specify the field list to its constructor, as shown in the following statement:

static char schema[] =  "record" 					// Schema of input data set
			"( a:int32; "
			" b:int32; "
			" c:int16; "
			" d:sfloat; "
			" e:string; )";
DynamicOperator aDynamicOp("a - c"); 					// Specify the input schema

The following table shows the definition of DynamicOperator. Comments follow the code in the table.

Table 1. DynamicOperator
Comment	Code
8 16 17 23 24 25 26 31 32 34 35 36 38 41 42	#include <apt_framework/orchestrate.h> class DynamicOperator : public APT_Operator { APT_DECLARE_RTTI(DynamicOperator); APT_DECLARE_PERSISTENT(DynamicOperator); public: DynamicOperator(); DynamicOperator(const APT_FieldList& fList) : inSchema(), inFList(fList) {} protected: virtual APT_Status describeOperator(); virtual APT_Status runLocally(); virtual APT_Status initializeFromArgs_(const APT_PropertyList &args, APT_Operator::InitializeContext context); private: APT_Schema inSchema; APT_FieldList inFList; . . . APT_Status DynamicOperator::describeOperator() { setKind(APT_Operator::eParallel); setInputDataSets(1); setOutputDataSets(1); APT_Schema tempSchema = viewAdaptedSchema(0); APT_FieldList::Error err; inFList.expand(tempSchema, &err); if (err.errorOccurred()) { reportError(err.description()); return APT_StatusFailed; } int numFields = inFList.numFields(); for (int n = 0; n < numFields; n++) { APT_FieldSelector fs = inFList.field(n); APT_SchemaField f = tempSchema.field(fs); inSchema.addField(f); } APT_SchemaField inField; inField.setIdentifier("inRec"); inField.setTypeSpec(""); inSchema.addField(inField); setInputInterfaceSchema(inSchema, 0); setOutputInterfaceSchema("record (outRec:;)", 0); declareTransfer("inRec", "outRec", 0, 0); Return APT_StatusOk; }

Table 1. DynamicOperator

Comment

Code

#include <apt_framework/orchestrate.h>

class DynamicOperator : public APT_Operator
{

	APT_DECLARE_RTTI(DynamicOperator);
	APT_DECLARE_PERSISTENT(DynamicOperator);


	public:
		DynamicOperator();
		DynamicOperator(const APT_FieldList& fList)
				: inSchema(), inFList(fList)
		{}

	protected:
		virtual APT_Status describeOperator();
		virtual APT_Status runLocally();
		virtual APT_Status initializeFromArgs_(const APT_PropertyList
			&args, APT_Operator::InitializeContext context); 

	private:
		APT_Schema inSchema;
		APT_FieldList inFList;

		. . .
	APT_Status DynamicOperator::describeOperator()
	{
		setKind(APT_Operator::eParallel);
		setInputDataSets(1);
		setOutputDataSets(1);

	APT_Schema tempSchema = viewAdaptedSchema(0);
	APT_FieldList::Error err;
	inFList.expand(tempSchema, &err);
	if (err.errorOccurred()) 
	{ 
		reportError(err.description()); 
		return APT_StatusFailed; 
	}
	int numFields = inFList.numFields();
	for (int n = 0; n < numFields; n++) 
	{
		APT_FieldSelector fs = inFList.field(n);
		APT_SchemaField f = tempSchema.field(fs);
		inSchema.addField(f);
	}

	APT_SchemaField inField;
	inField.setIdentifier("inRec");
	inField.setTypeSpec("*");
	inSchema.addField(inField);

	setInputInterfaceSchema(inSchema, 0);
	setOutputInterfaceSchema("record (outRec:*;)", 0);

	declareTransfer("inRec", "outRec", 0, 0);

	Return APT_StatusOk;
}

8: Define a constructor that takes a field list as an argument.
16: Define storage for the complete input interface schema to the operator.
17: Define storage for the input field list specifying the input schema.
23: Use APT_Operator::viewAdaptedSchema() to obtain the complete record schema of the input data set. You will expand the input field list in the context of the input data set record schema.
24: Define err, an instance of APT_FieldList::Error, to hold any errors generated when expanding the field list.
25: Use APT_FieldList::expand() to expand the field list relative to the record schema of the input data set. If the field list does not contain a wildcard or field range, the expand function does nothing.
26: If any errors occurred during the expansion, print the description of the error and return APT_StatusFailed from describeOperator().
31: Use APT_FieldList::numFields() to determine the number of fields in the field list.
32: Create a for loop to iterate through the field lists. For each element in the field list, add a schema field to inSchema, the input interface schema of the operator.
34: Use APT_FieldList::field() to get a field selector from the expanded field list.
35: Use APT_Schema::field() to return an APT_SchemaField object corresponding to a record schema field of the input data set.
36: Use APT_Schema::addField() to add the APT_SchemaField object to inSchema.
38 - 41: After adding all the fields of the field list to the input interface schema, you must create a schema field component for the schema variable "inRec:*;" and add that component to the input interface schema. Use APT_Schema::addField() to add the schema variable to allow transfers from the input data set to the output data set.
42: Use APT_Operator::setInputInterfaceSchema() to set the input interface schema of the operator to the schema contained in inSchema.