ResourceDescription.cxx

Go to the documentation of this file.

/***************************************************************************************
*   Programmer: Gary E. Christensen
*   Date: 6/24/2010
*   Name: ResourceDescription
*   Purpose: This class holds information about the resources stored in the database.
*      Each resource must contain a unique resource id and a list of data descriptions
*      that describe the data (images, object maps, contours, landmarks, etc.) associated
*      with the resource.  Optionally, a resource can contain a list of non-required user
*      defined attributes such as age, race, handeness, etc.
******************************************************************************************/
#include "ResourceDescription.h"

void ResourceDescription::Clear(){
  m_label.clear();
  m_dmid.clear();
  ClearCSList();

  ClearAlgorithms();
  m_format.clear();

  ClearFilenames();
  m_transform_units.clear();
  m_datatype.clear();

  ClearAttributes(); 
};

TiXmlElement * ResourceDescription::CreateDOM(const std::string & tag){

        // descrip is the main element to hold the DOM tree for this object
        TiXmlElement * descrip = new TiXmlElement( tag.c_str() );

  if (descrip){
    // Only save description label if there is one
    if (!m_label.empty()){
      descrip->SetAttribute("label", m_label.c_str());
    }
    // Only save dmid if there is one
    if (!m_dmid.empty()){
      descrip->SetAttribute("dmid", m_dmid.c_str());
    }
  } else {
    return NULL; // Failed to allocate memory
  }

  // Add coordinate system descriptions to resource descrip
  if (!m_cs.empty()){
    CSList::iterator cs_iter;
    for (cs_iter=m_cs.begin(); cs_iter != m_cs.end(); cs_iter++) {
      const std::string & key= cs_iter->first;
      const CoordinateSystem value= cs_iter->second;

      TiXmlElement * cs_tag = new TiXmlElement( "coordinate_system" );

      if (cs_tag){
        // Only save index if there is one
        if (!value.index.empty()){
          cs_tag->SetAttribute("index", value.index.c_str());
        }
        // Only save namespace if there is one
        if (!value.ns.empty()){
          cs_tag->SetAttribute("ns", value.ns.c_str());
        }
        // Coordinate system id is required
        if (!value.id.empty()){
          cs_tag->SetAttribute("id", value.id.c_str());
        } else {
          return NULL; // Coordinate system id is missing
        }

        // Add coordinate system to description
        descrip->LinkEndChild(cs_tag);
      } else {
        return NULL; // Faild to allocate memory
      }
    }
  }

  // Add algorithm descriptions to resource descrip
  if (!m_alg.empty()){
    AlgList::iterator alg_iter;
    for (alg_iter=m_alg.begin(); alg_iter != m_alg.end(); alg_iter++) {
      const std::string & key= alg_iter->first;
      const std::string & value= alg_iter->second;

      TiXmlElement * alg_tag = new TiXmlElement( "algorithm" );
      TiXmlText * algorithm = new TiXmlText(value.c_str());

      if (alg_tag && algorithm){
        // Only save index if there is one
        if (!key.empty()){
          alg_tag->SetAttribute("index", key.c_str());
        }
        // Set algorithm
        alg_tag->LinkEndChild(algorithm);

        // Add algorithm to description
        descrip->LinkEndChild(alg_tag);
      } else {
        return NULL; // Faild to allocate memory
      }
    }
  }

  // Add transform format to descrip if present
  if (!m_format.empty()){
    TiXmlElement * format_tag = new TiXmlElement( "format" );
    TiXmlText * format = new TiXmlText( m_format );
    if (format_tag && format){
      format_tag->LinkEndChild(format);
      descrip->LinkEndChild(format_tag);
    } else {
      return NULL; // Failed to allocate memory
    }
  }

  // Add filename descriptions to resource descrip
        FilenameList::iterator fn_iter;
        for (fn_iter=m_filename.begin(); fn_iter != m_filename.end(); fn_iter++) {
    const std::string & key= fn_iter->first;
                const std::string & value= fn_iter->second;
                
    TiXmlElement * fn_tag = new TiXmlElement( "filename" );
    TiXmlText * filename = new TiXmlText(value.c_str());

    if (fn_tag && filename){
      // Only save index if there is one
      if (!key.empty()){
        fn_tag->SetAttribute("index", key.c_str());
      }

      // Set filename
      fn_tag->LinkEndChild(filename);

      // Add filename to description
      descrip->LinkEndChild(fn_tag);
    } else {
      return NULL; // Faild to allocate memory
    }
        }

  // Add transform units to descrip if present
  if (!m_transform_units.empty()){
    TiXmlElement * tu_tag = new TiXmlElement( "transformation_units" );
    TiXmlText * transform_units = new TiXmlText( m_transform_units );
    if (tu_tag && transform_units){
      tu_tag->LinkEndChild(transform_units);
      descrip->LinkEndChild(tu_tag);
    } else {
      return NULL; // Failed to allocate memory
    }
  }

  // Add data type to descrip if present
  if (!m_datatype.empty()){
    TiXmlElement * dt_tag = new TiXmlElement( "datatype" );
    TiXmlText * datatype = new TiXmlText( m_datatype );
    if (dt_tag && datatype){
      dt_tag->LinkEndChild(datatype);
      descrip->LinkEndChild(dt_tag);
    } else {
      return NULL; // Failed to allocate memory
    }
  }


  // Add non-required attributes to descrip
        // Cycle through all the attributes and store them in DOM
  if (!m_attribute.empty()){
    TiXmlElement * attributes = new TiXmlElement( "attributes" );
    descrip->LinkEndChild( attributes );

    AttributeList::iterator a_iter;
    for (a_iter=m_attribute.begin(); a_iter != m_attribute.end(); a_iter++) {
      const std::string & key= a_iter->first;
      const std::string & value= a_iter->second;

      TiXmlElement * p_attribute = new TiXmlElement(key.c_str()); 
      TiXmlText * p_text = new TiXmlText(value.c_str());

      if (p_attribute && p_text){
        p_attribute->LinkEndChild( p_text );  
        attributes->LinkEndChild( p_attribute );
      } else {
        return NULL; // Failed to allocate memory
      }
    }
  }

        return descrip;
}

bool ResourceDescription::FillUsingDom(TiXmlElement * descrip){
  // Return false if called with NULL pointer
        if (!descrip){
                return false;
        }

  std::string buf;
  int readOkay;
 
  // set label if there is one
  readOkay = descrip->QueryStringAttribute("label", &buf);
  if (readOkay == TIXML_SUCCESS){
    SetLabel(buf);
  }

  //set dmid if there is one
  readOkay = descrip->QueryStringAttribute("dmid", &buf);
  if (readOkay == TIXML_SUCCESS){
    SetDMID(buf);
  }

        // pElem used to move through children of descrip 
        TiXmlElement* pElem; 
        TiXmlHandle hRoot(descrip);

  //Go to first attribute child of description and set attributes
        //Use hRoot to ensure that pElem is set to NULL if database_attributes is missing
        pElem=hRoot.FirstChildElement().Element();
        for( pElem; pElem; pElem=pElem->NextSiblingElement()) {
                const std::string pKey = std::string(pElem->Value());
                

    // Create and fill a coordinate system list entry
    if (pKey.compare("coordinate_system") == 0){
      CoordinateSystem cs;// = new CoordinateSystem;
      //if (cs){
        readOkay = pElem->QueryStringAttribute("index", &buf);
        if (readOkay == TIXML_SUCCESS){
          cs.index = buf;
        } else {
          // Use index "0" if index is missing
          cs.index = "0";
        }
        readOkay = pElem->QueryStringAttribute("ns", &buf);
        if (readOkay == TIXML_SUCCESS){
          cs.ns = buf;
        }
        readOkay = pElem->QueryStringAttribute("id", &buf);
        if (readOkay == TIXML_SUCCESS){
          cs.id = buf;
          // Add coordinate system to list using index as key
          // Note, must set the index, ns, and id values of cs before adding
          AddCS(cs.index,cs);
        } else {
          return false; // Missing coordinate system id
        }
      //} else {
      //  return false; // Failed to allocate memory
      //}
    }

    // Add and fill an algorithm list entry
    if (pKey.compare("algorithm") == 0){
      const std::string pText = std::string(pElem->GetText());
      readOkay = pElem->QueryStringAttribute("index", &buf);
      if (readOkay == TIXML_SUCCESS){
        // Add algorithm to list at given index
        AddAlgorithm(buf,pText);
      } else {
        // Assume index is "0" if missing
        AddAlgorithm("0",pText);
      }
    }

    // Set format
    if (pKey.compare("format") == 0){
      const std::string pText = std::string(pElem->GetText());
      SetFormat(pText);
    }

    // Add and fill an filename list entry
    if (pKey.compare("filename") == 0){
      readOkay = pElem->QueryStringAttribute("index", &buf);
      const std::string pText = std::string(pElem->GetText());
      if (readOkay == TIXML_SUCCESS){
        // Add algorithm to list at given index
        AddFilename(buf,pText);
      } else {
        // Assume index is "0" if missing
        AddFilename("0",pText);
      }
    }

    // Set transformation units
    if (pKey.compare("transformation_units") == 0){
      const std::string pText = std::string(pElem->GetText());
      SetTransformUnits(pText);
    }

    // Set data type
    if (pKey.compare("datatype") == 0){
      const std::string pText = std::string(pElem->GetText());
      SetDataType(pText);
    }
  }

  // Go to first attribute child of description and set attributes
  // Using hDescrip ensures that pElem is NULL if resource_attributes tag is missing
  pElem=hRoot.FirstChildElement("attributes").FirstChildElement().Element();
  for( pElem; pElem; pElem=pElem->NextSiblingElement()) {
    const char *pKey=pElem->Value();
    const char *pText=pElem->GetText();
    if (pKey && pText) {
      AddAttribute(pKey,pText);
    }
  }

  return true;
}