C:/Programs/source/NIREP/DisplayDescription/ResourceDescriptionList/ResourceDescription.h

/***************************************************************************************
*   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.
******************************************************************************************/
#pragma once
#ifndef _RESOURCE_DESCRIPTION_H_
#define _RESOURCE_DESCRIPTION_H_

#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <cstring>
#include "tinyxml.h"

#include <wx/filename.h>

#include "NIREPDefinitions.h"
#include "BasicDescription.h"

class ResourceDescription{
public:
  typedef struct {
    std::string index;     // index of coordinate system when there are multiple coordinate systems
                           // index = 0 corresponds to the source coordinate system
    std::string ns;        // namespace of coordinate system
    std::string id;        // coordinate system id
  } CoordinateSystem;

  typedef std::map<std::string, CoordinateSystem> CSList;
  typedef std::map<std::string, std::string> AlgList;
  typedef std::map<std::string, std::string> FilenameList;
  typedef std::map<std::string, std::string> AttributeList;

  ResourceDescription(std::string default_ns){ SetDefaultNS(default_ns);};

        ResourceDescription(TiXmlElement * descrip, std::string default_ns){
                SetDefaultNS(default_ns);
    if (!FillUsingDom(descrip)){
                        Clear();
                }
        };

        ~ResourceDescription(){ Clear(); };

        void Clear();

        std::string & GetDefaultNS(){ return m_default_ns;}
        void SetDefaultNS(std::string default_ns){ 
    m_default_ns = default_ns; 
    // convert m_default_ns to lower case for case insensitivity strin comparison
    std::transform(m_default_ns.begin(), m_default_ns.end(), m_default_ns.begin(), ::tolower);
  }
  
        std::string & GetLabel(){ return m_label;}
        void SetLabel(std::string label){ 
    m_label = label; 
    // convert m_label to lower case for case insensitivity strin comparison
    std::transform(m_label.begin(), m_label.end(), m_label.begin(), ::tolower);
  }

        std::string & GetDMID(){ return m_dmid;}
        void SetDMID(std::string dmid){ 
    m_dmid = dmid; 
    // convert m_dmid to lower case for case insensitivity strin comparison
    std::transform(m_dmid.begin(), m_dmid.end(), m_dmid.begin(), ::tolower);
  }

        const CoordinateSystem * GetCS(std::string & index){ 
    CSList::iterator iter = m_cs.find(index);
                if (iter != m_cs.end()){
                        return &iter->second;
                } else {
                        return NULL;
                }
        }

  //JAH added this in
        const CSList * GetCS(){ 
    return &m_cs;
        }

  void AddCS(std::string key, CoordinateSystem cs){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_cs[key] = cs; 
  }
        void ClearCSList(){ m_cs.clear(); }

  const size_t GetNumCS(){ return m_cs.size();  }

  const size_t GetNumAlg(){ return m_alg.size();        }

  const std::string CreateCSnsid(const std::string & index){ 
    CSList::iterator iter = m_cs.find(index); 
    if (iter != m_cs.end()){
      // Use default namespace if coordinate system namespace missing
      std::string cs_namespace = iter->second.ns;
      if (cs_namespace.empty()){
        return GetDefaultNS() + "|" + iter->second.id;
      } else {
        return cs_namespace + "|" + iter->second.id;
      }
    } else {
      return NULL;
    }
  }

  const std::string CreateReferenceCSnsid(){ 
    CSList::reverse_iterator riter = m_cs.rbegin(); // Get namespace of last/reference coordinate system
    if (!m_cs.empty()){
      // Use default namespace if coordinate system namespace missing
      std::string cs_namespace = riter->second.ns;
      if (cs_namespace.empty()){
        return GetDefaultNS() + "|" + riter->second.id;
      } else {
        return cs_namespace + "|" + riter->second.id;
      }
    } else {
      return "";
    }
  }

  std::string CreateLabelDMID(){
    if ((GetNumCS() == 1) && !m_label.empty()){
      std::string dmid;
      
      dmid = EvalCmd["SpatialData"] + "(" + CreateReferenceCSnsid() + "," + GetLabel() + ")";
      return dmid;
    } else {
      return "";
    }
  }

  std::string CreateTransformDMID(){
    if ((GetNumCS() == 2) && (GetNumAlg() == 1)){
      std::string dmid;
      
      dmid = EvalCmd["Transformation"] + "(" + CreateCSnsid("0") + ","
             + CreateCSnsid("1") + "," + GetAlgorithm("0") + ")";
      return dmid;
    } else {
      return "";
    }
  }

        std::string GetAlgorithm(std::string key){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

                AlgList::iterator iter = m_alg.find(key);
                if (iter != m_alg.end()){
                        return iter->second;
                } else {
                        return "";
                }
        }
        void AddAlgorithm(std::string key, const std::string & algorithmID){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_alg[key] = algorithmID; 
  }
        void ClearAlgorithms(){ m_alg.clear(); }

        std::string & GetFormat(){ return m_format;}
        void SetFormat(const std::string & format){ 
    m_format = format; 
    // convert m_format to lower case for case insensitivity strin comparison
    std::transform(m_format.begin(), m_format.end(), m_format.begin(), ::tolower);
  }
  
  std::string & GetDirectory(){ return m_directory;}
        void SetDirectory(const std::string & directory){ m_directory = directory; }

  //JAH added in bool normalize, this way if we don't want the filename to be noramlized then
  //the filename won't be normalized
        std::string GetFilename(const std::string & index, bool normalize = true){
                FilenameList::iterator iter = m_filename.find(index);
    if (iter != m_filename.end()){
      // When we are passed the short form of a filename, normalize it and make the long form.
      // If path is missing, the code currently prepends the current working directory.
      // This is incorrect and should be changed to path of the rdl file that it came from.
      wxString s( iter->second.c_str(), wxConvUTF8 );
      wxFileName fName(s);

      // Use result of GetDirectory to set the directory.  Use current working directory if GetDirectory returns an empty string. 
      if(normalize) {
        fName.Normalize(wxPATH_NORM_LONG|wxPATH_NORM_DOTS|wxPATH_NORM_TILDE|wxPATH_NORM_ABSOLUTE,wxString(GetDirectory().c_str(), wxConvUTF8));
      }
      std::string filename = std::string(fName.GetFullPath().mb_str());
      //return std::string(fName.GetFullPath().mb_str());
      return filename;
    } else {
      return "";
    }
  }
        void AddFilename(const std::string & index, const std::string & filename){ m_filename[index] = filename; }
        void ClearFilenames(){ m_filename.clear(); }

        std::string & GetTransformUnits(){ return m_transform_units;}
        void SetTransformUnits(const std::string & transform_units){ 
    m_transform_units = transform_units; 
    // convert m_transform_units to lower case for case insensitivity strin comparison
    std::transform(m_transform_units.begin(), m_transform_units.end(), m_transform_units.begin(), ::tolower);
  }

        std::string & GetDataType(){ return m_datatype;}
        void SetDataType(const std::string & datatype){ 
    m_datatype = datatype; 
    // convert m_datatype to lower case for case insensitivity strin comparison
    std::transform(m_datatype.begin(), m_datatype.end(), m_datatype.begin(), ::tolower);
  }

        std::string GetAttribute(std::string key){
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

                AttributeList::iterator iter = m_attribute.find(key);
                if (iter != m_attribute.end()){
                        return iter->second;
                } else {
                        return "";
                }
        }
        void AddAttribute(std::string key, const std::string & value){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_attribute[key] = value; 
  }
        void ClearAttributes(){ m_attribute.clear(); }

        // DOM = Document Object Model
        TiXmlElement * CreateDOM(const std::string & tag);
        bool FillUsingDom(TiXmlElement * descrip);


private:
  std::string     m_default_ns;   // Default namespace
        std::string         m_label;        // User supplied label to denote data type
  std::string     m_dmid;         // data manager id, data manager uses this to reference data
        CSList          m_cs;           // List of coordinate systems

  AlgList         m_alg;          // List of algorithms, one less than # of coordinate systems

  std::string     m_format;       // Format of transformation files
  std::string     m_directory;    // Directory appended to relative filenames.
  FilenameList    m_filename;     // List of filenames
  std::string     m_transform_units; // unit cube, physical, image
  std::string     m_datatype;     // Type of data stored in file

  AttributeList   m_attribute;    // List of attributes associated with resource, 
                                        // e.g., name, description, race, age, handedness

};

#endif