algorithm_definition.cpp

Go to the documentation of this file.

//--------------------------------------------------
//---------------------------------------------------

#include "algorithm_definition.h"

namespace imedgine 
{
  //---------------------------------------------------
  
  AlgorithmDefinition::AlgorithmDefinition()
  {
  }

  //---------------------------------------------------
  
  AlgorithmDefinition::~AlgorithmDefinition()
  {
  }
  
  //---------------------------------------------------
  
  void AlgorithmDefinition::setName(std::string name)
  {
    name_ = name;
  }
  
  //---------------------------------------------------
  
  void AlgorithmDefinition::setClassification(std::string classification)
  {
    classification_ = classification; 
  }
  
  //---------------------------------------------------
  
  void AlgorithmDefinition::setLibraryName(std::string library_name)
  {
    library_name_ = library_name;
  }
  
  //---------------------------------------------------
  
  std::string AlgorithmDefinition::getName()
  {
    return name_;
  }
  
  //---------------------------------------------------
  
  std::string AlgorithmDefinition::getClassification()
  {
    return classification_;
  }
  
  //---------------------------------------------------
  
  std::string AlgorithmDefinition::getLibraryName()
  {
    return library_name_;
  }
  
  //---------------------------------------------------
  
  void AlgorithmDefinition::setDatasetCombinations(AlgorithmDefinition::combinations_definition_list_type combinations)
  {
    dataset_combinations_ = combinations;
  }
  
  //---------------------------------------------------
  
  AlgorithmDefinition::combinations_definition_list_type AlgorithmDefinition::getDatasetCombinations()
  {
    return dataset_combinations_;
  }
 
  //---------------------------------------------------
  
  AlgorithmDefinition::accepted_datasets_type
    AlgorithmDefinition::getPossibleCombinations(std::string name, AlgorithmDefinition::already_set_datasets_type already_set_datasets)
  {
    accepted_datasets_type possible_dataset_types;
    //iterate over list of combinations
    for (combinations_definition_list_type::const_iterator iter = dataset_combinations_.begin();iter != dataset_combinations_.end();++iter)
    {
      //the acccepted datasets for this combination
      accepted_datasets_collection_type accepted_datasets = *iter;
      bool do_remove = false;
      for(already_set_datasets_type::const_iterator ds_iter=already_set_datasets.begin();ds_iter != already_set_datasets.end();++ds_iter)
      {
        std::string dataset_name = ds_iter->first;
        dataset_type dataset_type = ds_iter->second;
        accepted_datasets_collection_type::const_iterator accepted_datasets_iterator = accepted_datasets.find(dataset_name);
        if (accepted_datasets_iterator != accepted_datasets.end())
        {
          accepted_datasets_type accepted = accepted_datasets_iterator->second;
          //not found in combination
          if (accepted.find(dataset_type) == accepted.end())
          {
            do_remove = true;
          }
        }
      }

      //only if the dataset shan't be removed
      if (!do_remove)
      {
        accepted_datasets_collection_type::const_iterator datasets_iterator = accepted_datasets.find(name);
        if (datasets_iterator != accepted_datasets.end())
        {
          accepted_datasets_type datasets = datasets_iterator->second;
          possible_dataset_types.insert(datasets.begin(),datasets.end());
        }
      }
    }
    return possible_dataset_types;
  }
  
  //---------------------------------------------------
  
  std::string AlgorithmDefinition::toString()
  {
    std::stringstream output;
    output << "name: " << name_ << std::endl;
    output << "classification: " << classification_ << std::endl;
    output << "library name: " << library_name_ << std::endl;
    return output.str();
  }
  
  //---------------------------------------------------

  void AlgorithmDefinition::addOutputDataset(AlgorithmDefinition::dataset_definition_pointer_type dataset)
  {
    output_datasets_.insert(std::make_pair(dataset->getName(), dataset));
  }
  
  //---------------------------------------------------
  
  void AlgorithmDefinition::addInputDataset(AlgorithmDefinition::dataset_definition_pointer_type dataset)
  {
    input_datasets_.insert(std::make_pair(dataset->getName(), dataset));
  } 
  
  //---------------------------------------------------

  AlgorithmDefinition::dataset_definition_pointer_type AlgorithmDefinition::getInputDataset(std::string name)
  {
    dataset_definition_collection_type::const_iterator iter = input_datasets_.find(name);
    if (iter != input_datasets_.end())
    {
      return iter->second;
    }
    else
    {
      //TODO throw exception
      return dataset_definition_pointer_type();
    }
  }
  
  //---------------------------------------------------

  AlgorithmDefinition::dataset_definition_collection_type AlgorithmDefinition::getInputDatasets()
  {
    return input_datasets_;
  }
  
  //---------------------------------------------------
  
  AlgorithmDefinition::dataset_definition_collection_type AlgorithmDefinition::getOutputDatasets()
  {
    return output_datasets_;
  }

  //---------------------------------------------------
  
  void AlgorithmDefinition::setOutputDatasetIds(config_dataset_id_to_output_map_type &dataset_id_map)
  {
    for(dataset_definition_collection_type::const_iterator output_ds_def_iterator=output_datasets_.begin();
        output_ds_def_iterator!=output_datasets_.end();
        ++output_ds_def_iterator)
    {
      dataset_definition_pointer_type output_ds_def = output_ds_def_iterator->second;
      dataset_id_map.insert(std::make_pair(output_ds_def->getName(), output_ds_def->getType()));
    }
  }
}

---