serializationinterface.h

Go to the documentation of this file.

/*
    
  This file is a part of SerUt, a library containing some serialization
  utilities.
  
  Copyright (C) 2008-2012 Jori Liesenborgs

  Contact: jori.liesenborgs@gmail.com

  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 St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef SERUT_SERIALIZATIONINTERFACE_H

#define SERUT_SERIALIZATIONINTERFACE_H

#include "serutconfig.h"
#include <errut/errorbase.h>
#include <sys/types.h>
#include <stdint.h>
#include <vector>

namespace serut
{

class SERUT_IMPORTEXPORT SerializationInterface : public errut::ErrorBase
{
public:
        SerializationInterface()                                                { }
        ~SerializationInterface()                                               { }
        
        virtual bool readBytes(void *pBuffer, size_t amount) = 0;

        virtual bool writeBytes(const void *pBuffer, size_t amount) = 0;

        bool writeLongDouble(double x)                                          { return writeSingle(x); }

        bool writeDouble(double x)                                              { return writeSingle(x); }

        bool writeFloat(float x)                                                { return writeSingle(x); }

        bool writeInt32(int32_t x)                                              { return writeSingle(x); }
        
        bool writeLongDoubles(const long double *pX, size_t amount)             { return writeArray(pX, amount); }

        bool writeDoubles(const double *pX, size_t amount)                      { return writeArray(pX, amount); }

        bool writeFloats(const float *pX, size_t amount)                        { return writeArray(pX, amount); }

        bool writeInt32s(const int32_t *pX, size_t amount)                      { return writeArray(pX, amount); }

        bool writeLongDoubles(const std::vector<long double> &x)                { return writeStdVector(x); }

        bool writeDoubles(const std::vector<double> &x)                         { return writeStdVector(x); }

        bool writeFloats(const std::vector<float> &x)                           { return writeStdVector(x); }

        bool writeInt32s(const std::vector<int32_t> &x)                         { return writeStdVector(x); }

        bool writeString(const std::string &x);
        
        bool readLongDouble(long double *pX)                                    { return readSingle(pX); }

        bool readDouble(double *pX)                                             { return readSingle(pX); }

        bool readFloat(float *pX)                                               { return readSingle(pX); }

        bool readInt32(int32_t *pX)                                             { return readSingle(pX); }

        bool readLongDoubles(long double *pX, size_t amount)                    { return readArray(pX, amount); }

        bool readDoubles(double *pX, size_t amount)                             { return readArray(pX, amount); }

        bool readFloats(float *pX, size_t amount)                               { return readArray(pX, amount); }

        bool readInt32s(int32_t *pX, size_t amount)                             { return readArray(pX, amount); }

        bool readLongDoubles(std::vector<long double> &x)                       { return readStdVector(x); }

        bool readDoubles(std::vector<double> &x)                                { return readStdVector(x); }

        bool readFloats(std::vector<float> &x)                                  { return readStdVector(x); }

        bool readInt32s(std::vector<int32_t> &x)                                { return readStdVector(x); }

        bool readString(std::string &x);
private:
        template<class T>
        bool writeSingle(T x)
        {
                if (!writeBytes(&x, sizeof(T)))
                        return false;
                return true;
        }

        template<class T>
        bool readSingle(T *x)
        {
                if (!readBytes(x, sizeof(T)))
                        return false;
                return true;
        }

        template<class T>
        bool writeArray(const T *x, size_t amount)
        {
                if (!writeBytes(x, sizeof(T)*amount))
                        return false;
                return true;
        }

        template<class T>
        bool readArray(T *x, size_t amount)
        {
                if (!readBytes(x, sizeof(T)*amount))
                        return false;
                return true;
        }

        template<class T>
        bool writeStdVector(const std::vector<T> &v)
        {
                return writeArray(&(v[0]), v.size());
        }

        template<class T>
        bool readStdVector(std::vector<T> &v)
        {
                return readArray(&(v[0]), v.size());
        }
};

} // end namespace

#endif // SERUT_SERIALIZATIONINTERFACE_H