BinaryStream.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2009 Soeren Sonnenburg
 * Copyright (C) 2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef __BINARYSTREAM_H__
#define __BINARYSTREAM_H__

#include <shogun/io/SGIO.h>
#include <shogun/base/SGObject.h>

#include <stdio.h>
#include <string.h>

namespace shogun
{
template <class T> class CBinaryStream : public CSGObject
{
    public:
        CBinaryStream() : CSGObject()
        {
            rw=NULL;
            m_fname=NULL;
            fd = NULL;
            length = 0;
        }

        CBinaryStream(const char* fname, const char* flag="r")
        : CSGObject()
        {
            /* open_stream(bs.m_fname, bs.rw); */
            SG_NOTIMPLEMENTED;
        }


        CBinaryStream(const CBinaryStream &bs)
        {
            open_stream(bs.m_fname, bs.rw);
            ASSERT(length==bs.length);
        }


        virtual ~CBinaryStream()
        {
            close_stream();
        }

        void open_stream(const char* fname, const char* flag="r")
        {
            rw=strdup(flag);
            m_fname=strdup(fname);

            fd = fopen(fname, flag);
            if (!fd)
                SG_ERROR("Error opening file '%s'\n", m_fname);

            struct stat sb;
            if (stat(fname, &sb) == -1)
                SG_ERROR("Error determining file size of '%s'\n", m_fname);

            length = sb.st_size;
            SG_DEBUG("Opened file '%s' of size %ld byte\n", fname, length);
        }

        void close_stream()
        {
            SG_FREE(rw);
            SG_FREE(m_fname);
            if (fd)
                fclose(fd);

            rw=NULL;
            m_fname=NULL;
            fd = NULL;
            length = 0;
        }

        uint64_t get_length()
        {
            return length/sizeof(T);
        }

        uint64_t get_size()
        {
            return length;
        }

        char* get_line(uint64_t& len, uint64_t& offs)
        {
            return NULL;
        }

        int32_t get_num_lines()
        {
            return 0;
        }

        void pre_buffer(T* buffer, long index, long num) const
        {
            ASSERT(index>=0);
            ASSERT(num>=0);

            if (num==0)
                return;

            if (fseek(fd, ((long) sizeof(T))*((long) index), SEEK_SET) != 0)
                SG_ERROR("Error seeking to %ld (file '%s')\n", sizeof(T)*((int64_t) index), m_fname);

            if ( fread(buffer, sizeof(T), num, fd) != num)
                SG_ERROR("Error calling fread (file '%s')\n", m_fname);
        }

        inline T read_next() const
        {
            T ptr;
            if ( fread(&ptr, sizeof(T), 1, fd) != 1)
            {
                fprintf(stderr, "Error calling fread (file '%s')\n", m_fname);
                exit(1);
            }
            return ptr;
        }

        inline T operator[](int32_t index) const
        {

            if (fseek(fd, ((long) sizeof(T))*((long) index), SEEK_SET) != 0)
                SG_ERROR("Error seeking to %ld (file '%s')\n", sizeof(T)*((int64_t) index), m_fname);

            T ptr;

            if ( fread(&ptr, sizeof(T), 1, fd) != 1)
                SG_ERROR("Error calling fread (file '%s')\n", m_fname);

            return ptr;
        }

        inline virtual const char* get_name() const { return "BinaryStream"; }

    protected:
        FILE* fd;
        uint64_t length;
        char* rw;
        char* m_fname;
};
}
#endif // BINARY_STREAM