source: orxonox.OLD/orxonox/branches/old.chris/src/data_tank.cc @ 3715

/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   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 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  


   ### File Specific:
   main-programmer: Christian Meyer
   co-programmer: ...
*/

#include "data_tank.h"

using namespace std;

//////////////////
// DataTank
//////////////////

DataTank::DataTank()
{
        loader = new DataLoader;
        tree = NULL;
}

DataTank::~DataTank()
{
        // free DataTree
        tree_delete();
        // free DataLoader
        if( loader) delete loader;
}

void DataTank::tree_add( void* r, char* filename, int type)
{
        DataTree *act;
        
        if( tree == NULL)
        {
                tree = (DataTree*) malloc( sizeof( DataTree));
                tree->type = type;
                memset( tree->filename, 0, MAX_FILENAME_LENGHT);
                strncpy( tree->filename, filename, MAX_FILENAME_LENGHT-1);
                tree->parent = NULL;
                tree->up = NULL;
                tree->down = NULL;
                tree->resource = r;
                return;
        }
        
        act = tree;
        while( act != NULL)
        {
                if( strcmp( act->filename, filename) > 0)
                {
                        if( act->up != NULL) act = act->up;
                        else
                        {
                                act->up = (DataTree*) malloc( sizeof( DataTree));
                                act->up->type = type;
                                memset( act->up->filename, 0, MAX_FILENAME_LENGHT);
                                strncpy( act->up->filename, filename, MAX_FILENAME_LENGHT-1);
                                act->up->parent = act;
                                act->up->up = NULL;
                                act->up->down = NULL;
                                act->up->resource = r;
                                break;
                        }
                }
                else
                {
                        if( act->down != NULL) act = act->down;
                        else
                        {
                                act->down = (DataTree*) malloc( sizeof( DataTree));
                                act->down->type = type;
                                memset( act->down->filename, 0, MAX_FILENAME_LENGHT);
                                strncpy( act->down->filename, filename, MAX_FILENAME_LENGHT-1);
                                act->down->parent = act;
                                act->down->up = NULL;
                                act->down->down = NULL;
                                act->down->resource = r;
                                break;
                        }
                }
        }
}

DataTree* DataTank::tree_find( char* file)
{
        DataTree *act;
        
        if( tree == NULL) return NULL;
        
        act = tree;
        
        while( act != NULL)
        {
                if( strcmp( act->filename, file) == 0) break;
                else if( strcmp( act->filename, file) > 0)
                        act = act->up;
                else
                        act = act->down;
        }
        
        return act;
}

DataTree* DataTank::tree_highest( DataTree* t)
{
        DataTree* act;
        
        if( t == NULL) return NULL;
        
        act = t;
        
        while( act != NULL)
        {
                if( act->up == NULL) break;
                act = act->up;
        }
        
        return act;
}

DataTree* DataTank::tree_lowest( DataTree* t)
{
        DataTree* act;
        
        if( t == NULL) return NULL;
        
        act = t;
        
        while( act != NULL)
        {
                if( act->down == NULL) break;
                act = act->down;
        }
        
        return act;
}

void DataTank::tree_remove( DataTree* rem)
{
        DataTree *rep;
        void* tempv;
        int tempi;
        char tempn[MAX_FILENAME_LENGHT];
        
        if( rem != NULL)
        {
                if( rem->up == NULL && rem->down == NULL)
                {
                                // leaf
                        if( rem->parent == NULL) tree = NULL;
                        else
                        {
                                if( rem->parent->up == rem) rem->parent->up = NULL;
                                else rem->parent->down = NULL;
                        }
                        loader->free_file( rem->resource, rem->type);
                        free( rem);
                }
                else if( rem->up != NULL && rem->down == NULL)
                {
                                // branch up
                        if( rem->parent == NULL)
                        {
                                tree = rem->up;
                                rem->up->parent = NULL;
                        }
                        else
                        {
                                if( rem->parent->up == rem) rem->parent->up = rem->up;
                                else rem->parent->down = rem->up;
                                rem->up->parent = rem->parent;
                        }
                        loader->free_file( rem->resource, rem->type);
                        free( rem);                     
                }
                else if( rem->up == NULL && rem->down != NULL)
                {
                                // branch down
                        if( rem->parent == NULL)
                        {
                                tree = rem->down;
                                rem->down->parent = NULL;
                        }
                        else
                        {
                                if( rem->parent->up == rem) rem->parent->up = rem->down;
                                else rem->parent->down = rem->down;
                                rem->down->parent = rem->parent;
                        }
                        loader->free_file( rem->resource, rem->type);
                        free( rem);                     
                }
                else
                {
                                // fork
                        // get highest from down tree
                        rep = tree_highest( rem->down);
                        
                        // swap contents
                        tempv = rep->resource;
                        tempi = rep->type;
                        strcpy( tempn, rep->filename);
                        
                        rep->resource = rem->resource;
                        rep->type = rem->type;
                        strcpy( rep->filename, rem->filename);
                        
                        rem->resource = tempv;
                        rem->type = tempi;
                        strcpy( rem->filename, tempn);
                        
                        // remove rep
                        tree_remove( rep);
                }
        }
}

void DataTank::tree_delete()
{
        DataTree *act, *kil;
        
        if( tree != NULL)
        {
                act = tree;
                while( act != NULL)
                {
                        if( act->up != NULL)
                        {
                                act = act->up;
                                continue;
                        }
                        if( act->down != NULL)
                        {
                                act = act->down;
                                continue;
                        }
                        kil = act;
                        act = act->parent;
                        if( act != NULL)
                        {
                                if( kil == act->up)     act->up = NULL;
                                if( kil == act->down) act->down = NULL;
                        }
                        loader->free_file( kil->resource, kil->type);
                        free( kil);
                }
        }
}

void* DataTank::get( char* file)
{
        DataTree* t;
        void* new_res;
        int type;
        
        t = tree_find( file);
        
        if( t == NULL)
        {
                type = loader->get_type( file);
                if( type == -1) return NULL;
                new_res = loader->load_file( file, type);
                if( new_res == NULL)
                {
                        // return placeholder
                        return loader->get_placeholder( type);
                }
                else
                {
                        tree_add( new_res, file, type);
                        return new_res;
                }
        }
        else
        {
                return t->resource;
        }
}

void DataTank::unload( char* file)
{
        DataTree* rem;
        
        rem = tree_find( file);
        
        tree_remove( rem);
}

void DataTank::precache( char* resfile, void(*pfunc)(int, float, char*))
{
        FILE* source;
        int total, done;
        char file[256];
        char* s;
        
        source = fopen( resfile, "r");
        if( source == NULL) return;
        
        total = done = 0;
        
        while( !feof( source))
        {
                fgets( file, 256, source);
                if( (s = strchr( file, '\n')) != NULL) *s = 0;
                if( strlen( file) > 1) total++;
        }
        
        rewind( source);
        
        while( !feof( source))
        {
                fgets( file, 256, source);
                if( (s = strchr( file, '\n')) != NULL) *s = 0;
                if( strlen( file) > 1)
                {
                        if( pfunc) pfunc( total, ((float)done)/((float)total), file);
                        get( file);
                        done++;
                }
        }
        
        fclose( source);
}

void DataTank::save_precache( char* filename)
{
        FILE* out;
        
        out = fopen( filename, "w");
        if( out == NULL) return;
        
        if( tree != NULL) save_node( tree, out);
        
        fclose( out);
}

void DataTank::save_node( DataTree* act, FILE* out)
{
        fprintf(out, "%s\n", act->filename);
        
        if( act->down) save_node( act->down, out);
        if( act->up) save_node( act->up, out);
        
        return;
}

int DataTank::add_filetype( char* postfix, void*(*lfunc)(char*), void(*ffunc)(void*), char* placeholderfile)
{
        return loader->add_filetype( postfix, lfunc, ffunc, placeholderfile);
}

////////////////
// DataLoader
////////////////

DataLoader::DataLoader()
{
        ntypes = 0;
        load_funcs = NULL;
        free_funcs = NULL;
        postfixes = NULL;
        placeholders = NULL;
}

DataLoader::~DataLoader()
{
        int i;
        
        for( i = 0; i < ntypes; i++)
        {
                if( placeholders[i] != NULL) free_funcs[i]( placeholders[i]);
                if( postfixes[i] != NULL) free( postfixes[i]);
        }
        
        if( postfixes) free( postfixes);
        if( placeholders) free( placeholders);
        if( free_funcs) free( free_funcs);
        if( load_funcs) free( load_funcs);
}

int DataLoader::add_filetype( char* postfix, void*(*lfunc)(char*), void(*ffunc)(void*), char* placeholderfile)
{
        int type = 0;
        char testfile[MAX_FILENAME_LENGHT];

        if( !postfix || !lfunc || !ffunc || !placeholderfile) return -1;

        sprintf( testfile, "blabla.%s", postfix);
        if( (type = get_type( testfile)) != -1)
        {
                load_funcs[type] = lfunc;
                free_funcs[type] = ffunc;
                placeholders[type] = lfunc( placeholderfile);
                return type;
        }
        
        // backup
        void*(**old_load_funcs)(char*) = load_funcs;
        void(**old_free_funcs)(void*) = free_funcs;
        char** old_postfixes = postfixes;
        void** old_placeholders = placeholders;

        // realloc
        load_funcs = (void*(**)(char*)) malloc( sizeof( void*(*)(char*)) * (ntypes + 1));
        free_funcs = (void(**)(void*)) malloc( sizeof( void(*)(void*)) * (ntypes + 1));
        postfixes = (char**) malloc( sizeof( char*) * (ntypes + 1));
        placeholders = (void**) malloc( sizeof( void*) * (ntypes + 1));
        
        // copy
        memcpy( load_funcs, old_load_funcs, sizeof( void*(*)(char*)) * ntypes);
        memcpy( free_funcs, old_free_funcs, sizeof( void(*)(void*)) * ntypes);
        memcpy( postfixes, old_postfixes, sizeof( char*) * ntypes);
        memcpy( placeholders, old_placeholders, sizeof( void*) * ntypes);
        
        // free
        free( old_load_funcs);
        free( old_free_funcs);
        free( old_postfixes);
        free( old_placeholders);
        
        // add
        type = ntypes;
        ntypes++;
        
        load_funcs[type] = lfunc;
        free_funcs[type] = ffunc;
        postfixes[type] = (char*) malloc( sizeof( char) * POSTFIX_LENGHT);
        memset( postfixes[type], 0, POSTFIX_LENGHT);
        strncpy( postfixes[type], postfix, POSTFIX_LENGHT);
        placeholders[type] = lfunc( placeholderfile);
        
        return type;
}

void* DataLoader::load_file( char* file, int type)
{
        if( type <= ntypes && type >= 0) return load_funcs[type]( file);
        else return NULL;
}

int DataLoader::get_type( char* file)
{
        int i, n;
        char* posterior;
        
        if( file == NULL) return -1;
        
        i = 0;
        n = -1;
        while( file[i] != 0)
        {
                if( file[i] == '.') n = i;
                i++;
        }
        
        if( n == -1) return -1;
        
        posterior = &(file[n]);
        
        for( i = 0; i < ntypes; i++)
        {
                if( strcmp( posterior, postfixes[i]) == 0) return i;
        }
        
        return -1;
}

void DataLoader::free_file( void* resource, int type)
{
        if( type <= ntypes && type >= 0) free_funcs[type]( resource);
}

void* DataLoader::get_placeholder( int type)
{
        if( type <= ntypes && type >= 0) return placeholders[type];
        else return NULL;
}