b_stream.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_B_STREAM
#define GEOGRAM_BASIC_B_STREAM
 
#include <geogram/basic/common.h>
#include <geogram/basic/numeric.h>
 
#include <iostream>
#include <fstream>
#include <string>
 
namespace GEO {
 
    class GEOGRAM_API BinaryStream {
    public:
    static const int GEO_LITTLE_ENDIAN = 0;
 
    static const int GEO_BIG_ENDIAN = 1;
 
    void set_stream_endian(int stream_endian);
 
    inline int stream_endian() const {
        return stream_endian_;
    }
 
    inline int machine_endian() const {
        return machine_endian_;
    }
 
    inline bool has_record_markers() const {
        return has_record_markers_;
    }
 
    inline void set_has_record_markers(bool b) {
        has_record_markers_ = b;
    }
 
    protected:
    BinaryStream(int stream_endian = GEO_BIG_ENDIAN);
 
    void detect_machine_endian();
 
    template <size_t N>
    struct ItemSize {
    };
 
    protected:
    bool swapped_;
 
    private:
    int machine_endian_;
    int stream_endian_;
    bool has_record_markers_;
    };
 
    /************************************************************************/
 
    class GEOGRAM_API BinaryInputStream : public BinaryStream {
    public:
        BinaryInputStream(
            const std::string& file_name, int stream_endian = GEO_BIG_ENDIAN
        );
 
        BinaryInputStream(
            std::istream& input, int stream_endian = GEO_BIG_ENDIAN
        );
 
        ~BinaryInputStream();
 
        bool OK() const;
 
        bool more() const;
 
        template <class T>
            inline BinaryInputStream& operator>> (T& x) {
            return read(
                (char*) &x, 1,
                ItemSize<Numeric::Limits<T>::size>()
            );
        }
 
        inline BinaryInputStream& read_opaque_data(void* ptr, size_t n) {
            input_->read((char*) ptr, (std::streamsize) n);
            return *this;
        }
 
        inline BinaryInputStream& read_opaque_data(
            void* ptr, size_t size, size_t n
        ) {
            return read_opaque_data(ptr, size * n);
        }
 
        template <class T>
            inline BinaryInputStream& read_array(T* data, size_t n) {
            return read(
                (char*) data, n,
                ItemSize<Numeric::Limits<T>::size>()
            );
        }
 
        void begin_record();
 
        void end_record();
 
        template <class T>
            inline BinaryInputStream& read_record(T* data, size_t n) {
            begin_record();
            read(
                (char*) data, n,
                ItemSize<Numeric::Limits<T>::size>()
            );
            end_record();
            return *this;
        }
 
        std::streamoff tell() const {
            return input_->tellg();
        }
 
        void seek(std::streamoff pos) {
            input_->seekg(pos);
        }
 
        void seek(std::streamoff off, std::ios_base::seekdir dir) {
            input_->seekg(off, dir);
        }
 
    protected:
        inline BinaryInputStream& read(char* data, size_t n, ItemSize<1>) {
            return read_opaque_data(data, n);
        }
 
        BinaryInputStream& read(char* data, size_t n, ItemSize<2>);
 
        BinaryInputStream& read(char* data, size_t n, ItemSize<4>);
 
        BinaryInputStream& read(char* data, size_t n, ItemSize<8>);
 
    private:
        std::istream* input_;
        bool owns_input_;
        bool record_OK_;
        Numeric::uint32 count1_;
        Numeric::uint32 count2_;
        Numeric::int32 record_count_;
    };
 
    /************************************************************************/
 
    class GEOGRAM_API BinaryOutputStream : public BinaryStream {
    public:
        BinaryOutputStream(
            const std::string& file_name, int stream_endian = GEO_BIG_ENDIAN
        );
 
        BinaryOutputStream(
            std::ostream& output, int stream_endian = GEO_BIG_ENDIAN
        );
 
        ~BinaryOutputStream();
 
        bool OK() const;
 
        template <class T>
            inline BinaryOutputStream& operator<< (T x) {
            return write(
                (const char*) &x, 1,
                ItemSize<Numeric::Limits<T>::size>()
            );
        }
 
        inline BinaryOutputStream& write_opaque_data(
            const void* ptr, size_t size
        ) {
            output_->write((const char*) ptr, (std::streamsize) size);
            count_ += size;
            return *this;
        }
 
        inline BinaryOutputStream& write_opaque_data(
            const void* ptr, size_t size, size_t n
        ) {
            return write_opaque_data(ptr, size * n);
        }
 
        template <class T>
            inline BinaryOutputStream& write_array(const T* data, size_t n) {
            return write(
                (const char*) data, n,
                ItemSize<Numeric::Limits<T>::size>()
            );
        }
 
        void begin_record();
 
        void end_record();
 
        template <class T>
            BinaryOutputStream& write_record(const T* data, size_t n) {
            begin_record();
            write(
                (const char*) data, n,
                ItemSize<Numeric::Limits<T>::size>()
            );
            end_record();
            return *this;
        }
 
    protected:
        BinaryOutputStream& write(const char* data, size_t n, ItemSize<1>) {
            return write_opaque_data(data, n);
        }
 
        BinaryOutputStream& write(const char* data, size_t n, ItemSize<2>);
 
        BinaryOutputStream& write(const char* data, size_t n, ItemSize<4>);
 
        BinaryOutputStream& write(const char* data, size_t n, ItemSize<8>);
 
    private:
        void write_marker(Numeric::uint32 value);
 
        std::ostream* output_;
        bool owns_output_;
        size_t count_;
        std::streamoff pos_;
    };
 
    /************************************************************************/
}
 
#endif