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/lib/config.h>

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

#include <stdio.h>
#include <sys/stat.h>

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

        set_generic<T>();
    }

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


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


    virtual ~CBinaryStream()
    {
        close_stream();
    }

    void open_stream(const char * fname, const char * flag = "r")
    {
        rw = get_strdup(flag);
        m_fname = get_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;
    }

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

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