NIREPResourceDatabase.cxx

Go to the documentation of this file.

#include "NIREPResourceDatabase.h"

vtkStandardNewMacro(NIREPResourceDatabase);

NIREPResourceDatabase::NIREPResourceDatabase(void)
{
  cron = 0;

  //tags
  tag.push_back(UpToLow(std::string("database")));
  tag.push_back(UpToLow(std::string("subject")));


  //define available types
  typelist.push_back(UpToLow(std::string("spatialdata")));
  //typelist.push_back(UpToLow(std::string("image")));
  //typelist.push_back(UpToLow(std::string("objMap")));
  //typelist.push_back(UpToLow(std::string("contour")));
  //typelist.push_back(UpToLow(std::string("landmark")));
  //typelist.push_back(UpToLow(std::string("surface")));
}


NIREPResourceDatabase::~NIREPResourceDatabase(void)
{
  /* Nothing to do! */
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
void NIREPResourceDatabase::StartElement(const char* name, const char** atts)
{
  if(!history.empty()) {
    if(cron == 0) return;
    this->previous = this->history[cron-1];

    // NOT SURE IF I UNDERSTAND THIS LINE - Paul //
    previous = (previous);
  }
  //dbresource, level 1
  if(!tag[0].compare(UpToLow(name))) {
    Resource item;
    this->resource.push_back(item);
    int i = 0;
    while(atts[i]) {
      this->resource.end()[-1].attribute[std::string(atts[i])] =
                                                       std::string(atts[i+1]);
      i = i + 2;
    }
  }
  //dataset, level 2
  if(!tag[0].compare(previous) && !tag[1].compare(name)) {
    Dataset item;
    this->resource.end()[-1].dataset.push_back(item);
    int i = 0;
    while(atts[i]) {
      this->resource.end()[-1].dataset.end()[-1].attribute[
                               std::string(atts[i])] = std::string(atts[i+1]);
      i = i + 2;
    }
  }
  //defined type, level 3
  if(!tag[1].compare(previous) && IsDefinedType(name)) {
    if(this->resource.empty()) return;
    std::map<std::string, std::string> item;
    this->resource.end()[-1].dataset.end()[-1].entry.push_back(item);
    int i = 0;
    while(atts[i]) {
      std::map<std::string, std::string>* iter =
                  &this->resource.end()[-1].dataset.end()[-1].entry.end()[-1];
      (*iter)[atts[i]] = std::string(atts[i+1]);
      i = i + 2;
    }
    std::map<std::string, std::string>* iter =
                  &this->resource.end()[-1].dataset.end()[-1].entry.end()[-1];
    (*iter)["content::type"] = name;
  }

  this->current = std::string(UpToLow(name));
  this->history.push_back(std::string(UpToLow(name)));
  this->cron++;
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
void NIREPResourceDatabase::EndElement(const char* name)
{
  if(this->history.empty()) return;
  this->history.pop_back();
  this->cron--;
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
void NIREPResourceDatabase::CharacterDataHandler(const char* data, int length)
{
  if(length <= 1) return;
  if(this->current.empty()) return;
  if(data == NULL) return;
  if(!this->DataIntegrityChecker(data)) return;
  if(this->resource.empty()) return;

  if(!tag[0].compare(previous) && tag[1].compare(current)) {
    this->resource.end()[-1].attribute[current] = std::string(data, length);
  }
  if(!tag[1].compare(previous) && !IsDefinedType(current)) {
    this->resource.end()[-1].dataset.end()[-1].attribute[current] =
                                                    std::string(data, length);
  }

  if(IsDefinedType(previous)) {
    std::map<std::string, std::string>* iter =
                  &this->resource.end()[-1].dataset.end()[-1].entry.end()[-1];
    (*iter)[current] = std::string(data, length);
  }
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
bool NIREPResourceDatabase::IsDefinedType(std::string type)
{
  for(unsigned int i=0; i<typelist.size(); i++) {
    if(!typelist[i].compare(UpToLow(type))) {
      return true;
    }
  }
  return false;
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
std::string NIREPResourceDatabase::ParseThisString(std::string str,
                                       const char* delimiter, short partition)
{
  size_t loc = str.find(delimiter);
  std::string ret;
  
  switch(partition) {
    case LEFT:
      ret = str.substr(0, loc);
      break;
    case RIGHT:
      ret = str.substr(loc+1);
      break;
    default:
      ret = std::string("error");
      break;
  }
  return ret;
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
std::string NIREPResourceDatabase::QueryFilename(std::string str)
{
  std::string ret = std::string("empty");

  std::string lstr = ParseThisString(str, ":", LEFT);
  std::string rstr = ParseThisString(str, ":", RIGHT);
  std::string mstr = ParseThisString(rstr, "-", LEFT);
  rstr = ParseThisString(rstr, "-", RIGHT);

  bool empty = false;

  Resource res = SearchResource(lstr, empty);
  if(empty) return ret;
  Dataset ds = SearchDataset(rstr, res, empty);
  if(empty) return ret;
  std::map<std::string, std::string> em = SearchEntry(mstr, ds, empty);
  if(empty) return ret;

  return em["filename"];
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
std::map<std::string,std::string> NIREPResourceDatabase::QueryList(
                                                              std::string str)
{
  std::map<std::string,std::string> ret;
  ret[std::string("empty")] = std::string("empty");

  std::string lstr = ParseThisString(str, ":", LEFT);
  std::string rstr = ParseThisString(str, ":", RIGHT);
  std::string mstr = ParseThisString(rstr, "-", LEFT);
  rstr = ParseThisString(rstr, "-", RIGHT);

  bool empty = false;

  Resource res = SearchResource(lstr, empty);
  if(empty) return ret;
  ret = res.attribute;
  Dataset ds = SearchDataset(rstr, res, empty);
  if(empty) return ret;
  ret = ds.attribute;
  std::map<std::string, std::string> em = SearchEntry(mstr, ds, empty);
  if(empty) return ret;
  ret = em;
  
  return ret;
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
Resource& NIREPResourceDatabase::SearchResource(std::string str, bool& empty)
{
  for(unsigned int i=0; i<resource.size(); i++) {
    if(!resource[i].attribute["id"].compare(str)) {
      return resource[i];
    }
  }
  empty = true;
  return resource[0];
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
Dataset& NIREPResourceDatabase::SearchDataset(std::string str,
                                              Resource& resource, bool& empty)
{
  for(unsigned int i=0; i<resource.dataset.size(); i++) {
    if(!resource.dataset[i].attribute["id"].compare(str)) {
      return resource.dataset[i];
    }
  }
  empty = true;
  return resource.dataset[0];
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
std::map<std::string,std::string>& NIREPResourceDatabase::SearchEntry(
                               std::string str, Dataset& dataset, bool& empty)
{
  for(unsigned int i=0; i<dataset.entry.size(); i++) {
    std::map<std::string, std::string>* iter = &dataset.entry[i];
    if(!(*iter)["id"].compare(str)) {
      return dataset.entry[i];
    }
  }
  empty = true;
  return dataset.entry[0];
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
std::vector<std::string> NIREPResourceDatabase::GetTags()
{
  return this->tag;
}


//Programmer:
//Date:
//Function: 
//Copyright: University of Iowa
//Inputs:
//Outputs:
std::vector<std::string> NIREPResourceDatabase::GetTypeList()
{
  return this->typelist;
}