ossimKeywordlist.h

Go to the documentation of this file.

//---
//
// License: MIT
//
// Author: Ken Melero
// 
// Description: This class provides capabilities for keywordlists.
//
//---
// $Id$

#ifndef ossimKeywordlist_HEADER
#define ossimKeywordlist_HEADER 1

#include <ossim/base/ossimErrorStatusInterface.h>
#include <ossim/base/ossimReferenced.h>
#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimErrorCodes.h>
#include <ossim/base/ossimIosFwd.h>
#include <ossim/base/ossimString.h>
#include <ossim/base/ossimFilename.h>
#include <map>
#include <vector>
#include <algorithm>

static const char DEFAULT_DELIMITER = ':';

class ossimFilename;

class OSSIM_DLL ossimKeywordlist : public ossimErrorStatusInterface,
   public ossimReferenced
{
public:

   typedef std::map<std::string, std::string> KeywordMap;

   ossimKeywordlist(const ossimKeywordlist& src);
   ossimKeywordlist(const std::map<std::string, std::string>& keywordMap);
   ossimKeywordlist(char delimiter = DEFAULT_DELIMITER,
                    bool expandEnvVars = false);

   ossimKeywordlist(const char* file,
                    char        delimiter = DEFAULT_DELIMITER,
                    bool        ignoreBinaryChars = false,
                    bool        expandEnvVars = false );

   ossimKeywordlist(const ossimFilename& fileName,
                    char                 delimiter = DEFAULT_DELIMITER,
                    bool                 ignoreBinaryChars = false,
                    bool                 expandEnvVars = false);

   ~ossimKeywordlist();

   static const std::string NULL_KW;

   bool addFile(const char* file);

   bool addFile(const ossimFilename& file); 

   void change_delimiter(char del);

   ossimString delimiter_str() const;

   void setExpandEnvVarsFlag( bool flag );
   bool getExpandEnvVarsFlag( void ) const;

   void add(const char* prefix,
            const ossimKeywordlist& kwl,
            bool overwrite=true);

   template<class CompareType>
   bool findValue(ossimString& value, const CompareType& compare)const
   {
      KeywordMap::const_iterator iter = std::find_if(m_map.begin(), m_map.end(), compare);
      bool result = (iter != m_map.end());
      if(result) value = iter->second;
      return result;
   }
   
   std::string& operator[](const std::string& key)
   {
      return m_map[key];
   }
   std::string operator[](const std::string& key)const
   {
      ossimString result = find(key.c_str());
      
      return result.c_str();
   }

   // Methods to add keywords to list.
   void addPair(const std::string& key,
                const std::string& value,
                bool               overwrite = true);

   void addPair(const std::string& prefix,
                const std::string& key,
                const std::string& value,
                bool               overwrite = true);
   
   void add(const ossimKeywordlist& kwl,
            const char* prefix=0,
            bool stripPrefix=true);
  
   void add(const char*   key,
            const char*   value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            const char*   value,
            bool          overwrite = true);

   void add(const char*   key,
            char          value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            char          value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_int16   value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            ossim_int16   value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_uint16  value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            ossim_uint16  value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_int32   value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            ossim_int32   value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_uint32  value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            ossim_uint32  value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_int64   value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            ossim_int64   value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_uint64  value,
            bool          overwrite = true);

   void add(const char*   prefix,
            const char*   key,
            ossim_uint64  value,
            bool          overwrite = true);

   void add(const char*   key,
            ossim_float32 value,
            bool          overwrite    = true,
            int           precision    = 8);

   void add(const char*   prefix,
            const char*   key,
            ossim_float32 value,
            bool          overwrite    = true,
            int           precision    = 8);

   void add(const char*   key,
            ossim_float64 value,
            bool          overwrite    = true,
            int           precision    = 15);

   void add(const char*   prefix,
            const char*   key,
            ossim_float64 value,
            bool          overwrite    = true,
            int           precision    = 15);

   bool hasKey( const std::string& key ) const;
   
   const std::string& findKey(const std::string& key) const;
   const std::string& findKey(const std::string& prefix,
                              const std::string& key) const;
   
   const char* find(const char* key) const;
   const char* find(const char* prefix,
                    const char* key) const;

   void remove(const char * key);
   void remove(const char* prefix, const char * key);

   ossim_uint32 numberOf(const char* str) const;

   ossim_uint32 numberOf(const char* prefix, const char* key) const;

   virtual bool write(const char* file, const char* comment = 0) const;

   virtual ossimString toString()const;
   virtual void toString(ossimString& result)const;

   virtual void writeToStream(std::ostream &out)const;

   void toXML(std::ostream &out, const std::string& rootTag="info")const;
   
   void toJSON(std::ostream &out, const std::string& rootTag="info")const;
   
   virtual std::ostream& print(std::ostream& os) const;
   OSSIMDLLEXPORT friend std::ostream& operator<<(std::ostream& os,
                                                  const ossimKeywordlist& kwl);
   bool operator ==(ossimKeywordlist& kwl)const;
   bool operator !=(ossimKeywordlist& kwl)const;

    void clear();

   void addList( const ossimKeywordlist &src, bool overwrite = true );

   virtual bool parseStream(ossim::istream& is,
                            bool ignoreBinaryChars);
   
   virtual bool parseStream(ossim::istream& is);
   virtual bool parseString(const std::string& inString);

   void getSortedList(std::vector<ossimString>& prefixValues,
                      const ossimString &prefixKey)const;
   std::vector<ossimString> findAllKeysThatContains(
      const ossimString &searchString)const;

   void findAllKeysThatMatch( std::vector<ossimString>& result,
                              const ossimString &regularExpression ) const;

   ossim_uint32 getNumberOfKeysThatMatch(
      const ossimString &regularExpression ) const;

   void extractKeysThatMatch(ossimKeywordlist& kwl,
                             const ossimString &regularExpression)const;

   void removeKeysThatMatch(const ossimString &regularExpression);

   std::vector<ossimString> getSubstringKeyList(const ossimString& regularExpression)const;
   void getSubstringKeyList(std::vector<ossimString>& result,
                            const ossimString& regularExpression)const;

   ossim_uint32 getNumberOfSubstringKeys(
      const ossimString& regularExpression)const;

   void addPrefixToAll(const ossimString& prefix);
   void addPrefixToKeysThatMatch(const ossimString& prefix,
                                 const ossimString& regularExpression);
   void stripPrefixFromAll(const ossimString& regularExpression);

   ossim_uint32 getSize()const;

   const ossimKeywordlist::KeywordMap& getMap()const;
   ossimKeywordlist::KeywordMap& getMap();
   
   ossimKeywordlist& downcaseKeywords();
   ossimKeywordlist& upcaseKeywords();
   
   ossimKeywordlist& trimAllValues(const ossimString& valueToTrim= ossimString(" \t\n\r"));
   ossimKeywordlist trimAllValues(const ossimString& valueToTrim= ossimString(" \t\n\r"))const;


   bool getBoolKeywordValue(bool& rtn_val, 
                            const char* keyword, 
                            const char* prefix=0) const;

protected:
   enum KeywordlistParseState
   {
      KeywordlistParseState_OK         = 0,
      
      // Used to say this set of token has failed the rules.
      KeywordlistParseState_FAIL       = 1,

      // Means an error occured that is a mal formed stream for Keywordlist.
      KeywordlistParseState_BAD_STREAM = 2, 
   };
   bool parseFile(const ossimFilename& file,
                  bool  ignoreBinaryChars = false);

   bool isValidKeywordlistCharacter(ossim_uint8 c)const;
   void skipWhitespace(ossim::istream& in)const;
   KeywordlistParseState readComments(ossimString& sequence, ossim::istream& in)const;
   KeywordlistParseState readPreprocDirective(ossim::istream& in);
   KeywordlistParseState readKey(ossimString& sequence, ossim::istream& in)const;
   KeywordlistParseState readValue(ossimString& sequence, ossim::istream& in)const;
   KeywordlistParseState readKeyAndValuePair(ossimString& key,
                                             ossimString& value, ossim::istream& in)const;
   
   // Method to see if keyword exists in list.
   KeywordMap::iterator getMapEntry(const std::string& key);
   KeywordMap::iterator getMapEntry(const ossimString& key);
   KeywordMap::iterator getMapEntry(const char* key);

   // For toXML method lifted from oms::DataInfo.
   bool isSpecialXmlCharacters(const ossimString& value) const;
   bool isValidTag(const std::string& value)const;
   void replaceSpecialCharacters(ossimString& value)const;

   bool isSame( const std::vector<ossimString>& a,
                const std::vector<ossimString>& b ) const;

   KeywordMap               m_map;
   char                     m_delimiter;

   // enables preserving empty field values, multi lines, ... etc
   bool                     m_preserveKeyValues; 

   bool                     m_expandEnvVars;

   // enables relative paths in #include directive
   ossimFilename            m_currentlyParsing; 
};

#endif /* #ifndef ossimKeywordlist_HEADER */