OperationIndex Class Reference

#include <OperationIndex.hh>

Collaboration diagram for OperationIndex:

Public Member Functions
	OperationIndex ()
virtual	~OperationIndex ()
void	addPath (const std::string &path)
std::string	path (int i) const
int	pathCount () const
OperationModule &	module (int i)
int	moduleCount () const
OperationModule &	module (int i, const std::string &path)
int	moduleCount (const std::string &path) const
void	addModule (OperationModule *module, const std::string &path)
void	removeModule (const std::string &path, const std::string &modName)
void	refreshModule (const std::string &path, const std::string &modName)
OperationModule &	moduleOf (const std::string &name)
std::string	operationName (int i, const OperationModule &om)
int	operationCount (const OperationModule &om)
Operation *	effectiveOperation (const TCEString &name)

Static Public Attributes
static const std::string	PROPERTY_FILE_EXTENSION = ".opp"

Private Types
typedef std::map< std::string, std::vector< OperationModule * > >	ModuleTable
	Contains all operation modules indexed by full path names.
typedef std::map< std::string, ObjectState * >	DefinitionTable
	Contains all object state trees of modules indexed by operation definition module names.

Private Member Functions
	OperationIndex (const OperationIndex &)
	Copying not allowed.
OperationIndex &	operator= (const OperationIndex &)
	Assignment not allowed.
void	readOperations (const OperationModule &module)
OperationModule &	moduleOf (const std::string &path, const std::string &operName)

Private Attributes
std::vector< std::string >	paths_
	List of paths searched for the operation modules.
ModuleTable	modulesInPath_
	Contains all operation modules found in a search path organized by path names.
DefinitionTable	opDefinitions_
	Contains all operation definitions defined in available operation modules indexed by module names.
std::vector< OperationModule * >	modules_
	Container holding all modules.
OperationSerializer	serializer_
	Reads the operation property definitions.
OperationBehaviorLoader	loader_
std::vector< OperationBehaviorProxy * >	proxies_
std::set< const OperationModule * >	brokenModules_

Detailed Description

Class that holds information about search paths, modules and operations.

An indexed table of all operations available organized by modules and indexed by names.

Definition at line 58 of file OperationIndex.hh.

Member Typedef Documentation

DefinitionTable

typedef std::map<std::string, ObjectState*> OperationIndex::DefinitionTable

private

Contains all object state trees of modules indexed by operation definition module names.

Definition at line 90 of file OperationIndex.hh.

ModuleTable

typedef std::map<std::string, std::vector<OperationModule*> > OperationIndex::ModuleTable

private

Contains all operation modules indexed by full path names.

Definition at line 87 of file OperationIndex.hh.

Constructor & Destructor Documentation

OperationIndex() [1/2]

OperationIndex::OperationIndex

(

)

Constructor.

Definition at line 58 of file OperationIndex.cc.

                               : loader_(*this) {
}

~OperationIndex()

OperationIndex::~OperationIndex ( )

virtual

Destructor.

Deletes all object state trees modeling module properties. Deletes all modules.

Definition at line 67 of file OperationIndex.cc.

                                {
    AssocTools::deleteAllValues(opDefinitions_);
    SequenceTools::deleteAllItems(modules_);
    SequenceTools::deleteAllItems(proxies_);
}

References SequenceTools::deleteAllItems(), AssocTools::deleteAllValues(), modules_, opDefinitions_, and proxies_.

Here is the call graph for this function:

OperationIndex() [2/2]

OperationIndex::OperationIndex ( const OperationIndex &  )

private

Copying not allowed.

Member Function Documentation

addModule()

void OperationIndex::addModule	(	OperationModule *	module,
		const std::string &	path
	)

Adds a new module to OperationIndex.

Parameters

module	Module to be added.
path	Path in which module is located.

Exceptions

PathNotFound

If path is not found.

Definition at line 193 of file OperationIndex.cc.

                                                                        {
    ModuleTable::iterator it = modulesInPath_.find(path);
    if (it == modulesInPath_.end()) {
        string method = "OperationIndex::addModule()";
        string msg = "Path not found.";
        throw PathNotFound(__FILE__, __LINE__, method, msg, path);
    }
    modules_.push_back(module);
    (*it).second.push_back(module);
}

References module(), modules_, modulesInPath_, and path().

Referenced by OSEdAddModuleCmd::Do().

Here is the call graph for this function:

addPath()

void OperationIndex::addPath

(

const std::string &

path

)

Adds a path to search path list.

When the path is added, all modules in that path are automatically scanned and recorded.

Parameters

path	The path to be added.

Definition at line 82 of file OperationIndex.cc.

                                             {
    
    ModuleTable::iterator iter = modulesInPath_.find(path);
    if (iter != modulesInPath_.end()) {
        return;
    }
 
    paths_.push_back(path);
    vector<string> modules;
    string pattern = path + FileSystem::DIRECTORY_SEPARATOR + 
        FileSystem::STRING_WILD_CARD + PROPERTY_FILE_EXTENSION;
 
    FileSystem::globPath(pattern, modules);
    
    vector<OperationModule*> opModules;
    for (unsigned int i = 0; i < modules.size(); i++) {
        string file = FileSystem::fileOfPath(modules[i]);
        string behaviourFile = modules[i];
        string behaviourSourceFile = 
            behaviourFile.substr(0, behaviourFile.length() - 3) + "cc";
        
        // behaviour is .opb , change last letter from p to b
        *(behaviourFile.rbegin()) = 'b';
        
        // load only modules which have behaviour file.
        if (!FileSystem::fileExists(behaviourFile) &&
            FileSystem::fileExists(behaviourSourceFile)) {
            OperationBuilder& opBuilder = OperationBuilder::instance();
            std::vector<std::string> output;
            bool buildOk = opBuilder.buildObject(
                file.substr(0, file.length()-4), behaviourSourceFile, 
                path, output);
            if (!buildOk || !FileSystem::fileExists(behaviourFile)) {
                std::cerr << "Warning: Found operation module specification "
                          << "file " << modules[i] << " and operation "
                          << "behavious source file " << behaviourSourceFile
                          << " without compiled behaviour "
                          << "implementation file "
                          << behaviourFile << "." << std::endl;
                std::cerr << "Tried to compile behaviour impelementaton "
                          << "file, but the compilation failed to error: "
                          << std::endl;
                for (unsigned int j = 0; j < output.size(); j++) {
                    std::cerr << output[j] << std::endl;
                }
                std::cerr << "This may cause program to hang if operation "
                          << "in this module is attempted to be simulated."
                          << std::endl;
            }
        }
        OperationModule*  module = 
            new OperationModule(FileSystem::fileNameBody(file), path);
        modules_.push_back(module);
        opModules.push_back(module);
    }
    modulesInPath_[path] = opModules;
}

References OperationBuilder::buildObject(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), FileSystem::fileOfPath(), FileSystem::globPath(), OperationBuilder::instance(), module(), modules_, modulesInPath_, path(), paths_, PROPERTY_FILE_EXTENSION, and FileSystem::STRING_WILD_CARD.

Referenced by OSEdAddModuleCmd::Do(), OperationContainer::operation(), OperationContainer::operationIndex(), and OperationPoolPimpl::OperationPoolPimpl().

Here is the call graph for this function:

effectiveOperation()

Operation * OperationIndex::effectiveOperation

(

const TCEString &

name

)

Returns a new instance of the Operation with the given name that is 'effective' based on the search path priorities.

Definition at line 454 of file OperationIndex.cc.

                                                        {
 
    OperationModule& mod = moduleOf(name);
 
    DefinitionTable::const_iterator dt = 
        opDefinitions_.find(mod.propertiesModule());
 
    assert (dt != opDefinitions_.end());
 
    ObjectState* root = (*dt).second;
    ObjectState* child = NULL;
    
    // load operations
    for (int i = 0; i < root->childCount(); i++) {
        child = root->child(i);
        const TCEString operName = 
            root->child(i)->stringAttribute(Operation::OPRN_NAME);
      
        /* Do not load all operations in the module because the user
           might have overridden some of the operation (properties)
           in a local search path with higher order. Just load the one 
           requested. */
        if (!operName.ciEqual(name))
            continue;
        
        Operation* oper = 
            new Operation(operName, NullOperationBehavior::instance());
      
        oper->loadState(child);
        // add the behavior loader proxy
        OperationBehaviorProxy* proxy = 
            new OperationBehaviorProxy(*oper, loader_);
        proxies_.push_back(proxy);
        oper->setBehavior(*proxy);
        return oper;
    }
    return NULL;
}

References assert, ObjectState::child(), ObjectState::childCount(), TCEString::ciEqual(), NullOperationBehavior::instance(), loader_, Operation::loadState(), moduleOf(), opDefinitions_, Operation::OPRN_NAME, OperationModule::propertiesModule(), proxies_, Operation::setBehavior(), and ObjectState::stringAttribute().

Referenced by OperationPoolPimpl::operation(), and FUGen::parseOperations().

Here is the call graph for this function:

module() [1/2]

OperationModule & OperationIndex::module

(

int

i

)

Referenced by addModule(), addPath(), OSEdTreeView::constructTree(), OperationContainer::isEffective(), OperationContainer::module(), moduleOf(), OperationContainer::operationExists(), readOperations(), refreshModule(), and writeCustomOpMacros().

module() [2/2]

OperationModule & OperationIndex::module	(	int	i,
		const std::string &	path
	)

Returns the module by the given index in a given path.

Parameters

i	The index of wanted module.
path	The path of the module

Returns

The module by the given index in a given path, or null module if path is not found.

Exceptions

OutOfRange	If index i is out of range.
PathNotFound	If path is not found.

Definition at line 151 of file OperationIndex.cc.

                                                   {
    ModuleTable::iterator it = modulesInPath_.find(path);
    if (it == modulesInPath_.end()) {
        string msg = "Path for the module not found.";
        throw PathNotFound(__FILE__, __LINE__, __func__, msg, path);
    }
    
    if (i < 0 || i > static_cast<int>((*it).second.size()) - 1) {
        string msg = "Index out of range.";
        throw OutOfRange(__FILE__, __LINE__, __func__, msg);
    }
 
    OperationModule* module = ((*it).second)[i];
    return *module;
}

References __func__, modulesInPath_, and path().

Here is the call graph for this function:

moduleCount() [1/2]

int OperationIndex::moduleCount

(

)

const

Referenced by OSEdTreeView::constructTree(), VectorLSGenerator::createVectorLSU(), OSEdBuildAllCmd::Do(), ProGeTools::generateableDAGOperations(), Automagic::generateableDAGOperations(), OperationContainer::isEffective(), OSEdBuildAllCmd::isEnabled(), OperationContainer::module(), OSEdInfoView::moduleView(), OperationContainer::operationExists(), OpsetDialog::TransferDataToWindow(), OperationPropertyDialog::updateAffected(), and writeCustomOpMacros().

moduleCount() [2/2]

int OperationIndex::moduleCount

(

const std::string &

path

)

const

Returns the number of modules in a path.

Parameters

path	The path of the modules.

Returns

The number of modules in a path.

Exceptions

PathNotFound

If path is not found.

Definition at line 175 of file OperationIndex.cc.

                                                       {
    ModuleTable::const_iterator it = 
        modulesInPath_.find(path);
    if (it == modulesInPath_.end()) {
        string msg = "Path for the modules not found.";
        throw PathNotFound(__FILE__, __LINE__, __func__, msg, path);
    }
    return (*it).second.size();
}

References __func__, modulesInPath_, and path().

Here is the call graph for this function:

moduleOf() [1/2]

OperationModule & OperationIndex::moduleOf

(

const std::string &

name

)

Returns the module in which a given operation is defined.

If operation module is not found, a null operation module is returned.

Parameters

name	The name of the operation.

Returns

The OperationModule in which operation is defined.

Definition at line 315 of file OperationIndex.cc.

                                              {
    
    // let's iterate through every module to search an operation
    for (unsigned int i = 0; i < paths_.size(); i++) {
        OperationModule& module = moduleOf(paths_[i], name);
        if (&module != &NullOperationModule::instance()) {
            return module;
        }
    }
    return NullOperationModule::instance();
}

References NullOperationModule::instance(), module(), and paths_.

Referenced by effectiveOperation().

Here is the call graph for this function:

moduleOf() [2/2]

OperationModule & OperationIndex::moduleOf ( const std::string &  path, const std::string &  operName  )

private

Searches for a module in which a given operation is defined all in a given path.

If no module is found, NullOperationModule is returned.

Parameters

path	The name of the path.
operName	The name of the operation.

Returns

The module in which operation is defined or NullOperationModule.

Definition at line 403 of file OperationIndex.cc.

                               {
 
    ModuleTable::const_iterator mt = modulesInPath_.find(path);
    if (mt == modulesInPath_.end()) {
        return NullOperationModule::instance();
    }
    
    vector<OperationModule*> mods = (*mt).second;
    
    // let's iterate through all modules in this path
    for (unsigned int j = 0; j < mods.size(); j++) {
 
        if (brokenModules_.count(mods[j]))
            continue;
        DefinitionTable::const_iterator dt = 
            opDefinitions_.find(mods[j]->propertiesModule());
        if (dt == opDefinitions_.end()) {
        
            // operations for this module are not yet read from XML file
            // let's read them now
            try {
                readOperations(*mods[j]);
                dt = opDefinitions_.find(mods[j]->propertiesModule());
            } catch (const SerializerException& s) {
                brokenModules_.insert(mods[j]);
                // error occurred in reading, let's keep searching
                continue;
            }
        }
        
        // let's go through all operations and try to find a specific 
        // one
        ObjectState* op = (*dt).second;
        for (int i = 0; i < op->childCount(); i++) {    
            ObjectState* child = op->child(i);
            TCEString childName = child->stringAttribute(Operation::OPRN_NAME);
            if (childName.ciEqual(operName)) {
                return *(mods[j]);
            }
        }
    }
    return NullOperationModule::instance();
}

References brokenModules_, ObjectState::child(), ObjectState::childCount(), TCEString::ciEqual(), NullOperationModule::instance(), modulesInPath_, opDefinitions_, Operation::OPRN_NAME, path(), readOperations(), and ObjectState::stringAttribute().

Here is the call graph for this function:

operationCount()

int OperationIndex::operationCount

(

const OperationModule &

om

)

Returns the number of operations in a particular module.

Parameters

om	The OperationModule.

Returns

The number of operations in a module.

Exceptions

BadOperationModule

When module is invalid.

Definition at line 363 of file OperationIndex.cc.

                                                        {
    DefinitionTable::iterator it = opDefinitions_.find(om.propertiesModule());
    if (it == opDefinitions_.end()) {
        try {
            readOperations(om);
            it = opDefinitions_.find(om.propertiesModule());
        } catch (const SerializerException& s) {
            brokenModules_.insert(&om);
            string msg = "Error when reading module: " + s.errorMessage();
            throw BadOperationModule(__FILE__, __LINE__, __func__, msg);
        }
    }
    ObjectState* op = (*it).second;
    return op->childCount();
}

References __func__, brokenModules_, ObjectState::childCount(), Exception::errorMessage(), opDefinitions_, OperationModule::propertiesModule(), and readOperations().

Referenced by OSEdTreeView::constructTree(), VectorLSGenerator::createVectorLSU(), OSEdAddOperationCmd::Do(), ProGeTools::generateableDAGOperations(), Automagic::generateableDAGOperations(), OperationContainer::isEffective(), OperationContainer::operationExists(), OSEdInfoView::operationView(), OpsetDialog::TransferDataToWindow(), OperationPropertyDialog::updateAffected(), and writeCustomOpMacros().

Here is the call graph for this function:

operationName()

string OperationIndex::operationName	(	int	i,
		const OperationModule &	om
	)

Returns the name of the operation by the given index in a given module.

Parameters

i	The index of the operation.
om	The OperationModule.

Returns

The name of the operation by the given index in a given module.

Exceptions

OutOfRange	If index i is out of range.
BadOperationModule	When module is invalid.

Definition at line 337 of file OperationIndex.cc.

                                                              {
    DefinitionTable::iterator it = opDefinitions_.find(om.propertiesModule());
    if (it == opDefinitions_.end()) {
        try {
            readOperations(om);
            it = opDefinitions_.find(om.propertiesModule());
        } catch (const SerializerException& s) {
            brokenModules_.insert(&om);
            string msg = "Error when reading module: " + s.errorMessage();
            throw BadOperationModule(__FILE__, __LINE__, __func__, msg);
        }
    }
    
    ObjectState* op = (*it).second;
    ObjectState* child = op->child(i);
    return child->stringAttribute(Operation::OPRN_NAME);
}

References __func__, brokenModules_, ObjectState::child(), Exception::errorMessage(), opDefinitions_, Operation::OPRN_NAME, OperationModule::propertiesModule(), readOperations(), and ObjectState::stringAttribute().

Referenced by OSEdTreeView::constructTree(), VectorLSGenerator::createVectorLSU(), OSEdAddOperationCmd::Do(), ProGeTools::generateableDAGOperations(), Automagic::generateableDAGOperations(), OperationContainer::isEffective(), OperationContainer::operationExists(), OSEdInfoView::operationView(), OpsetDialog::TransferDataToWindow(), OperationPropertyDialog::updateAffected(), and writeCustomOpMacros().

Here is the call graph for this function:

operator=()

OperationIndex & OperationIndex::operator= ( const OperationIndex &  )

private

Assignment not allowed.

path()

std::string OperationIndex::path

(

int

i

)

const

Referenced by addModule(), addPath(), OSEdBuildAllCmd::Do(), OperationContainer::isEffective(), module(), moduleCount(), moduleOf(), refreshModule(), removeModule(), and OperationPropertyDialog::updateAffected().

pathCount()

int OperationIndex::pathCount

(

)

const

Referenced by OSEdBuildAllCmd::Do(), OperationContainer::isEffective(), and OperationPropertyDialog::updateAffected().

readOperations()

void OperationIndex::readOperations ( const OperationModule &  module )

private

Read all operation definitions of a module.

Parameters

module

The operation module to be read operations from.

Exceptions

SerializerException

If reading fails.

Definition at line 386 of file OperationIndex.cc.

                                                            {
    serializer_.setSourceFile(module.propertiesModule());
    ObjectState* tree = serializer_.readState();
    opDefinitions_[module.propertiesModule()] = tree;
}

References module(), opDefinitions_, OperationModule::propertiesModule(), OperationSerializer::readState(), serializer_, and OperationSerializer::setSourceFile().

Referenced by moduleOf(), operationCount(), and operationName().

Here is the call graph for this function:

refreshModule()

void OperationIndex::refreshModule	(	const std::string &	path,
		const std::string &	modName
	)

Refreshes module (usually when new operation is added to it).

Refreshing is done by erasing the ObjectState tree of the module. That way it has to be read again.

Parameters

path	The name of the path.
modName	The name of the module.

Exceptions

PathNotFound

If path is not found.

Definition at line 272 of file OperationIndex.cc.

                                                     {
    ModuleTable::iterator modIter = modulesInPath_.find(path);
    if (modIter == modulesInPath_.end()) {
        string msg = "Path for the module not found.";
        throw PathNotFound(__FILE__, __LINE__, __func__, msg, path);
    }
 
    vector<OperationModule*>::iterator iter = (*modIter).second.begin();
    OperationModule* module = NULL;
    while (iter != (*modIter).second.end()) {
        if ((*iter)->name() == modName) {
            module = (*iter);
            break;
        }
        iter++;
    }
 
    if (module == NULL) {
    throw InstanceNotFound(
        __FILE__, __LINE__, __func__, 
        "Operation module " + path + ":" + modName + " not found.");
    }
 
    DefinitionTable::iterator it = 
        opDefinitions_.find(module->propertiesModule());
    if (it == opDefinitions_.end()) {
        return;
    } else {
        delete (*it).second;
        opDefinitions_.erase(it);
    }
}

References __func__, module(), modulesInPath_, opDefinitions_, path(), and OperationModule::propertiesModule().

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

Here is the call graph for this function:

removeModule()

void OperationIndex::removeModule	(	const std::string &	path,
		const std::string &	modName
	)

Removes the module in a given path.

Parameters

path	The name of the path.
modName	The name of the module.

Exceptions

PathNotFound

If path is not found.

Definition at line 212 of file OperationIndex.cc.

                                                     {
    ModuleTable::iterator iter = modulesInPath_.find(path);
    if (iter == modulesInPath_.end()) {
        string msg = "Paths of the module not found.";
        throw PathNotFound(__FILE__, __LINE__, __func__, msg, path);
    }
    
    OperationModule* toBeErased = NULL;
    
    vector<OperationModule*>::iterator modIter = (*iter).second.begin();
    while (modIter != (*iter).second.end()) {
        if ((*modIter)->name() == modName) {
            toBeErased = *modIter;
            (*iter).second.erase(modIter);
            break;
        }
        modIter++;
    }
 
    if (toBeErased == NULL) {
    throw InstanceNotFound(
        __FILE__, __LINE__, __func__, 
        "Operation module " + path + ":" + modName + " not found.");
    }
 
    modIter = modules_.begin();
    while (modIter != modules_.end()) {
        if (*modIter == toBeErased) {
            modules_.erase(modIter);
            break;
        }
        modIter++;
    }
    
    // erase module from DefinitionTable
    DefinitionTable::iterator dIter = opDefinitions_.begin();
    while (dIter != opDefinitions_.end()) {
        if ((*dIter).first == toBeErased->propertiesModule()) {
            opDefinitions_.erase(dIter);
            delete (*dIter).second;
            break;
        }
        dIter++;
    }
 
    delete toBeErased;
}

References __func__, modules_, modulesInPath_, opDefinitions_, path(), and OperationModule::propertiesModule().

Referenced by OSEdRemoveModuleCmd::Do().

Here is the call graph for this function:

Member Data Documentation

brokenModules_

std::set<const OperationModule*> OperationIndex::brokenModules_

private

Definition at line 117 of file OperationIndex.hh.

Referenced by moduleOf(), operationCount(), and operationName().

loader_

OperationBehaviorLoader OperationIndex::loader_

private

Definition at line 115 of file OperationIndex.hh.

Referenced by effectiveOperation().

modules_

std::vector<OperationModule*> OperationIndex::modules_

private

Container holding all modules.

Definition at line 112 of file OperationIndex.hh.

Referenced by addModule(), addPath(), removeModule(), and ~OperationIndex().

modulesInPath_

ModuleTable OperationIndex::modulesInPath_

private

Contains all operation modules found in a search path organized by path names.

Definition at line 107 of file OperationIndex.hh.

Referenced by addModule(), addPath(), module(), moduleCount(), moduleOf(), refreshModule(), and removeModule().

opDefinitions_

DefinitionTable OperationIndex::opDefinitions_

private

Contains all operation definitions defined in available operation modules indexed by module names.

Definition at line 110 of file OperationIndex.hh.

Referenced by effectiveOperation(), moduleOf(), operationCount(), operationName(), readOperations(), refreshModule(), removeModule(), and ~OperationIndex().

paths_

std::vector<std::string> OperationIndex::paths_

private

List of paths searched for the operation modules.

Definition at line 104 of file OperationIndex.hh.

Referenced by addPath(), and moduleOf().

PROPERTY_FILE_EXTENSION

const string OperationIndex::PROPERTY_FILE_EXTENSION = ".opp"

static

Definition at line 61 of file OperationIndex.hh.

Referenced by addPath().

proxies_

std::vector<OperationBehaviorProxy*> OperationIndex::proxies_

private

Definition at line 116 of file OperationIndex.hh.

Referenced by effectiveOperation(), and ~OperationIndex().

serializer_

OperationSerializer OperationIndex::serializer_

private

Reads the operation property definitions.

Definition at line 114 of file OperationIndex.hh.

Referenced by readOperations().

---

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

• OperationIndex.hh
• OperationIndex.cc