rock/data.h

/*--------------------------------------------------------------------------

  This is part of the Data system of the Karoo project.

  (C) 2008 Brian Modra <brian@zwartberg.com>

  This library is free software; you can redistribute them 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 these libraries; if not, write to the Free Software Foundation,
  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

--------------------------------------------------------------------------*/



#ifndef data_h
#define data_h

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include "config.h"
#include "base.h"
#include "util.h"
#include <glib.h>
#include <stdint.h>
#include <stdexcept>

using std::exception;
using std::bad_alloc;

namespace karoo {

    class rock_exception_io : public exception
    {
    protected:
        mutable char buf[100];
    public:
        size_t pos;
        size_t size;
        size_t alloc_size;

        rock_exception_io(size_t pos, size_t size, size_t alloc_size) throw() 
        { this->pos = pos; this->size = size; this->alloc_size = alloc_size; }
        virtual ~rock_exception_io() throw() {}

        virtual const char* what() const throw()
        {
            sprintf(buf, "access %u bytes at offset %u, in block of %u bytes", size, pos, alloc_size);
            return buf;
        }
    };

    class rock_exception_read : public rock_exception_io
    {
    public:
        rock_exception_read(size_t pos, size_t size, size_t alloc_size) : rock_exception_io(pos, size, alloc_size) {}
        virtual ~rock_exception_read() throw () {}

        virtual const char* what() const throw()
        {
            sprintf(buf, "read access %u bytes at offset %u, in block of %u bytes", size, pos, alloc_size);
            return buf;
        }
    };

    class rock_data
    {
    private:
    public:
        rock_data() {}
        virtual ~rock_data() {}

        virtual void accomodate(size_t bytes) = 0;

        virtual void write(const void* data, size_t size) = 0;
        virtual void read(void* data, size_t size) = 0;

        void writeNumber(const void* data, size_t size);
        void readNumber(void* data, size_t size);

        void writeU8(const uint8_t&  data) { return writeNumber(&data, sizeof(uint8_t)); }
        void writeU16(const uint16_t& data) { return writeNumber(&data, sizeof(uint16_t)); }
        void writeU32(const uint32_t& data) { return writeNumber(&data, sizeof(uint32_t)); }
        void writeU64(const uint64_t& data) { return writeNumber(&data, sizeof(uint64_t)); }
        void writeI8(const int8_t&   data) { return writeNumber(&data, sizeof(int8_t)); }
        void writeI16(const int16_t&  data) { return writeNumber(&data, sizeof(int16_t)); }
        void writeI32(const int32_t&  data) { return writeNumber(&data, sizeof(int32_t)); }
        void writeI64(const int64_t&  data) { return writeNumber(&data, sizeof(int64_t)); }

        void writeF(const float&      data) { return writeNumber(&data, sizeof(float));  }
        void writeD(const double&   data)  { return writeNumber(&data, sizeof(double)); }
        void writeLD(const long double& data);

        void readU8(uint8_t&  data)  { return readNumber(&data, sizeof(uint8_t));  }
        void readU16(uint16_t& data) { return readNumber(&data, sizeof(uint16_t)); }
        void readU32(uint32_t& data) { return readNumber(&data, sizeof(uint32_t)); }
        void readU64(uint64_t& data) { return readNumber(&data, sizeof(uint64_t)); }
        void readI8(int8_t&  data)   { return readNumber(&data, sizeof(int8_t));   }
        void readI16(int16_t& data)  { return readNumber(&data, sizeof(int16_t));  }
        void readI32(int32_t& data)  { return readNumber(&data, sizeof(int32_t));  }
        void readI64(int64_t& data)  { return readNumber(&data, sizeof(int64_t));  }

        void readF(float&     data)  { return readNumber(&data, sizeof(float));  }
        void readD(double&   data)   { return readNumber(&data, sizeof(double)); }
        void readLD(long double& data);

        void writeS(const text& str);
        void readS(text& str);
    };
}
#endif

---