config_handler.cpp

Go to the documentation of this file.

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

#include "config_handler.h"
#include "../algorithms/algorithm_definition.h"
#include "../algorithms/dataset_definition.h"
#include <iostream>
#include <boost/lexical_cast.hpp>

namespace imedgine 
{ 
  //---------------------------------------------------

  ConfigHandler::ConfigHandler(AlgorithmConfig::algorithm_config_pointer_type algorithm_config)
    :algorithm_config_(algorithm_config),
     is_algorithm_(false), is_combinations_(false), is_combination_(false), is_input_(false), is_output_(false), is_dataset_(false),
     is_name_(false), is_classification_(false), is_library_(false), is_type_(false)
  {
  }

  //---------------------------------------------------
 
  ConfigHandler::~ConfigHandler() 
  {
  }

  //---------------------------------------------------
  //FIXME hack. Tobe, übernehmen Sie
  
  bool ConfigHandler::startElement(const QString &namespace_uri, const QString &local_name, const QString &qname, const QXmlAttributes &attrs)
  {
    if (local_name == "algorithms")
    {
      // removed parameter by Alexander Lex
    }
    else if (local_name == "algorithm")
    {
      current_definition_ = AlgorithmConfig::algorithm_definition_pointer_type(new AlgorithmDefinition);
      is_algorithm_ = true; 
    }
    else if (local_name == "combinations")
    {
      is_combinations_ = true;
    } 
    else if (local_name == "combination")
    {
      is_combination_ = true;
    } 
    else if (local_name == "input")
    {
      is_input_ = true;
    }
    else if (local_name == "output")
    {
      is_output_ = true;
    }
    //input dataset
    else if (local_name == "dataset" && is_input_)
    {
      current_dataset_ = AlgorithmDefinition::dataset_definition_pointer_type(new DatasetDefinition);
      if (attrs.count() == 0)
      {
        return false;
      }
      else
      {
        current_dataset_->setName(attrs.value("name").toStdString());
        bool in_place = true;
        if (attrs.value("inplace") == "false")
          in_place = false;
        current_dataset_->setInPlace(in_place);
      }

      is_dataset_ = true;
    }
    //output dataset
    else if (local_name == "dataset" && is_output_)
    {
      current_dataset_ = AlgorithmDefinition::dataset_definition_pointer_type(new DatasetDefinition);
      if (attrs.count() == 0)
      {
        return false;
      }
      else 
      {
        current_dataset_->setName(attrs.value("name").toStdString());
        std::string type = attrs.value("type").toStdString();
        std::string bytes = attrs.value("bytes").toStdString();

        dataset_type ds_type = getDatasetType(type, bytes);
        current_dataset_->setType(ds_type);
      }
    }
    //combination dataset
    else if (local_name == "dataset" && is_combination_)
    {
      if (attrs.count() == 0)
      {
        return false;
      }
      current_dataset_ = current_definition_->getInputDataset(attrs.value("name").toStdString());
      is_dataset_ = true; 
    }
    else if (local_name == "name")
    {
      is_name_ = true;
    }
    else if (local_name == "classification")
    {
      is_classification_ = true;
    }
    else if (local_name == "library")
    {
      is_library_ = true;
    }
    else if (local_name == "type")
    {
      if (attrs.count() == 0)
      {
        return false;
      }
      else
      {
        std::string type = attrs.value("type").toStdString();
        std::string bytes = attrs.value("bytes").toStdString();
        current_type_ = getDatasetType(type, bytes);
      }
      is_type_ = true;
    }
    return true;
  }

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

  bool ConfigHandler::endElement(const QString &namespace_uri, const QString &local_name, const QString &qname)
  {
    if (local_name == "algorithm")
    {
      algorithm_config_->addAlgorithmDefinition(current_definition_);
      is_algorithm_ = false; 
    }
    else if (local_name == "dataset" && is_combination_)
    {
      current_combination_.insert(std::make_pair(current_dataset_->getName(), accepted_datasets_));
      accepted_datasets_.clear();
      is_dataset_ = false;
    }
    else if (local_name == "combination")
    {
      combinations_.push_back(current_combination_);
      current_combination_.clear();
      is_combination_ = false;
    }
    else if (local_name == "combinations")
    {
      current_definition_->setDatasetCombinations(combinations_);
      combinations_.clear();
      is_combinations_ = false;
    } 
    else if (local_name == "input")
    {
      is_input_ = false;
    }
    else if (local_name == "output")
    {
      is_output_ = false;
    }
    else if (local_name == "dataset")
    {
      if (is_input_)
      {
        current_definition_->addInputDataset(current_dataset_); 
      }
      else if (is_output_)
      {
        current_definition_->addOutputDataset(current_dataset_); 
      }
      is_dataset_ = false;
    }
    else if (local_name == "name")
    {
      is_name_ = false;
    }
    else if (local_name == "classification")
    {
      is_classification_ = false;
    }
    else if (local_name == "library")
    {
      is_library_ = false;
    }
    else if (local_name == "type")
    {
      accepted_datasets_.insert(current_type_);
      is_type_ = false;
    }
    return true;
  }

  bool ConfigHandler::characters (const QString &characters) 
  {
    if (is_algorithm_ && is_name_)
    {
      current_definition_->setName(characters.toStdString());
    }
    else if (is_classification_)
    {
      current_definition_->setClassification(characters.toStdString());
    }
    else if (is_library_)
    {
      current_definition_->setLibraryName(characters.toStdString());
    }

    return true;
  }

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

  dataset_type ConfigHandler::getDatasetType(std::string type, std::string bytes)
  {
    dataset_type ds = ONE_BYTE_VOLUME_PIXEL_DATASET;
    if((type=="volume")&&(bytes=="1"))
    {
      ds = ONE_BYTE_VOLUME_PIXEL_DATASET; 
    } 
    else if((type=="volume")&&(bytes=="2"))
    {
      ds = TWO_BYTE_VOLUME_PIXEL_DATASET;
    }
    else if((type=="volume")&&(bytes=="4"))
    {
      ds = FOUR_BYTE_VOLUME_PIXEL_DATASET;
    }
    else if((type=="image")&&(bytes=="1"))
    {
      ds = ONE_BYTE_IMAGE_PIXEL_DATASET;
    }
    else if((type=="image")&&(bytes=="2"))
    {
      ds = TWO_BYTE_IMAGE_PIXEL_DATASET;
    }
    else if((type=="image")&&(bytes=="4"))
    {
      ds = TWO_BYTE_IMAGE_PIXEL_DATASET;
    }
    else if(type=="matrix")
    {
      ds = MATRIX_DATASET;
    }
    return ds;
  }

}

---