---

BinFile.h

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// Time-stamp: <Fri Dec/06/2002 06:25 MET Coder@ReallySoft.de>
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#ifndef BINFILE_H
#define BINFILE_H

#ifndef __FSTREAM__
#include <fstream>
#endif
#ifndef ERR_H
#include <Err.h>
#endif


namespace rs {
    namespace file {

        enum BinaryFileType { BF_INPUT, BF_OUTPUT };

        //  ----------------------------------------------
        //      class BinaryFile : rs_boost::noncopyable
        //  ----------------------------------------------
        class BinaryFile : rs_boost::noncopyable {
        private:
            std::string filename;
            BinaryFileType type;
            std::fstream *file;

        public:
            BinaryFile(const std::string& filename_, BinaryFileType type_) {
                filename = filename_;
                type = type_;
                if (type==BF_OUTPUT) {
                    file = new std::fstream(filename.c_str(), std::ios::binary|std::ios::out);
                }
                else {
                    assert(type==BF_INPUT);
                    file = new std::fstream(filename.c_str(), std::ios::binary|std::ios::in);
                }
                if (!file || !file->good()) throw rs::err::IOError(filename);
            }
            virtual ~BinaryFile() { if (file) delete file; }

            const std::string& name() const { return filename; }

            bool good() { return file != 0 && file->good(); }

            bool eof()  {
                assert(type==BF_INPUT);
                return file!=0 && file->eof();
            }

            void put_char(unsigned char  c) {
                assert(type==BF_OUTPUT);
                file->put(c);
            }

            void get_char(unsigned char& c) {
                assert(type==BF_INPUT);
                int i = file->get();
                if (i==EOF) {
                    throw rs::err::Error(std::string("End of file reached (")+filename+")");
                }
                c = i;
            }

            void put_nat(unsigned long nat) {
                assert(sizeof(nat)==4);

                if (nat<=0x7f) {
                    put_char(nat); // bit7==0 -> 1 byte integer
                }
                else if (nat<=0x3FFF) {
                    put_char((nat>>8) | 0x80); // bit7==1 && bit6==0 -> 2 byte integer
                    put_char(nat & 0xFF);
                }
                else if (nat<=0x1FFFFF) {
                    put_char((nat>>16) | 0xC0); // bit7==1 && bit6==1 && bit5==0 -> 3 byte integer
                    put_char((nat>>8) & 0xFF);
                    put_char(nat & 0xFF);
                }
                else if (nat<=0x0FFFFFFF) {
                    put_char((nat>>24) | 0xE0); // bit7==1 && bit6==1 && bit5==1 && bit4==0 -> 4 byte integer
                    put_char((nat>>16) & 0xFF);
                    put_char((nat>>8) & 0xFF);
                    put_char(nat & 0xFF);
                }
                else { // sonst als 5 byte integer
                    put_char(0xf0);
                    put_char((nat>>24) & 0xFF);
                    put_char((nat>>16) & 0xFF);
                    put_char((nat>>8) & 0xFF);
                    put_char(nat & 0xFF);
                }
            }
            void get_nat(unsigned long &i) {
                unsigned char c; get_char(c);

                if ((c&0x80)==0) { // 1-byte
                    i = c;
                }
                else {
                    if ((c&0xC0)==0x80) { // 2-byte
                        i = (unsigned long)(c&0x3F) << 8;
                    }
                    else {
                        if ((c&0xE0)==0xC0) { // 3-byte
                            i = (unsigned long)(c&0x1F) << 16;
                        }
                        else {
                            if ((c&0xF0)==0xE0) { // 4-byte
                                i = (unsigned long)(c&0x0F) << 24;
                            }
                            else {
                                get_char(c); i = (unsigned long)c << 24;
                            }
                            get_char(c); i = (unsigned long)c << 16;
                        }
                        get_char(c); i |= (unsigned long)c << 8;
                    }
                    get_char(c); i |= c;
                }
            }

            void put_long(long i) {
                // changes position of sign-bit in such manner that compression gets better.
                unsigned long l;
                if (i<0) {
                    l = (-i << 1) | 1;
                }
                else {
                    l = i << 1;
                }
                put_nat(l);
            }
            void get_long(long& i) {
                unsigned long l;
                get_nat(l);
                if (l&1) {
                    i = -(long)(l >> 1);
                }
                else {
                    i = l >> 1;
                }
            }

            void put_int(int i) { put_long(i); }
            void get_int(int& i) { long l; get_long(l); i=(int)l; }


            void write_bytes(const unsigned char *buf, std::streamsize size) {
                assert(type==BF_OUTPUT);
                file->write(reinterpret_cast<const char*>(buf), size);
            }
            void read_bytes(unsigned char *buf, std::streamsize size) {
                assert(type==BF_INPUT);
                file->read(reinterpret_cast<char *>(buf), size);
            }

            void put_string(const std::string& s) {
                put_int(s.length());
                write_bytes((const unsigned char *)s.data(), s.length());
            }
            void get_string(std::string& s) {
                int len;
                get_int(len);
                unsigned char *buf = new unsigned char[len+1];
                read_bytes(buf, len);
                buf[len] = 0;
                s = (char*)buf;
                delete [] buf;
            }
        };

        template <class T> inline void put_binary(const T& t, BinaryFile& file) {
            file.write_bytes((const unsigned char*)(&t), sizeof(t));
        }

        template <class T> inline void get_binary(T& t, BinaryFile& file) {
            file.read_bytes((unsigned char*)(&t), sizeof(t));
        }

        template <> inline void put_binary<std::string>(const std::string& s, BinaryFile& file) { file.put_string(s); }
        template <> inline void get_binary<std::string>(std::string& s, BinaryFile& file)  { file.get_string(s); }


        class BinaryStoreable {
        public:
            BinaryStoreable() {}
            virtual ~BinaryStoreable() {}

            virtual void save(BinaryFile& out) const = 0;

            virtual void load(BinaryFile& in, int version) = 0;
        };

    }; // end of namespace file
}; // end of namespace rs

#else
#error BinFile.h included twice
#endif // BINFILE_H

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002