OperationSerializer Class Reference

#include <OperationSerializer.hh>

Inheritance diagram for OperationSerializer:

Collaboration diagram for OperationSerializer:

Public Member Functions
	OperationSerializer ()
virtual	~OperationSerializer ()
virtual void	writeState (const ObjectState *state)
virtual ObjectState *	readState ()
void	setSourceFile (const std::string &filename)
void	setDestinationFile (const std::string &filename)
void	setSchemaFile (const std::string &filename)
void	setUseSchema (bool useSchema)
Public Member Functions inherited from TCETools::Serializer
virtual	~Serializer ()

Private Member Functions
	OperationSerializer (const OperationSerializer &)
	Copying not allowed. More...
OperationSerializer &	operator= (const OperationSerializer &)
	Assignment not allowed. More...
ObjectState *	convertToXMLFormat (const ObjectState *state)
ObjectState *	convertToOperationFormat (const ObjectState *state)
ObjectState *	toOperation (const ObjectState *state)
ObjectState *	toXMLFormat (const ObjectState *state)
void	setOperandProperties (ObjectState *operand, ObjectState *source)

Private Attributes
XMLSerializer	serializer_
	Constructs the ObjectState tree from the XML file. More...

Detailed Description

Class that constructs an ObjectState tree that represents the information contents of an operation module from a given external file.

Definition at line 49 of file OperationSerializer.hh.

Constructor & Destructor Documentation

OperationSerializer() [1/2]

OperationSerializer::OperationSerializer

(

)

Constructor.

If schema file is found it is used.

Definition at line 67 of file OperationSerializer.cc.

                                         : Serializer() {
 
    string path = Environment::schemaDirPath(LIBRARY_NAME);
    if (path != "") {
        string schema = path + FileSystem::DIRECTORY_SEPARATOR + 
            SCHEMA_FILE_NAME;
        if (FileSystem::fileExists(schema)) {
            setSchemaFile(schema);
            setUseSchema(true);
        }
    }
}

References FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), LIBRARY_NAME, SCHEMA_FILE_NAME, Environment::schemaDirPath(), setSchemaFile(), and setUseSchema().

Here is the call graph for this function:

~OperationSerializer()

OperationSerializer::~OperationSerializer ( )

virtual

Destructor.

Definition at line 83 of file OperationSerializer.cc.

                                          {
}

OperationSerializer() [2/2]

OperationSerializer::OperationSerializer ( const OperationSerializer &  )

private

Copying not allowed.

Member Function Documentation

convertToOperationFormat()

ObjectState * OperationSerializer::convertToOperationFormat ( const ObjectState *  state )

private

Converts ObjectState to more easily parseable format.

More easily parseable format is such that there are less nodes. Only children of the main node are the operands, affects, and affected-by nodes.

Parameters

state

ObjectState to be converted.

Exceptions

ObjectStateLoadingException

If ObjectState conversion fails.

Returns

The converted ObjectState tree.

Definition at line 318 of file OperationSerializer.cc.

                                                                      {
    ObjectState* operation = new ObjectState(OPSER_OSAL);
    for (int i = 0; i < state->childCount(); i++) {
        ObjectState* child = state->child(i);
        operation->addChild(toOperation(child));
    }
    return operation;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), OPSER_OSAL, and toOperation().

Referenced by readState().

Here is the call graph for this function:

convertToXMLFormat()

ObjectState * OperationSerializer::convertToXMLFormat ( const ObjectState *  state )

private

Converts ObjectState to the format understood by XMLSerializer.

XMLSerializer needs an ObjectState tree in which each attribute is in its own node. ObjectState tree obtained form an operation is not in that format. This is why conversion is needed.

Parameters

state

ObjectState to be converted.

Exceptions

ObjectStateLoadingException

If ObjectState conversion fails.

Returns

The converted ObjectState tree.

Definition at line 147 of file OperationSerializer.cc.

                                                                {
    ObjectState* operation = new ObjectState(OPSER_OSAL);
    operation->setAttribute(OPSER_VERSION, VERSION_NUMBER);
    for (int i = 0; i < state->childCount(); i++) {
        ObjectState* child = state->child(i);
        operation->addChild(toXMLFormat(child));
    }
    return operation;
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), OPSER_OSAL, OPSER_VERSION, ObjectState::setAttribute(), toXMLFormat(), and VERSION_NUMBER.

Referenced by writeState().

Here is the call graph for this function:

operator=()

OperationSerializer& OperationSerializer::operator= ( const OperationSerializer &  )

private

Assignment not allowed.

readState()

ObjectState * OperationSerializer::readState ( )

virtual

Reads the Operation property file and returns a corresponding ObjectState.

ObjectState is converted to more easily parseable format before returning.

Returns

The read ObjectState tree.

Implements TCETools::Serializer.

Definition at line 118 of file OperationSerializer.cc.

                               {
    ObjectState* operationState = NULL;
    try {
        ObjectState* xmlState = serializer_.readState();
        operationState = convertToOperationFormat(xmlState);
        delete xmlState;
    } catch (const Exception& e) {
        string method = "OperationSerializer::readState()";
        string msg = "Problems reading the state: " + e.errorMessage();
        SerializerException error(__FILE__, __LINE__, __func__, msg);
        error.setCause(e);
        throw error;
    }
 
    return operationState;
}

References __func__, convertToOperationFormat(), Exception::errorMessage(), XMLSerializer::readState(), serializer_, and Exception::setCause().

Referenced by OSEdTreeView::constructTree(), OSEdRemoveOperationCmd::Do(), OSEdPropertiesCmd::Do(), OperationPropertyLoader::loadModule(), OperationContainer::operation(), OperationIndex::readOperations(), and OperationBuilder::verifyXML().

Here is the call graph for this function:

setDestinationFile()

void OperationSerializer::setDestinationFile

(

const std::string &

filename

)

Sets destination file.

Parameters

filename

The name of the file.

Definition at line 546 of file OperationSerializer.cc.

                                                                 {
    serializer_.setDestinationFile(filename);
}

References serializer_, and XMLSerializer::setDestinationFile().

Referenced by OSEdAddModuleCmd::Do(), OSEdRemoveOperationCmd::Do(), OSEdPropertiesCmd::Do(), and OSEdAddOperationCmd::Do().

Here is the call graph for this function:

setOperandProperties()

void OperationSerializer::setOperandProperties ( ObjectState *  operand, ObjectState *  source  )

private

Set operand properties to right values.

Parameters

operand	Operand which properties are set.
source	Original ObjectState tree.

Definition at line 508 of file OperationSerializer.cc.

                         {
 
    for (int childIndex = 0; childIndex < source->childCount();
         childIndex++) {
        
        ObjectState* child = source->child(childIndex);
        if (child->name() == Operand::OPRND_MEM_ADDRESS) {
            operand->setAttribute(Operand::OPRND_MEM_ADDRESS, true);
        } else if (child->name() == Operand::OPRND_MEM_DATA) {
            operand->setAttribute(Operand::OPRND_MEM_DATA, true);
        } else if (child->name() == Operand::OPRND_CAN_SWAP) {      
            ObjectState* canSwap = new ObjectState(*child);
            operand->addChild(canSwap);
        }
        if (child->name() == Operand::OPRND_MEM_UNITS) {
            operand->setAttribute(Operand::OPRND_MEM_UNITS,child->intValue());
        }
    }
}

References ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), ObjectState::intValue(), ObjectState::name(), Operand::OPRND_CAN_SWAP, Operand::OPRND_MEM_ADDRESS, Operand::OPRND_MEM_DATA, Operand::OPRND_MEM_UNITS, and ObjectState::setAttribute().

Referenced by toOperation().

Here is the call graph for this function:

setSchemaFile()

void OperationSerializer::setSchemaFile

(

const std::string &

filename

)

Sets schema file.

Parameters

fileName

The name of the file.

Definition at line 556 of file OperationSerializer.cc.

                                                            {
    serializer_.setSchemaFile(filename);
}

References serializer_, and XMLSerializer::setSchemaFile().

Referenced by OperationSerializer().

Here is the call graph for this function:

setSourceFile()

void OperationSerializer::setSourceFile

(

const std::string &

filename

)

Sets source file.

Parameters

filename

The name of the file.

Definition at line 536 of file OperationSerializer.cc.

                                                            {
    serializer_.setSourceFile(filename);
}

References serializer_, and XMLSerializer::setSourceFile().

Referenced by OSEdTreeView::constructTree(), OSEdRemoveOperationCmd::Do(), OSEdPropertiesCmd::Do(), OperationPropertyLoader::loadModule(), OperationContainer::operation(), OperationIndex::readOperations(), and OperationBuilder::verifyXML().

Here is the call graph for this function:

setUseSchema()

void OperationSerializer::setUseSchema

(

bool

useSchema

)

Sets whether schema is used or not.

Parameters

useSchema

True or false, depending on if schema is to be used or not.

Definition at line 566 of file OperationSerializer.cc.

                                                {
    serializer_.setUseSchema(useSchema);
}

References serializer_, and XMLSerializer::setUseSchema().

Referenced by OperationSerializer().

Here is the call graph for this function:

toOperation()

ObjectState * OperationSerializer::toOperation ( const ObjectState *  state )

private

Converts Operation ObjectState tree to more easily parsed format.

Parameters

state

ObjectState to be converted.

Exceptions

ObjectStateLoadingException

If ObjectState conversion fails.

Returns

The converted ObjectState tree.

Definition at line 335 of file OperationSerializer.cc.

                                                         {
    ObjectState* root = new ObjectState(Operation::OPRN_OPERATION);
    
    try {
        for (int i = 0; i < state->childCount(); i++) {
            
            ObjectState* child = state->child(i);
            
            if (child->name() == Operation::OPRN_NAME) {
                root->setAttribute(
                    Operation::OPRN_NAME, child->stringValue());
            } else if (child->name() == Operation::OPRN_DESCRIPTION) {
                root->setAttribute(Operation::OPRN_DESCRIPTION, child->stringValue());
            } else if (child->name() == Operation::OPRN_INPUTS) {
                root->setAttribute(Operation::OPRN_INPUTS, child->intValue());
            } else if (child->name() == Operation::OPRN_OUTPUTS) {
                root->setAttribute(Operation::OPRN_OUTPUTS, child->intValue());
            } else if (child->name() == Operation::OPRN_READS_MEMORY) {
                root->setAttribute(Operation::OPRN_READS_MEMORY, true);
            } else if (child->name() == Operation::OPRN_WRITES_MEMORY) {
                root->setAttribute(Operation::OPRN_WRITES_MEMORY, true);
            } else if (child->name() == Operation::OPRN_TRAP) {
                root->setAttribute(Operation::OPRN_TRAP, true);
            } else if (child->name() == Operation::OPRN_SIDE_EFFECTS) {
                root->setAttribute(Operation::OPRN_SIDE_EFFECTS, true);
            } else if (child->name() == Operation::OPRN_CLOCKED) {
                root->setAttribute(Operation::OPRN_CLOCKED, true);
            } else if (child->name() == Operation::OPRN_CONTROL_FLOW) {
                root->setAttribute(Operation::OPRN_CONTROL_FLOW, true);
            } else if (child->name() == Operation::OPRN_ISCALL) {
                root->setAttribute(Operation::OPRN_ISCALL, true);
            } else if (child->name() == Operation::OPRN_ISBRANCH) {
                root->setAttribute(Operation::OPRN_ISBRANCH, true);
 
//            } else if (child->name() == Operation::OPRN_AFFECTED_BY) {
//                ObjectState* affectedBy = new ObjectState(*child);
//                root->addChild(affectedBy);
                
//            } else if (child->name() == Operation::OPRN_AFFECTS) {
//                ObjectState* affects = new ObjectState(*child);
//                root->addChild(affects);
                
            } else if (child->name() == Operation::OPRN_IN) {
                ObjectState* inOperand = new ObjectState(Operation::OPRN_IN);
 
                inOperand->setAttribute(
                    Operand::OPRND_ID, 
                    child->intAttribute(Operand::OPRND_ID));
 
                inOperand->setAttribute(
                    Operand::OPRND_TYPE, 
                    child->stringAttribute(Operand::OPRND_TYPE));
 
                if (child->hasAttribute(Operand::OPRND_ELEM_WIDTH)) {
                    inOperand->setAttribute(
                        Operand::OPRND_ELEM_WIDTH, 
                        child->intAttribute(Operand::OPRND_ELEM_WIDTH));
                }
                
                if (child->hasAttribute(Operand::OPRND_ELEM_COUNT)) {
                    inOperand->setAttribute(
                        Operand::OPRND_ELEM_COUNT, 
                        child->intAttribute(Operand::OPRND_ELEM_COUNT));
                }
 
                root->addChild(inOperand);
                
                setOperandProperties(inOperand, child);
                
                if (!inOperand->hasAttribute(Operand::OPRND_MEM_ADDRESS)) {
                    inOperand->setAttribute(Operand::OPRND_MEM_ADDRESS, false);
                }
                
                if (!inOperand->hasAttribute(Operand::OPRND_MEM_DATA)) {
                    inOperand->setAttribute(Operand::OPRND_MEM_DATA, false);
                }
                
            } else if (child->name() == Operation::OPRN_OUT) {
                
                ObjectState* outOperand = new ObjectState(Operation::OPRN_OUT);
 
                outOperand->setAttribute(
                    Operand::OPRND_ID, 
                    child->intAttribute(Operand::OPRND_ID));
 
                outOperand->setAttribute(
                    Operand::OPRND_TYPE, 
                    child->stringAttribute(Operand::OPRND_TYPE));
 
                if (child->hasAttribute(Operand::OPRND_ELEM_WIDTH)) {
                    outOperand->setAttribute(
                        Operand::OPRND_ELEM_WIDTH, 
                        child->intAttribute(Operand::OPRND_ELEM_WIDTH));
                }
                
                if (child->hasAttribute(Operand::OPRND_ELEM_COUNT)) {
                    outOperand->setAttribute(
                        Operand::OPRND_ELEM_COUNT, 
                        child->intAttribute(Operand::OPRND_ELEM_COUNT));
                }
 
                root->addChild(outOperand);
                setOperandProperties(outOperand, child);
                
                outOperand->setAttribute(Operand::OPRND_MEM_ADDRESS, false);
                
                if (!outOperand->hasAttribute(Operand::OPRND_MEM_DATA)) {
                    outOperand->setAttribute(Operand::OPRND_MEM_DATA, false);
                }
 
            } else {
                // just copy other elements
                ObjectState* copyChild = new ObjectState(*child);
                root->addChild(copyChild);                 
            } 
        }
 
        root->setAttribute(
            Operation::OPRN_NAME, StringTools::stringToUpper(
                root->stringAttribute(Operation::OPRN_NAME)));
        
        if (!root->hasAttribute(Operation::OPRN_DESCRIPTION)) {
            root->setAttribute(Operation::OPRN_DESCRIPTION, std::string(""));
        }
 
        if (!root->hasAttribute(Operation::OPRN_READS_MEMORY)) {
            root->setAttribute(Operation::OPRN_READS_MEMORY, false);
        }
        
        if (!root->hasAttribute(Operation::OPRN_WRITES_MEMORY)) {
            root->setAttribute(Operation::OPRN_WRITES_MEMORY, false);
        }
        
        if (!root->hasAttribute(Operation::OPRN_TRAP)) {
            root->setAttribute(Operation::OPRN_TRAP, false);
        }
        
        if (!root->hasAttribute(Operation::OPRN_SIDE_EFFECTS)) {
            root->setAttribute(Operation::OPRN_SIDE_EFFECTS, false);
        }
        
        if (!root->hasAttribute(Operation::OPRN_CLOCKED)) {
            root->setAttribute(Operation::OPRN_CLOCKED, false);
        }
 
        if (!root->hasAttribute(Operation::OPRN_CONTROL_FLOW)) {
            root->setAttribute(Operation::OPRN_CONTROL_FLOW, false);
        }
        if (!root->hasAttribute(Operation::OPRN_ISCALL)) {
            root->setAttribute(Operation::OPRN_ISCALL, false);
        }
        if (!root->hasAttribute(Operation::OPRN_ISBRANCH)) {
            root->setAttribute(Operation::OPRN_ISBRANCH, false);
        }
 
    } catch (const Exception& e) {
        string msg = "Error while constructing ObjectState tree" +
            e.errorMessage();
        ObjectStateLoadingException error(__FILE__, __LINE__, __func__, msg);
        error.setCause(e);
        throw error;
    }
    
    return root;
}

References __func__, ObjectState::addChild(), ObjectState::child(), ObjectState::childCount(), Exception::errorMessage(), ObjectState::hasAttribute(), ObjectState::intAttribute(), ObjectState::intValue(), ObjectState::name(), Operation::OPRN_CLOCKED, Operation::OPRN_CONTROL_FLOW, Operation::OPRN_DESCRIPTION, Operation::OPRN_IN, Operation::OPRN_INPUTS, Operation::OPRN_ISBRANCH, Operation::OPRN_ISCALL, Operation::OPRN_NAME, Operation::OPRN_OPERATION, Operation::OPRN_OUT, Operation::OPRN_OUTPUTS, Operation::OPRN_READS_MEMORY, Operation::OPRN_SIDE_EFFECTS, Operation::OPRN_TRAP, Operation::OPRN_WRITES_MEMORY, Operand::OPRND_ELEM_COUNT, Operand::OPRND_ELEM_WIDTH, Operand::OPRND_ID, Operand::OPRND_MEM_ADDRESS, Operand::OPRND_MEM_DATA, Operand::OPRND_TYPE, ObjectState::setAttribute(), Exception::setCause(), setOperandProperties(), ObjectState::stringAttribute(), StringTools::stringToUpper(), and ObjectState::stringValue().

Referenced by convertToOperationFormat().

Here is the call graph for this function:

toXMLFormat()

ObjectState * OperationSerializer::toXMLFormat ( const ObjectState *  state )

private

Converts an individual operation to xml format.

Parameters

state

ObjectState to be converted.

Exceptions

ObjectStateLoadingException

If ObjectState conversion fails.

Returns

The converted ObjectState tree.

Definition at line 165 of file OperationSerializer.cc.

                                                         {
    ObjectState* oper = new ObjectState(Operation::OPRN_OPERATION);
    try {
        ObjectState* nameChild = new ObjectState(Operation::OPRN_NAME);
        nameChild->setValue(state->stringAttribute(Operation::OPRN_NAME));
        oper->addChild(nameChild);
 
        ObjectState* descriptionChild = new ObjectState(Operation::OPRN_DESCRIPTION);
        descriptionChild->setValue(state->stringAttribute(Operation::OPRN_DESCRIPTION));
        oper->addChild(descriptionChild); 
        
        ObjectState* inputChild = new ObjectState(Operation::OPRN_INPUTS);
        inputChild->setValue(state->intAttribute(Operation::OPRN_INPUTS));
        oper->addChild(inputChild);
        
        ObjectState* outputChild = new ObjectState(Operation::OPRN_OUTPUTS);
        outputChild->setValue(state->intAttribute(Operation::OPRN_OUTPUTS));
        oper->addChild(outputChild);
        
        if (state->boolAttribute(Operation::OPRN_READS_MEMORY)) {
            oper->addChild(new ObjectState(Operation::OPRN_READS_MEMORY));
        }
        
        if (state->boolAttribute(Operation::OPRN_WRITES_MEMORY)) {
            oper->addChild(new ObjectState(Operation::OPRN_WRITES_MEMORY));
        }
        
        if (state->boolAttribute(Operation::OPRN_TRAP)) {
            oper->addChild(new ObjectState(Operation::OPRN_TRAP));
        }
        
        if (state->boolAttribute(Operation::OPRN_SIDE_EFFECTS)) {
            oper->addChild(new ObjectState(Operation::OPRN_SIDE_EFFECTS));
        }
        
        if (state->boolAttribute(Operation::OPRN_CLOCKED)) {
            oper->addChild(new ObjectState(Operation::OPRN_CLOCKED));
        }
 
        if (state->boolAttribute(Operation::OPRN_CONTROL_FLOW)) {
            oper->addChild(new ObjectState(Operation::OPRN_CONTROL_FLOW));
        }
 
        if (state->boolAttribute(Operation::OPRN_ISCALL)) {
            oper->addChild(new ObjectState(Operation::OPRN_ISCALL));
        }
 
        if (state->boolAttribute(Operation::OPRN_ISBRANCH)) {
            oper->addChild(new ObjectState(Operation::OPRN_ISBRANCH));
        }
        
        for (int i = 0; i < state->childCount(); i++) {
            
            ObjectState* child = state->child(i);
            if (child->name() == Operation::OPRN_IN || 
                child->name() == Operation::OPRN_OUT) {
                
                ObjectState* operandChild = NULL;
                if (child->name() == Operation::OPRN_IN) {
                    operandChild = new ObjectState(Operation::OPRN_IN);
                } else {
                    operandChild = new ObjectState(Operation::OPRN_OUT);
                }
                
                operandChild->setAttribute(
                    Operand::OPRND_ID, 
                    child->intAttribute(Operand::OPRND_ID));
                
                operandChild->setAttribute(
                    Operand::OPRND_TYPE, 
                    child->stringAttribute(Operand::OPRND_TYPE));
 
                if (child->hasAttribute(Operand::OPRND_ELEM_WIDTH)) {
                    operandChild->setAttribute(
                        Operand::OPRND_ELEM_WIDTH, 
                        child->intAttribute(Operand::OPRND_ELEM_WIDTH));
                } 
                
                if (child->hasAttribute(Operand::OPRND_ELEM_COUNT)) {
                    operandChild->setAttribute(
                        Operand::OPRND_ELEM_COUNT, 
                        child->intAttribute(Operand::OPRND_ELEM_COUNT));
                }
 
                if (child->boolAttribute(Operand::OPRND_MEM_ADDRESS)) {
                    operandChild->
                        addChild(new ObjectState(Operand::OPRND_MEM_ADDRESS));
                }
                
                if (child->boolAttribute(Operand::OPRND_MEM_DATA)) {
                    operandChild->addChild(
                        new ObjectState(Operand::OPRND_MEM_DATA));
                }
 
                if (child->hasAttribute(Operand::OPRND_MEM_UNITS)) {
                    ObjectState* units = new ObjectState(
                        Operand::OPRND_MEM_UNITS);
                    units->setValue(child->intAttribute(
                                        Operand::OPRND_MEM_UNITS));
                    operandChild->addChild(units);
                }
                
                // can swap list
                if (child->childCount() > 0) {
                    ObjectState* swap = 
                        new ObjectState(Operand::OPRND_CAN_SWAP);
                    ObjectState* canSwap = child->child(0);
 
                    for (int j = 0; j < canSwap->childCount(); j++) {
                        ObjectState* swapChild = canSwap->child(j);
                        
                        ObjectState* newSwap = 
                            new ObjectState(Operand::OPRND_IN);
 
                        newSwap->setAttribute(
                            Operand::OPRND_ID, 
                            swapChild->intAttribute(Operand::OPRND_ID));
                        swap->addChild(newSwap);
                                              
                    }
                    operandChild->addChild(swap);
                }
 
                oper->addChild(operandChild);
            } else {
                
                ObjectState* newChild = new ObjectState(*child);
                oper->addChild(newChild);
            }
        }
            
    } catch (const Exception& e) {
        string msg = "Error while constructing ObjectState tree: " +
            e.errorMessage();
        ObjectStateLoadingException error(__FILE__, __LINE__, __func__, msg);
        error.setCause(e);
        throw error;
    }
    return oper;
}

References __func__, ObjectState::addChild(), ObjectState::boolAttribute(), ObjectState::child(), ObjectState::childCount(), Exception::errorMessage(), ObjectState::hasAttribute(), ObjectState::intAttribute(), ObjectState::name(), Operation::OPRN_CLOCKED, Operation::OPRN_CONTROL_FLOW, Operation::OPRN_DESCRIPTION, Operation::OPRN_IN, Operation::OPRN_INPUTS, Operation::OPRN_ISBRANCH, Operation::OPRN_ISCALL, Operation::OPRN_NAME, Operation::OPRN_OPERATION, Operation::OPRN_OUT, Operation::OPRN_OUTPUTS, Operation::OPRN_READS_MEMORY, Operation::OPRN_SIDE_EFFECTS, Operation::OPRN_TRAP, Operation::OPRN_WRITES_MEMORY, Operand::OPRND_CAN_SWAP, Operand::OPRND_ELEM_COUNT, Operand::OPRND_ELEM_WIDTH, Operand::OPRND_ID, Operand::OPRND_IN, Operand::OPRND_MEM_ADDRESS, Operand::OPRND_MEM_DATA, Operand::OPRND_MEM_UNITS, Operand::OPRND_TYPE, ObjectState::setAttribute(), Exception::setCause(), ObjectState::setValue(), and ObjectState::stringAttribute().

Referenced by convertToXMLFormat().

Here is the call graph for this function:

writeState()

void OperationSerializer::writeState ( const ObjectState *  state )

virtual

Writes the state of operations to XML file.

The states of operations are first converted to the format understood by XMLSerializer and then written.

Parameters

state

ObjectState to be written.

Exceptions

SerializerException

If error occurs.

Implements TCETools::Serializer.

Definition at line 96 of file OperationSerializer.cc.

                                                        {
    try {
        ObjectState* converted = convertToXMLFormat(state);
        serializer_.writeState(converted);
        delete converted;
    } catch (const Exception& e) {
        string method = "OperationSerializer::writeState()";
        string msg = "Problems writing the state: " + e.errorMessage();
        SerializerException error(__FILE__, __LINE__, __func__, msg);
        error.setCause(e);
        throw error;
    }
}

References __func__, convertToXMLFormat(), Exception::errorMessage(), serializer_, Exception::setCause(), and XMLSerializer::writeState().

Referenced by OSEdAddModuleCmd::Do(), OSEdRemoveOperationCmd::Do(), OSEdPropertiesCmd::Do(), and OSEdAddOperationCmd::Do().

Here is the call graph for this function:

Member Data Documentation

serializer_

XMLSerializer OperationSerializer::serializer_

private

Constructs the ObjectState tree from the XML file.

Definition at line 77 of file OperationSerializer.hh.

Referenced by readState(), setDestinationFile(), setSchemaFile(), setSourceFile(), setUseSchema(), and writeState().

---

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

• OperationSerializer.hh
• OperationSerializer.cc