---

datafile_writer.cpp

Go to the documentation of this file.

/*
        ClanLib, the platform independent game SDK.
        This library is distributed under the GNU LIBRARY GENERAL PUBLIC
        LICENSE version 2. See COPYING for details. For a total list of
        contributers see CREDITS.

        $Id: datafile_writer.cpp,v 1.2 2000/07/15 15:45:50 starch Exp $

*/

#include "Core/precomp.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#ifdef WIN32
        #include <io.h>
#else
        #include <unistd.h>
#endif

#include "datafile_writer.h"

#ifndef WIN32
        #define OPEN_FLAGS       O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
#else
        #define OPEN_FLAGS       _O_RDWR | O_CREAT | O_TRUNC | O_BINARY, _S_IREAD | _S_IWRITE
#endif

/*********************************
 OutputSourceProvider_Datafile
*********************************/

OutputSourceProvider_Datafile::OutputSourceProvider_Datafile(const char *_filename)
{
        filename = _filename;
        datafile_fd = open(filename, OPEN_FLAGS);

        int index_pos = -1;
        write(datafile_fd, datafile_id, strlen(datafile_id));
        write(datafile_fd, &index_pos, sizeof(int));
}

OutputSourceProvider_Datafile::~OutputSourceProvider_Datafile()
{
        int index_pos = lseek(datafile_fd, 0, SEEK_CUR);
        int num_indexes = indexes.size();

        write(datafile_fd, &num_indexes, sizeof(int));

        for (
                std::list<DatafileIndex*>::iterator it = indexes.begin();
                it != indexes.end();
                it++)
        {
                int name_len = (*it)->name.get_length()+1;
                write(datafile_fd, &name_len, sizeof(short));
                write(datafile_fd, (*it)->name, name_len);
                write(datafile_fd, &(*it)->pos, sizeof(int));
                write(datafile_fd, &(*it)->size, sizeof(int));
        }

        lseek(datafile_fd, strlen(datafile_id), SEEK_SET);
        write(datafile_fd, &index_pos, sizeof(int));

        close(datafile_fd);
}

gzFile OutputSourceProvider_Datafile::create_index(const char *index)
{
        indexes.push_back(
                new DatafileIndex(
                        index,
                        lseek(datafile_fd, 0, SEEK_CUR)));
        return gzdopen(dup(datafile_fd), "w+b");
}

void OutputSourceProvider_Datafile::close_index(gzFile gz_fd, int size)
{
        gzclose(gz_fd);
//      indexes.get_last()->size = lseek(datafile_fd, 0, SEEK_CUR) - indexes.get_last()->pos;

        indexes.back()->size = size;
/*
        std::cout << "Index written:" << std::endl;
        std::cout << "  name: " << indexes.get_last()->name << std::endl;
        std::cout << "  pos: " << indexes.get_last()->pos << std::endl;
        std::cout << "  size: " << indexes.get_last()->size << std::endl;
        std::cout << std::endl;
*/
}

CL_OutputSource *OutputSourceProvider_Datafile::open_source(const char *handle)
{
        return new OutputSource_Datafile(handle, this);
}

CL_OutputSourceProvider *OutputSourceProvider_Datafile::clone()
{
        return NULL;
}

/*************************
 OutputSource_Datafile
*************************/

OutputSource_Datafile::OutputSource_Datafile(
        const char *handle,
        OutputSourceProvider_Datafile *_provider)
{
        provider = _provider;
        output_fd = provider->create_index(handle);
        pos = 0;
}

OutputSource_Datafile::~OutputSource_Datafile()
{
        provider->close_index(output_fd, pos);
}

void OutputSource_Datafile::set_system_mode()
{
        // muh
}

void OutputSource_Datafile::set_big_endian_mode()
{
        // muh
}

void OutputSource_Datafile::set_little_endian_mode()
{
        // muh
}

void OutputSource_Datafile::write_int32(int data)
{
        write(&data, sizeof(int));
}

void OutputSource_Datafile::write_uint32(unsigned int data)
{
        write(&data, sizeof(unsigned int));
}

void OutputSource_Datafile::write_short16(short data)
{
        write(&data, sizeof(short));
}

void OutputSource_Datafile::write_ushort16(unsigned short data)
{
        write(&data, sizeof(unsigned short));
}

void OutputSource_Datafile::write_char8(char data)
{
        write(&data, sizeof(char));
}

void OutputSource_Datafile::write_uchar8(unsigned char data)
{
        write(&data, sizeof(unsigned char));
}

void OutputSource_Datafile::write_float32(float data)
{
        write(&data, sizeof(float));
}

int OutputSource_Datafile::write(const void *data, int size)
{
        gzwrite(output_fd, (void *) data, size);
        pos += size;
        return size;
}

void OutputSource_Datafile::open()
{
        // muh
}

void OutputSource_Datafile::close()
{
        // muh
}

CL_OutputSource *OutputSource_Datafile::clone()
{
        return NULL;
}

int OutputSource_Datafile::tell()
{
        return pos;
}

int OutputSource_Datafile::size()
{
        return pos;
}

void OutputSource_Datafile::write_string(const char *string)
{
        int size = strlen(string)+1;
        write(&size, sizeof(int));
        write((void *) string, size);
}

/*
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#ifdef WIN32
        #include <io.h>
#else
        #include <unistd.h>
#endif
                                                        
#include "datafilewriter.h"

#ifndef WIN32
#define OPEN_FLAGS       O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
#else
#define OPEN_FLAGS       _O_RDWR | O_CREAT | O_TRUNC | O_BINARY, _S_IREAD | _S_IWRITE
#endif

CL_Datafile_Write::CL_Datafile_Write(char *_filename)
{
        filename=_filename;

        cur_index_size=0;

        char open_buffer[256];
        // Open files here
        datafile=open(filename, OPEN_FLAGS);
        
        strcpy(open_buffer, filename);
        strcat(open_buffer, "_Index");
        index=open(open_buffer, OPEN_FLAGS);

        strcpy(open_buffer, filename);
        strcat(open_buffer, "_Data");
        data=open(open_buffer, OPEN_FLAGS);

        num_indexes=0;
        index_open=false;

        init_datafile();
}

CL_Datafile_Write::~CL_Datafile_Write()
{
        finish_datafile();

        close(datafile);
        close(index);
        close(data);

        // Delete temp files...
        char open_buffer[256];
        strcpy(open_buffer, filename);
        strcat(open_buffer, "_Index");
        remove(open_buffer);

        strcpy(open_buffer, filename);
        strcat(open_buffer, "_Data");
        remove(open_buffer);
}

void CL_Datafile_Write::init_datafile()
{
        // Init index file

        write(index, datafile_id, strlen(datafile_id)+1);
}

void CL_Datafile_Write::finish_datafile()
{
        if (index_open==true)
        {
                gzclose(data_indexed);
                index_open=false;

        write(index, &cur_index_size, sizeof(int));
        }

        int end_signal=-1;
        write(index, &end_signal, sizeof(int));

        // Copy index and data together. Also, adjust the index dest values (so help me god)

        long index_size=lseek(index,0,SEEK_CUR);

        long data_size=lseek(data,0,SEEK_CUR);

        lseek(index, 0, SEEK_SET);
        lseek(data, 0, SEEK_SET);

        copy_file(datafile, index, index_size);
        copy_file(datafile, data, data_size);

        lseek(datafile, strlen(datafile_id)+1, SEEK_SET); // Skip smart-ass comment

        for (int index=0; index<num_indexes; index++)
        {
                int size_name;
                read(datafile, &size_name, sizeof(int));
                lseek(datafile, size_name, SEEK_CUR); // skip name

                long index_pos;
                read(datafile, &index_pos, sizeof(long));
                index_pos+=index_size;

                lseek(datafile, -4, SEEK_CUR); // Seek back to index_pos position
                write(datafile, &index_pos, sizeof(long));

                lseek(datafile, 4, SEEK_CUR); // Skip size information
        }
}

void CL_Datafile_Write::copy_file(int dest, int source, long len)
{
        char buffer[16*1024];

        long copy_left=len;
        long copy_done=0;
        long copy_now=16*1024;

        while (copy_left>0)
        {
                if (copy_left<copy_now) copy_now=copy_left;
                copy_done+=copy_now;
                copy_left-=copy_now;

                read(source, buffer, copy_now);
                write(dest, buffer, copy_now);
        }
}

void CL_Datafile_Write::create_index(char *index_name)
{
        if (index_open==true)
        {
                gzclose(data_indexed);
                index_open=false;

        write(index, &cur_index_size, sizeof(int));
        }

        int size_name=strlen(index_name)+1;
        long data_pos=lseek(data,0,SEEK_CUR);
        write(index, &size_name, sizeof(int));
        write(index, index_name, size_name);
        write(index, &data_pos, sizeof(long));

        index_open=true;
        data_indexed=gzdopen(dup(data), "w+b");

        num_indexes++;

        cur_index_size=0;
}

void CL_Datafile_Write::write_data(void *data, int data_size)
{
        if (index_open==false) return;

        gzwrite(data_indexed, data, data_size);
        cur_index_size += data_size;
}

gzFile CL_Datafile_Write::get_file_pointer()
{
        return data_indexed;
}
*/

---