SimpleFile.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) 1999-2009 Soeren Sonnenburg
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef __SIMPLEFILE_H__
#define __SIMPLEFILE_H__

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

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

namespace shogun
{
template <class T> class CSimpleFile : public CSGObject
{
    public:
        CSimpleFile() :CSGObject(), line_buffer_size(1024*1024), line_buffer(NULL)
        {
            SG_UNSTABLE("CSimpleFile::CSimpleFile()", "\n")

            file=NULL;
            filename=get_strdup("");
            status = false;

            set_generic<T>();
        }

        CSimpleFile(char* fname, FILE* f)
        : CSGObject(), line_buffer_size(1024*1024), line_buffer(NULL)
        {
            file=f;
            filename=get_strdup(fname);
            status = (file!=NULL && filename!=NULL);
        }

        virtual ~CSimpleFile()
        {
            SG_FREE(filename);
            free_line_buffer();
        }

        T* load(T* target, int64_t& num)
        {
            if (status)
            {
                status=false;

                if (num==0)
                {
                    bool seek_status=true;
                    int64_t cur_pos=ftell(file);

                    if (cur_pos!=-1)
                    {
                        if (!fseek(file, 0, SEEK_END))
                        {
                            if ((num=(int64_t) ftell(file)) != -1)
                            {
                                SG_INFO("file of size %ld bytes == %ld entries detected\n", num,num/sizeof(T))
                                num/=sizeof(T);
                            }
                            else
                                seek_status=false;
                        }
                        else
                            seek_status=false;
                    }

                    if ((fseek(file,cur_pos, SEEK_SET)) == -1)
                        seek_status=false;

                    if (!seek_status)
                    {
                        SG_ERROR("filesize autodetection failed\n")
                        num=0;
                        return NULL;
                    }
                }

                if (num>0)
                {
                    if (!target)
                        target=SG_MALLOC(T, num);

                    if (target)
                    {
                        size_t num_read=fread((void*) target, sizeof(T), num, file);
                        status=((int64_t) num_read == num);

                        if (!status)
                            SG_ERROR("only %ld of %ld entries read. io error\n", (int64_t) num_read, num)
                    }
                    else
                        SG_ERROR("failed to allocate memory while trying to read %ld entries from file \"s\"\n", (int64_t) num, filename)
                }
                return target;
            }
            else
            {
                num=-1;
                return NULL;
            }
        }

        bool save(T* target, int64_t num)
        {
            if (status)
            {
                status=false;
                if (num>0)
                {
                    if (!target)
                        target=SG_MALLOC(T, num);

                    if (target)
                    {
                        status=(fwrite((void*) target, sizeof(T), num, file)==
                            (size_t) num);
                    }
                }
            }
            return status;
        }

        void get_buffered_line(char* line, uint64_t len)
        {

            /*
            if (!line_buffer)
            {
                line_buffer=SG_MALLOC(char, line_buffer_size);
                size_t num_read=fread((void*) target, sizeof(T), num, file);

                    if (target)
                    {
                        size_t num_read=fread((void*) target, sizeof(T), num, file);
                        status=((int64_t) num_read == num);

                        if (!status)
                            SG_ERROR("only %ld of %ld entries read. io error\n", (int64_t) num_read, num)
                    }
                    else
                        SG_ERROR("failed to allocate memory while trying to read %ld entries from file \"s\"\n", (int64_t) num, filename)

                        */
        }

        void free_line_buffer()
        {
            SG_FREE(line_buffer);
            line_buffer=NULL;
        }

        inline void set_line_buffer_size(int32_t bufsize)
        {
            if (bufsize<=0)
                bufsize=1024*1024;

            free_line_buffer();
            line_buffer_size=bufsize;
        }

        inline bool is_ok() { return status; }

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

    protected:
        FILE* file;
        bool status;
        char task;
        char* filename;

        int32_t line_buffer_size;
        char* line_buffer;
};
}
#endif