---

resourcetype_raw.cpp

Go to the documentation of this file.

/*
        $Id: resourcetype_raw.cpp,v 1.1 2001/01/18 06:13:58 plasmoid 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:
                Raw resource type

*/

#include "Core/precomp.h"
#include <API/Core/Resources/resourcetype_raw.h>
#include <API/Core/System/cl_assert.h>


CL_Res_Raw::CL_Res_Raw() : CL_ResourceType("raw")
{
}

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

        if (is_raw_type || options->exists("raw"))
        {
                return new CL_RawResource(
                        name,
                        location,
                        options,
                        parent);
        }

        return NULL;
}

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

std::vector<unsigned char> *CL_Res_Raw::load(
        std::string name,
        CL_ResourceManager *manager)
{
        CL_RawResource *res = (CL_RawResource *) manager->get_resource(name);
        return res->get_value();
}

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

        value = NULL;
}

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

        value = NULL;
}

void CL_RawResource::serialize_save(CL_OutputSource *output)
{
        load_count++;
        if (value != NULL)  return; // test if already loaded.
        
        if (from_datafile) load_from_datafile();
        else load_from_file();

        for (
                std::vector<unsigned char>::iterator it=value->begin();
                it != value->end();
                it++)
        {
                output->write_uchar8(*it);
        }

        unload();
}

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

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

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

std::vector<unsigned char> *CL_RawResource::get_value()
{
        load();
        return value;
}

void CL_RawResource::load_from_datafile()
{
        value=new std::vector<unsigned char>;

        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)
                value->push_back (input->read_uchar8());

        delete input;
}

void CL_RawResource::load_from_file()
{
        value=new std::vector<unsigned char>;

        CL_InputSourceProvider *provider=CL_InputSourceProvider::create_file_provider(".");
        cl_assert ( provider != NULL );

        CL_InputSource *input=provider->open_source(location);
        cl_assert ( input != NULL );

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

        delete input;
        delete provider;        
}

---