---

resourcetype_module.cpp

Go to the documentation of this file.

/*
        $Id: resourcetype_module.cpp,v 1.1 2001/01/30 23:34:05 mbn Exp $

        ------------------------------------------------------------------------
        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.

        ------------------------------------------------------------------------

        File purpose:
                Module resource type

*/

#include "Core/precomp.h"
#include "resourcetype_module.h"
#include "module_reader.h"
#include <API/Core/System/cl_assert.h>

CL_Res_Module::CL_Res_Module() : CL_ResourceType("module")
{
}

CL_Resource *CL_Res_Module::create_from_location(
        std::string name,
        std::string location,
        CL_ResourceOptions *options,
        CL_ResourceManager *parent)
{
        bool is_module_type = false;
        if (options->exists("type"))
        {
                if (options->get_value("type") != "module") return NULL;
                is_module_type=true;
        }

        if (is_module_type || options->exists("module"))
        {
                return new CL_ModuleResource(
                        name,
                        location,
                        options,
                        parent);
        }

        return NULL;
}

CL_Resource *CL_Res_Module::create_from_serialization(
        std::string name,
        CL_ResourceManager *parent)
{
        return new CL_ModuleResource(name, parent);
}

MODULE *CL_Res_Module::load(
        std::string name,
        CL_ResourceManager *manager)
{
        CL_ModuleResource *res = (CL_ModuleResource *) manager->get_resource(name);
        return res->get_value();
}

                                                       
CL_ModuleResource::CL_ModuleResource(
        std::string name,
        std::string location,
        CL_ResourceOptions *options,
        CL_ResourceManager *parent)
        : CL_Resource("module", name)
{
        this->location = location;
        this->parent = parent;
        from_datafile = false;
        load_count = 0;

        value = NULL;
}

CL_ModuleResource::CL_ModuleResource(
        std::string name,
        CL_ResourceManager *parent)
        : CL_Resource("module", name)
{
        location = "";
        this->parent = parent;
        from_datafile = true;
        load_count = 0;

        value = NULL;
}

void CL_ModuleResource::serialize_save(CL_OutputSource *output)
{
        load_count++;
        if (value != NULL)  return; // test if already loaded.
        
        /*
         * When we want to serialize the file, we do not load it in memory
         * with the standard loader. Instead we just do a plain copy from
         * the input to the input. This way we can garantee that the file
         * is correctly stored in the datafile for instance. And when we
         * want to load the file for good, we call the real loader.
         */
        if (from_datafile) 
        {
                CL_InputSourceProvider *provider=parent->get_resource_provider();
                cl_assert ( provider != NULL );
                CL_InputSource *input=provider->open_source(get_name().c_str());
                cl_assert ( input != NULL );
                
                unsigned int size=input->size();
                for (unsigned int i = 0; i < size; ++i)
                        output->write_uchar8 (input->read_uchar8());

                delete input;
        }
        else
        {
                CL_InputSourceProvider *provider=CL_InputSourceProvider::create_file_provider(".");
                cl_assert ( provider != NULL );
          
                CL_InputSource *input=provider->open_source(location.c_str());
                cl_assert ( input != NULL );

                unsigned int size=input->size();
                for (unsigned int i = 0; i < size; ++i)
                        output->write_uchar8 (input->read_uchar8());

                delete input;
                delete provider;
        }

        unload();
}

void CL_ModuleResource::load()
{
        load_count++;
        if (value != NULL) return; // already loaded.

        if (from_datafile) load_from_datafile();
        else load_from_file();
}

void CL_ModuleResource::unload()
{
        load_count--;
        if (load_count == 0)
        {
                delete value;
                value = NULL;
        }
}

MODULE *CL_ModuleResource::get_value()
{
        load();
        return value;
}

void CL_ModuleResource::load_from_datafile()
{

        CL_InputSourceProvider *provider=parent->get_resource_provider();
        cl_assert ( provider != NULL );
        CL_InputSource *input=provider->open_source(get_name().c_str());
        cl_assert ( input != NULL );

        MREADER *reader=new_clanlib_reader((void *) input);
        cl_assert ( reader != NULL );

        value = Player_LoadGeneric(reader,CLANLIB_READER_CHANNELS,0);

        if (value == NULL)
        {
                throw CL_Error(MikMod_strerror(MikMod_errno));
        }

        delete_clanlib_reader(reader);
        delete input;
}

void CL_ModuleResource::load_from_file()
{
        CL_InputSourceProvider *provider=CL_InputSourceProvider::create_file_provider(".");
        cl_assert ( provider != NULL );
        CL_InputSource *input=provider->open_source(location.c_str());
        cl_assert ( input != NULL );

        MREADER *reader=new_clanlib_reader((void *) input);
        cl_assert ( reader != NULL );

        value = Player_LoadGeneric(reader,CLANLIB_READER_CHANNELS,0);

        if (value == NULL)
        {
                throw CL_Error(MikMod_strerror(MikMod_errno));
        }

        delete_clanlib_reader(reader);
        delete input;
        delete provider;         
}

---