sprint/archive/simple.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::simple
*
*   Copyright (C) 2002-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_SIMPLE_ARCHIVE_H
#define _SPRINT_SIMPLE_ARCHIVE_H

#include <sprint/sysdef.h>
#include <string>
#include <string.h>
#include <sprint/container/unordered_map.h>
#include <sprint/smart_cast.h>

namespace sprint {

typedef sprint::unordered_map<std::string, std::string> SimpleTextArchive;
 
bool LoadSimpleTextArchive(std::vector< std::pair<std::string, std::string> > & s, const char *fileName);
bool SaveSimpleTextArchive(const std::vector< std::pair<std::string, std::string> > & s, const char *fileName);

class SimpleTextArchiveOut {
    FILE *m_fp;
    public:
    SimpleTextArchiveOut(const char *storage);
    ~SimpleTextArchiveOut();
    
        inline bool reading() const { return false; }
        inline bool writing() const { return true; }

    void Write(const char * key, const char *value);    
    void Write(const char * key, const std::string & value)
        {
        Write(key, value.c_str());
        }
      
        template<class T, class R>
        inline void operator() (const char * path, T value, R _default) { Write(path, smart_cast<std::string>(value) );  }

        template<class T>
        inline bool operator() (const char * path, T value) { Write(path, value); return true;  }
        
        inline void str (const char * path, const char * buffer, int buflen, const char * _default) 
                        { 
                                Write(path, buffer);  
                        }

        inline bool str (const char * path, const char * buffer, int buflen) 
                        { 
                                Write(path, buffer);  
                                return true;
                        }
};

class SimpleTextArchiveIn {
    SimpleTextArchive m_storage;
    public:
           
    SimpleTextArchiveIn(const char *storage) { 
                              sprint::LoadSimpleTextArchive(m_storage, storage); 
                              }
    ~SimpleTextArchiveIn();
    
        inline bool reading() const { return true; }
        inline bool writing() const { return false; }
        
        const char *Read(const char * path) const;

        template<class T>
        inline bool operator() (const char * path, T &value) 
    { 
    const char *val = Read(path);
    if(val!=NULL) 
      {
      value = smart_cast<T>(val);  
      return true;
      }
    else
      return false;
    }

        template<class T, class R>
        inline void operator() (const char * path, T &value, R _default) 
    { 
    if(!operator()(path, &value)) 
      value = _default;  
    }
        
        inline bool str (const char * path, char * buffer, int buflen) 
                        { 
            const char *val = Read(path);
            if(val!=NULL) 
              {
              strncpy(buffer, val, buflen);  
              return true;
              }
            else
              return false;
                        }
                        
        inline void str (const char * path, char * buffer, int buflen, const char * _default) 
                        { 
                                if(!str(path, buffer, buflen)) strcpy(buffer, _default);  
                        }


};
      
} // namespace
      
#endif