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

/***************************************************************************************
*   @author Gary E. Christensen
*   @date 6/24/2010
*   @class ResourceDescriptionList
*   @brief 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. 
*      This class creates a map of ResourceDescription objects by parsing a resource description file.
******************************************************************************************/
#pragma once
#ifndef _RESOURCE_DESCRIPTION_LIST_H_
#define _RESOURCE_DESCRIPTION_LIST_H_

#include <string>
#include <map>
#include <set>
#include <algorithm>
#include "BasicDescription.h"
#include "ResourceDescription.h"

#include "tinyxml.h"
#include <wx/log.h>


class ResourceDescriptionList {
public:
  typedef std::map<std::string, BasicDescription *> BasicList;
  typedef std::map<std::string, ResourceDescription *> ResourceList;
  typedef std::map<std::string, ResourceDescriptionList *> RDLList;

  // Constructor left empty on purpose.  
        // All member objects initialize themselves automatically.
        ResourceDescriptionList(ResourceDescriptionList * parent = NULL) { m_parent = parent; }

        ResourceDescriptionList(const std::string & rdl_filename, ResourceDescriptionList * parent = NULL) {
    m_parent = parent;
    if (!rdl_filename.empty()){
      this->Load(rdl_filename);
    }
        }

  // Destructor left empty on purpose.  
        // All member objects should destroy themselves automatically.
  ~ResourceDescriptionList() { Clear(); };

        void Clear();

        bool Load(){ return Load(m_filename); };

        bool Load(const std::string & rdl_filename);  

  bool LoadFromDisplayDescription(const std::string & displayDescriptionFilename);


        bool Save(){ return Save(m_filename); };

        bool Save(const std::string & filename); 

  //JAH added
        bool Save(FILE *); 

        std::string & GetFilename() { return m_filename; }
        void SetFilename(const std::string & filename) { m_filename = filename; }

  std::vector<std::string> * CreateRDLFilenameList() { 
    std::vector<std::string> * filename = new std::vector<std::string>;

    if (filename != NULL){
      // Add root RDL filename
      filename->push_back(GetFilename());  

      // Add children RDL filenames if present
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          filename->push_back(RDL_iter->second->GetFilename());
        }
      }
    }else{
      wxString msg(wxT("Error: Could not allocate memory to store RDL Filenames"));
      wxLogError(msg);
    }

    return filename;
  }
  
        std::string & GetNameSpace() { return m_namespace; }
        void SetNameSpace(const std::string & _namespace) { 
    m_namespace = _namespace; 
    // convert m_namespace to lower case for case insensitivity strin comparison
    std::transform(m_namespace.begin(), m_namespace.end(), m_namespace.begin(), ::tolower);
  }

  BasicList & GetNameSpaceDescrip() { return m_namespace_descrip; }
  void SetNameSpaceDescrip(const BasicList & namespace_descrip) { m_namespace_descrip = namespace_descrip; }
  BasicDescription * GetNameSpaceDescrip(std::string key){
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    BasicList::iterator iter = m_namespace_descrip.find(key);
    if (iter != m_namespace_descrip.end()){
      return iter->second;
    } else {
      // Search for name space description in all included research description lists
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          iter = RDL_iter->second->m_namespace_descrip.find(key);    // RDL_iter->second is a different resource description list each time through the for loop
          if (iter != RDL_iter->second->m_namespace_descrip.end()){  // check to see if key was found in m_namespace_description list. not found if iter = end of list
            return iter->second;
          }
        }
      }
      // Return NULL if not found
      return NULL;
    }
  }
        void AddNameSpaceDescrip(std::string key, BasicDescription * value){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_namespace_descrip[key] = value; 
  }
  void ClearNameSpaceDescrips(){ 
    BasicList::iterator iter;
    for(iter = m_namespace_descrip.begin(); iter != m_namespace_descrip.end(); ++iter){
      delete iter->second;
    }
    m_namespace_descrip.clear(); 
  }

  std::vector<std::string> * CreateNameSpaceList() { 
    std::vector<std::string> * ns_list = new std::vector<std::string>;

    if (ns_list != NULL){
      // Add root namespaces
      BasicList::iterator iter;
      for(iter = m_namespace_descrip.begin(); iter != m_namespace_descrip.end(); ++iter){
        ns_list->push_back(iter->second->GetID());  
      }

      // Add first level children namespaces if present
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          BasicList child_descrip = RDL_iter->second->GetNameSpaceDescrip();
          BasicList::iterator iter;
          for(iter = child_descrip.begin(); iter != child_descrip.end(); ++iter){
            ns_list->push_back(iter->second->GetID());  
          }
        }
      }
    }else{
      wxString msg(wxT("Error: Could not allocate memory to store all namespaces."));
      wxLogError(msg);
    }

    return ns_list;
  }


  BasicList & GetCSDescrip() { return m_cs_descrip; }
  void SetCSDescrip(const BasicList & cs_descrip) { m_cs_descrip = cs_descrip; }

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

                BasicList::iterator iter = m_cs_descrip.find(key);
                if (iter != m_cs_descrip.end()){
                        return iter->second;
                } else {
      // Search for coordinate system description in all included research description lists
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          iter = RDL_iter->second->m_cs_descrip.find(key);    // RDL_iter->second is a different resource description list each time through the for loop
          if (iter != RDL_iter->second->m_cs_descrip.end()){  // check to see if key was found in m_cs_descrip list. not found if iter = end of list
            return iter->second;
          }
        }
      }
      // Return NULL if not found
      return NULL;
                }
        }
        void AddCSDescrip(std::string key, BasicDescription * value){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_cs_descrip[key] = value; 
  }
        void ClearCSDescrips(){ 
    BasicList::iterator iter;
    for(iter = m_cs_descrip.begin(); iter != m_cs_descrip.end(); ++iter){
      delete iter->second;
    }
    m_cs_descrip.clear(); 
  }
  std::vector<std::string> * CreateCSList() { 
    std::vector<std::string> * cs_list = new std::vector<std::string>;

    if (cs_list != NULL){
      // Add root coordinate systems
      BasicList::iterator iter;
      for(iter = m_cs_descrip.begin(); iter != m_cs_descrip.end(); ++iter){
        cs_list->push_back(iter->second->GetID());  
      }

      // Add first level children coordinate systems if present
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          BasicList child_descrip = RDL_iter->second->GetCSDescrip();
          BasicList::iterator iter;
          for(iter = child_descrip.begin(); iter != child_descrip.end(); ++iter){
            cs_list->push_back(iter->second->GetID());  
          }
        }
      }
    }else{
      wxString msg(wxT("Error: Could not allocate memory to store all coordinate system names."));
      wxLogError(msg);
    }

    return cs_list;
  }


  BasicList & GetAlgorithmDescrip() { return m_algorithm_descrip; }
  void SetAlgorithmDescrip(const BasicList & algorithm_descrip) { m_algorithm_descrip = algorithm_descrip;  }

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

                BasicList::iterator iter = m_algorithm_descrip.find(key);
                if (iter != m_algorithm_descrip.end()){
                        return iter->second;
                } else {
      // Search for algorithm description in all included research description lists
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          iter = RDL_iter->second->m_algorithm_descrip.find(key);    // RDL_iter->second is a different resource description list each time through the for loop
          if (iter != RDL_iter->second->m_algorithm_descrip.end()){  // check to see if key was found in m_algorithm_descrip list. not found if iter = end of list
            return iter->second;
          }
        }
      }
      // Return NULL if not found
                        return NULL;
                }
        }
        void AddAlgorithmDescrip(std::string key, BasicDescription * value){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_algorithm_descrip[key] = value; 
  }
        void ClearAlgorithmDescrips(){ 
    BasicList::iterator iter;
    for(iter = m_algorithm_descrip.begin(); iter != m_algorithm_descrip.end(); ++iter){
      delete iter->second;
    }
    m_algorithm_descrip.clear(); 
  }
  std::vector<std::string> * CreateAlgorithmList() { 
    std::vector<std::string> * alg_list = new std::vector<std::string>;

    if (alg_list != NULL){
      // Add root coordinate systems
      BasicList::iterator iter;
      for(iter = m_cs_descrip.begin(); iter != m_cs_descrip.end(); ++iter){
        alg_list->push_back(iter->second->GetID());  
      }

      // Add first level children coordinate systems if present
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          BasicList child_descrip = RDL_iter->second->GetAlgorithmDescrip();
          BasicList::iterator iter;
          for(iter = child_descrip.begin(); iter != child_descrip.end(); ++iter){
            alg_list->push_back(iter->second->GetID());  
          }
        }
      }
    }else{
      wxString msg(wxT("Error: Could not allocate memory to store all the algorithm names."));
      wxLogError(msg);
    }

    return alg_list;
  }

  BasicList & GetLabelDescrip() { return m_label_descrip; }
  void SetLabelDescrip(const BasicList & label_descrip) { m_label_descrip = label_descrip;  }

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

                BasicList::iterator iter = m_label_descrip.find(key);
                if (iter != m_label_descrip.end()){
                        return iter->second;
                } else {
      // Search for label description in all included research description lists
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          iter = RDL_iter->second->m_label_descrip.find(key);    // RDL_iter->second is a different resource description list each time through the for loop
          if (iter != RDL_iter->second->m_label_descrip.end()){  // check to see if key was found in m_label_descrip list. not found if iter = end of list
            return iter->second;
          }
        }
      }
      // Return NULL if not found
                        return NULL;
                }
        }
        void AddLabelDescrip(std::string key, BasicDescription * value){
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);

    m_label_descrip[key] = value; 
  }
        void ClearLabelDescrips(){ 
    BasicList::iterator iter;
    for(iter = m_label_descrip.begin(); iter != m_label_descrip.end(); ++iter){
      delete iter->second;
    }
    m_label_descrip.clear(); 
  }
  std::vector<std::string> * CreateLabelList() { 
    std::vector<std::string> * label_list = new std::vector<std::string>;

    if (label_list != NULL){
      // Add root coordinate systems
      BasicList::iterator iter;
      for(iter = m_label_descrip.begin(); iter != m_label_descrip.end(); ++iter){
        label_list->push_back(iter->second->GetID());  
      }

      // Add first level children coordinate systems if present
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          BasicList child_descrip = RDL_iter->second->GetLabelDescrip();
          BasicList::iterator iter;
          for(iter = child_descrip.begin(); iter != child_descrip.end(); ++iter){
            label_list->push_back(iter->second->GetID());  
          }
        }
      }
    }else{
      wxString msg(wxT("Error: Could not allocate memory to store all the label names."));
      wxLogError(msg);
    }

    return label_list;
  }

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

                ResourceList::iterator iter = m_data_descrip.find(key);
                if (iter != m_data_descrip.end()){
                        return iter->second;
                } else {
      // Search for data description in all included research description lists
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          iter = RDL_iter->second->m_data_descrip.find(key);    // RDL_iter->second is a different resource description list each time through the for loop
          if (iter != RDL_iter->second->m_data_descrip.end()){  // check to see if key was found in m_data_descrip list. not found if iter = end of list
            return iter->second;
          }
        }
      }
      // Return NULL if not found
                        return NULL;
                }
        }
        bool AddDataDescrip(std::string key, ResourceDescription * value){ 
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);
    int size = m_data_descrip.size();
    m_data_descrip[key] = value; 
    if(size< m_data_descrip.size()) {
      return true;
    }
    return false;
  }
        void ClearDataDescrips(){ 
    ResourceList::iterator iter;
    for(iter = m_data_descrip.begin(); iter != m_data_descrip.end(); ++iter){
      delete iter->second;
    }
    m_data_descrip.clear(); 
  }

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

                ResourceList::iterator iter = m_transform_descrip.find(key);
                if (iter != m_transform_descrip.end()){
                        return iter->second;
                } else {
                        // Search for transform description in all included research description lists
      if (!m_RDL.empty()){
        RDLList::iterator RDL_iter;
        for(RDL_iter = m_RDL.begin(); RDL_iter != m_RDL.end(); ++RDL_iter){ 
          iter = RDL_iter->second->m_transform_descrip.find(key);    // RDL_iter->second is a different resource description list each time through the for loop
          if (iter != RDL_iter->second->m_transform_descrip.end()){  // check to see if key was found in m_transform_descrip list. not found if iter = end of list
            return iter->second;
          }
        }
      }
      // Return NULL if not found
                        return NULL;
                }
        }
        bool AddTransformDescrip(std::string key, ResourceDescription * value){
    // convert key to lower case for case insensitivity strin comparison
    std::transform(key.begin(), key.end(), key.begin(), ::tolower);
    int size = m_transform_descrip.size();
    m_transform_descrip[key] = value; 
    if(size< m_transform_descrip.size()) {
      return true;
    }
    return false;
  }
        void ClearTransformDescrips(){ 
    ResourceList::iterator iter;
    for(iter = m_transform_descrip.begin(); iter != m_transform_descrip.end(); ++iter){
      delete iter->second;
    }
    m_transform_descrip.clear(); 
  }

  ResourceDescriptionList * GetParentRDL(){return m_parent;}
  void SetParentRDL(ResourceDescriptionList * parent){ m_parent = parent; }

        // Do not change case of filenames
  ResourceDescriptionList * GetRDL(const std::string & filename){ 
                RDLList::iterator iter = m_RDL.find(filename);
                if (iter != m_RDL.end()){
                        return iter->second;
                } else {
                        return NULL;
                }
        }
        void AddRDL(const std::string & filename, ResourceDescriptionList * rdl){ 
    // parent == NULL for the root RDL, otherwise pass RDL to parent to add
    if (m_parent == NULL){
      // Add RDL to root RDL list if it has not previously been added
      RDLList::iterator iter = m_RDL.find(filename);
                if (iter == m_RDL.end()){
                          m_RDL[filename] = rdl; 
                  }
    } else {
      GetParentRDL()->AddRDL(filename, rdl);
    }
  }

  void ClearRDLs(){ 
    // Destroy all included RDLs
    RDLList::iterator RDL_iter;
    for(RDL_iter=m_RDL.begin(); RDL_iter!=m_RDL.end(); ++RDL_iter){
      delete RDL_iter->second;
    }
    m_RDL.clear(); 
  }

//bool CaseInsensitiveFind(std::string string1, std::string string2);

private:
  std::string   m_filename;             // filename of resource description list
  std::string   m_namespace;            // Default namespace

  BasicList     m_namespace_descrip;    // List of name space descriptions indexed by namespace
  BasicList     m_cs_descrip;           // List coordinate system descriptions indexed by namespace and coordinate system
  BasicList     m_algorithm_descrip;    // List algorithm descriptions indexed by algorithm name
  BasicList     m_label_descrip;        // List label descriptions indexed by label name

        ResourceList  m_data_descrip;         // List of data file resourses indexed by dmid (data manager id)
  ResourceList  m_transform_descrip;    // List of transformation file resources indexed by dmid (data manager id)
    
  ResourceDescriptionList * m_parent;   // Pointer to parent ResourceDescriptionList object.  Root has NULL parent.
  RDLList       m_RDL;                  // List of included ResourceDescirptionList object pointers.  RDLs are
                                        // included at the root node to avoid duplicate entries and cycles.
  
};

#endif