ResourceDescriptionList.cxx

Go to the documentation of this file.

/***************************************************************************************
*   Programmer: Gary E. Christensen
*   Date: 6/24/2010
*   Name: ResourceDescriptionList
*   Purpose: This class keeps a list of the data files available to be loaded into memory.
*      This class lists the data descriptions of images, object maps, landmark files, and 
*      contour files.  It does not list information about transformations. 
*      This class creates a map of DataDescription objects by parsing a data resource file.
*   Required XML Tags:
*       database - main tag of resource description list, must contian an id.
*   resource - one tag for each resource in database, each resource can contain
*                 multiple data descriptions, i.e., files
*   Optional XML Tags:
*      database_attributes - contains non-required user defined XML tags and values
******************************************************************************************/
#include "ResourceDescriptionList.h"
#include "BasicDescription.h"
#include "NIREPDefinitions.h"
#include <wx/log.h>

#include <iostream>
#include <fstream>

void ResourceDescriptionList::Clear(){
        m_filename.clear();
  m_namespace.clear();

  ClearNameSpaceDescrips();
  ClearCSDescrips();
        ClearAlgorithmDescrips();
  ClearDataDescrips();
  ClearTransformDescrips();  
  ClearRDLs();
  ClearLabelDescrips();
}

//JAH changed so that we now use a FILE pointer as the main
//function
bool ResourceDescriptionList::Save(const std::string & filename){
  FILE *tempFile = fopen(filename.c_str(),"w");
  bool returnValue = Save(tempFile);
  fclose(tempFile);

  return returnValue;
}


//JAH added
bool ResourceDescriptionList::Save(FILE * file){
        TiXmlDocument doc;  

        // Add XML declaration to resource description list
        TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "", "" );  
  if (decl){
          doc.LinkEndChild( decl ); 
  } else {
    wxString msg(wxT("Error: Failed to allocate memory for Tiny XML declaration tag."));
    msg += wxT("\nFile: ");
    //msg.Append(file->_tmpfname);
    wxLogError(msg);  // Show a dialog box with error message

    return false; // Failed to allocate memory
  }

        // Add the database tag to resource description list
        TiXmlElement * root = new TiXmlElement("ResourceDescriptionList"); 
  if (root){
          root->SetAttribute("namespace", m_namespace.c_str());
          doc.LinkEndChild( root );  
  } else {
    wxString msg(wxT("Error: Failed to allocate memory for Tiny XML ResourceDescriptionList tag."));
    msg += wxT("\nFile: ");
    //msg.Append(file->_tmpfname);
    wxLogError(msg);  // Show a dialog box with error message

    return false; // Failed to allocate memory
  }

  // Cycle through included filenames. The filenames are the keys to the m_RDL map.
  RDLList::iterator RDL_iter;
  for (RDL_iter=m_RDL.begin(); RDL_iter != m_RDL.end(); RDL_iter++) {
    const std::string & key= RDL_iter->first;

    TiXmlElement * includeRDL = new TiXmlElement( "includeRDL" );
    if (includeRDL != NULL){
      includeRDL->LinkEndChild( new TiXmlText(key.c_str()));
      root->LinkEndChild( includeRDL );
    }else{
      wxString msg(wxT("Error: Failed to allocate memory for Tiny XML includeRDL tag."));
      msg += wxT("\nFile: ");
      //msg.Append(file->_tmpfname);
      wxLogError(msg);  // Show a dialog box with error message

      return false; // Failed to allocate memory
    }
  }

  // Add namespace description to resource description list DOM
  if (!m_namespace_descrip.empty()){
    BasicList::iterator ns_iter;
    for (ns_iter=m_namespace_descrip.begin(); ns_iter != m_namespace_descrip.end(); ns_iter++) {
      BasicDescription * value= ns_iter->second;
      root->LinkEndChild(value->CreateDOM("namespace_description"));
    }
  }

  // Add algorithm description to resource description list DOM
  if (!m_algorithm_descrip.empty()){
    BasicList::iterator a_iter;
    for (a_iter=m_algorithm_descrip.begin(); a_iter != m_algorithm_descrip.end(); a_iter++) {
      BasicDescription * value= a_iter->second;
      root->LinkEndChild(value->CreateDOM("algorithm_description"));
    }
  }

  // Add label descriptions to resource description list DOM
  if (!m_label_descrip.empty()){
    std::string buf;
    BasicList::iterator label_iter;
    for (label_iter=m_label_descrip.begin(); label_iter != m_label_descrip.end(); label_iter++) {
      BasicDescription * value= label_iter->second;
      root->LinkEndChild(value->CreateDOM("label_description"));
    }
  }

  // Add coordinate system description to resource description list DOM
  if (!m_cs_descrip.empty()){
    std::string buf;
    BasicList::iterator cs_iter;
    for (cs_iter=m_cs_descrip.begin(); cs_iter != m_cs_descrip.end(); cs_iter++) {
      BasicDescription * value= cs_iter->second;
      TiXmlElement * cs_description = value->CreateDOM("cs_description");

      // If there was no namespace in description, set the namespace to the
      // file default namespace.
      buf.clear();
      int readOkay = cs_description->QueryStringAttribute("ns", &buf);
      if (!readOkay || buf.empty()){
        cs_description->SetAttribute("ns", m_namespace.c_str());
      }
      root->LinkEndChild(cs_description);
    }
  }

        // Add data description to resource description list DOM
  if (!m_data_descrip.empty()){
    ResourceList::iterator dd_iter;
    for (dd_iter=m_data_descrip.begin(); dd_iter != m_data_descrip.end(); dd_iter++) {
      ResourceDescription * value= dd_iter->second;
      root->LinkEndChild(value->CreateDOM("data_description"));
    }
  }

  // Add resources to resource description list
  if (!m_transform_descrip.empty()){
    ResourceList::iterator td_iter;
    for (td_iter=m_transform_descrip.begin(); td_iter != m_transform_descrip.end(); td_iter++) {
      ResourceDescription * value= td_iter->second;
      root->LinkEndChild(value->CreateDOM("transform_description"));
    }
  }

        bool saveOkay = doc.SaveFile(file);

  if (saveOkay){
          return true;
  } else {
    wxString msg(doc.ErrorDesc(), wxConvUTF8);  // Get the error message from the tiny xml document
    msg += wxT("\nFile: ");
    //msg.Append(file->_tmpfname);
    wxLogError(msg);  // Show a dialog box with error message

    return false; // Failed to save file
  }
}

bool ResourceDescriptionList::Load(const std::string & filename){
        // Open fileName, parse file, and construct spatial data resource list
        TiXmlDocument doc(filename.c_str());
        bool loadOkay = doc.LoadFile();

  if ( !loadOkay ) {
    wxString msg(doc.ErrorDesc(), wxConvUTF8);  // Get the error message from the tiny xml document
    msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
    wxLogError(msg);  // Show a dialog box with error message

    return false;
  }
   

        // Set the filename of this object to filename if successfully able to load and parse it.
        this->SetFilename(filename);

        TiXmlHandle hDoc(&doc);
        TiXmlElement* pElem;
        TiXmlHandle hRoot(NULL);

        pElem=hDoc.FirstChildElement().Element();
        // should always have a valid root but handle gracefully if it does
        if (!pElem){
    wxString msg(wxT("Error: no root tag"));
    msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
    wxLogError(msg);  // Show a dialog box with error message

                return false;
        }

  //Root should be ResourceDescriptionList and have a namespace
  if (pElem->ValueStr().compare("ResourceDescriptionList") == 0){
    if (pElem->QueryStringAttribute("namespace", &m_namespace)==TIXML_NO_ATTRIBUTE){
      wxString msg(wxT("Error: Missing default namespace (i.e., na=\"\") in ResourceDescriptionList tag."));
      msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
      wxLogError(msg);  // Show a dialog box with error message

      return false; // error: namespace missing
    }
  }else{
    wxString msg(wxT("Error: Missing ResourceDescriptionList tag."));
    msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
    wxLogError(msg);  // Show a dialog box with error message

    return false; // error: no ResourceDescriptionList tag in document
  }

        // save this for later
        hRoot=TiXmlHandle(pElem);

  // Get directory of current RDL file
  wxFileName dir(wxString(m_filename.c_str(), wxConvUTF8));
  wxString defaultDirectory = dir.GetPath();

        //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());
                

    if (pKey.compare("namespace_description") == 0){
      BasicDescription * bdescrip = new BasicDescription(pElem);
      if(bdescrip){
        // Use namespace as key for adding namespace description
        AddNameSpaceDescrip(bdescrip->GetID(), bdescrip); 
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for namespace description."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }

    if (pKey.compare("cs_description") == 0){
      BasicDescription * bdescrip = new BasicDescription(pElem,m_namespace);
      if(bdescrip){
        // Use coordinate system namespace & id as key for adding coordinate system description
        AddCSDescrip(bdescrip->CreateNSID(), bdescrip);
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for coordinate system description."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }
    
    if (pKey.compare("algorithm_description") == 0){
      BasicDescription * bdescrip = new BasicDescription(pElem);
      if(bdescrip){
        // Use algorithm id as key for adding aglorithm description
        AddAlgorithmDescrip(bdescrip->GetID(), bdescrip);
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for algorithm description."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }
   
    if (pKey.compare("label_description") == 0){
      BasicDescription * bdescrip = new BasicDescription(pElem);
      if(bdescrip){
        // Use label id as key for adding label description
        AddLabelDescrip(bdescrip->GetID(), bdescrip);
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for label description."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }

    if (pKey.compare("data_description") == 0){
      ResourceDescription * rdescrip = new ResourceDescription(pElem,m_namespace);
      if(rdescrip){
        // Use dmid as key to add data description
        if (rdescrip->GetDMID().empty()){
          std::string dmid = rdescrip->CreateLabelDMID();
          if (dmid.empty()){
            wxString msg(wxT("Error: Failed to create data manager id."));
            msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
            wxLogError(msg);  // Show a dialog box with error message

            return false; // Failed to create dmid
          }
          rdescrip->SetDMID( dmid );
        }
        // Set default directory for data description
        rdescrip->SetDirectory( std::string(defaultDirectory.mb_str()) );
        AddDataDescrip(rdescrip->GetDMID(), rdescrip);
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for data description."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }

    if (pKey.compare("transform_description") == 0){
      ResourceDescription * rdescrip = new ResourceDescription(pElem,m_namespace);
      if(rdescrip){
        // Use dmid as key to add transformation description
        if (rdescrip->GetDMID().empty()){
          std::string dmid = rdescrip->CreateTransformDMID();
          if (dmid.empty()){
            wxString msg(wxT("Error: Failed to create transform data manager id."));
            msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
            wxLogError(msg);  // Show a dialog box with error message

            return false; // Failed to create dmid
          }
          rdescrip->SetDMID( dmid );
        }
        // Set default directory for transform description
        rdescrip->SetDirectory( std::string(defaultDirectory.mb_str()) );
        AddTransformDescrip(rdescrip->GetDMID(), rdescrip);
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for transform description."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }

    if (pKey.compare("includeRDL") == 0){
      const wxString fn = wxString(pElem->GetText(), wxConvUTF8);
      wxFileName fName(fn);
      
      // Set directory to defaultDirectory if fname is short form.
      // Assume fname is relative to directory containing filename.
      // Use current working directory if defaultDirectory is an empty string.     
      fName.Normalize(wxPATH_NORM_LONG|wxPATH_NORM_DOTS|wxPATH_NORM_TILDE|wxPATH_NORM_ABSOLUTE,defaultDirectory);
      std::string fullFileName = std::string(fName.GetFullPath().mb_str());

      ResourceDescriptionList * rdl = new ResourceDescriptionList(fullFileName,this);
      if (rdl){
        // Use filename of RDL as key to add RDL.  Add RDL to root RDL list
        // RDL is passed from parent to parent until added to root RDL list
        AddRDL(fullFileName, rdl); 
      } else {
        wxString msg(wxT("Error: Failed to allocate memory for included resource description list."));
        msg += wxT("\nFile: ") + wxString(filename.c_str(), wxConvUTF8);
        wxLogError(msg);  // Show a dialog box with error message

        return false; // Failed to allocate memory
      }
    }

        }

        return true;
}

bool ResourceDescriptionList::LoadFromDisplayDescription(const std::string & displayDescriptionFilename){
  wxString temp_str; // Used to remove spaces from left and right of a string
  std::string compare_string; // used to compare lower case string to display description tag

  std::ifstream dd_file(displayDescriptionFilename.c_str());

  if (dd_file.is_open()){

    // loop through the file one line at a time to find begin resource descirption list
    std::string line;
    bool found_begin = false;
    while (!dd_file.eof()  && (!found_begin)){  
      getline(dd_file,line);
      found_begin = CaseInsensitiveFind(line,"Begin ResourcedescriptionList");
    }

    // Report Error if did not find Begin ResourceDescriptionList
    if (dd_file.eof()){
      wxString msg(wxT("Error: "));
      msg += wxString(displayDescriptionFilename.c_str(), wxConvUTF8);
      msg += wxT(" does not contain Begin ResourceDescriptionList statement.");
      wxLogError(msg);

      dd_file.close();
      return false;
    }


    getline(dd_file,line);
    bool found_end = CaseInsensitiveFind(line,"End ResourceDescriptionList");

    while (!dd_file.eof()  && (!found_end)){    

      if(!line.empty()){
        // Get directory of Display Description file
        wxFileName dir(wxString(displayDescriptionFilename.c_str(), wxConvUTF8));
        wxString defaultDirectory = dir.GetPath();

        wxString fn = wxString(line.c_str(), wxConvUTF8);
        fn.Trim(false); // remove spaces from left side of filename
        fn.Trim(true);
        wxFileName fName(fn);

        // Set directory to defaultDirectory if fname is a short form of a filename.
        // Assume that fname is relative to directory containing Display Description file.
        // Use current working directory if defaultDirectory is an empty string.     
        fName.Normalize(wxPATH_NORM_LONG|wxPATH_NORM_DOTS|wxPATH_NORM_TILDE|wxPATH_NORM_ABSOLUTE,defaultDirectory);
        std::string rdl_filename = std::string(fName.GetFullPath().mb_str());

        if (!rdl_filename.empty()){
          if (GetFilename().empty()){
            this->Load(rdl_filename);
          } else {
            this->AddRDL(rdl_filename,new ResourceDescriptionList(rdl_filename));
          }
        }
      }

      getline(dd_file,line);
      found_end = CaseInsensitiveFind(line,"End ResourceDescriptionList");
    }

    // Check if we did not find End ResourceDescriptionList filename
    if (dd_file.eof()){
      wxString msg(wxT("Error: "));
      msg += wxString(displayDescriptionFilename.c_str(), wxConvUTF8);
      msg += wxT(" does not contain End ResourceDescriptionList");
      wxLogError(msg);

      dd_file.close();
      return false;
    }

    dd_file.close();
    return true;

  }else{
    wxString msg(wxT("Error: "));
    msg += wxT("Failed to open ");
    msg += wxString(displayDescriptionFilename.c_str(), wxConvUTF8);
    wxLogError(msg);

    return false;
  }
}