---

resourcetype_raw.h

Go to the documentation of this file.

#ifndef header_resourcetype_raw
#define header_resourcetype_raw

#include "resource_manager.h"
#include "resourcetype.h"
#include "resource.h"
#include "../System/clanstring.h"
#include "../System/error.h"
#include "../IOData/inputsource.h"
#include "../IOData/inputsource_provider.h"
#include "../../stl.h"

class CL_Res_Raw : public CL_ResourceType
//: The Raw resource is used to read raw data from a resource file.
// CL_Res_Raw allows you to store a binary file in a resource file,
// and then get the content of the binary file in an STL vector of bytes.
// This is usefull if you want to handle your own binary format without
// writting a whole ClanLib resource manager component, you just get the
// binary data and can do whatever you want with it (as long as you don't
// modify the contents of the resource of course).
// This class allows you to store anything in a resource file,
// since it does not perform any check on the stored data. For instance
// it might be a good idea to use it to store game maps or levels.
//
// The data is accessible with std::vector::begin(), 
// which returns an unsigned char *. The size (in bytes) of the data 
// can be obtained with std::vector::size(). Keep in mind that if
// you store complex classes or structs in such a buffer, it is not
// safe to do a brutal cast, for different compilers might not use
// the same memory alignments, especially if the endianess of the
// machines are different for instance. So if you store complex data,
// it is wise to write some clean and portable serialization functions.
//
{
public:
        static std::vector<unsigned char> *load(std::string res_id, CL_ResourceManager *manager );
        //: Returns a buffer containing raw data.

        CL_Res_Raw();

private:
friend CL_ResourceManager;
        virtual CL_Resource *create_from_location(
                std::string name,
                std::string location,
                CL_ResourceOptions *options,
                CL_ResourceManager *parent);

        virtual CL_Resource *create_from_serialization(
                std::string name,
                CL_ResourceManager *parent);
};

class CL_RawResource : public CL_Resource
{
public:
        CL_RawResource(
                std::string name,
                std::string location,
                CL_ResourceOptions *options,
                CL_ResourceManager *parent);

        CL_RawResource(
                std::string name,
                CL_ResourceManager *parent);
        
        std::vector<unsigned char> *get_value();

        virtual void load();
        virtual void unload();
        virtual int get_load_count() { return load_count; }
        virtual void serialize_save(CL_OutputSource *output);

private:
        void load_from_datafile();
        void load_from_file();

        std::vector<unsigned char> *value;

        CL_String location;
        CL_ResourceManager *parent;
        bool from_datafile;
        int load_count;
};

#endif

---