Resource.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "MutableArray.h"
#include "Resource.h"
#include "Value.h"

Go to the source code of this file.

Macros
#define	_Class   _Resource

Functions
Class *	_Resource (void)
static void	addResourcePath (const char *path)
static void	addResourceProvider (ResourceProvider provider)
static void	dealloc (Object *self)
static void	destroy (Class *clazz)
static void	initialize (Class *clazz)
static Resource *	initWithBytes (Resource *self, const uint8_t *bytes, size_t length, const char *name)
static Resource *	initWithData (Resource *self, Data *data, const char *name)
static Resource *	initWithName (Resource *self, const char *name)
static void	removeResourcePath (const char *path)
static void	removeResourceProvider (ResourceProvider provider)
static Resource *	resourceWithName (const char *name)

Variables
static MutableArray *	_resourcePaths
static MutableArray *	_resourceProviders

Macro Definition Documentation

_Class

#define _Class   _Resource

Definition at line 34 of file Resource.c.

Function Documentation

_Resource()

Class * _Resource

(

void

)

Definition at line 241 of file Resource.c.

                       {
    static Class *clazz;
    static Once once;
 
    do_once(&once, {
        clazz = _initialize(&(const ClassDef) {
            .name = "Resource",
            .superclass = _Object(),
            .instanceSize = sizeof(Resource),
            .interfaceOffset = offsetof(Resource, interface),
            .interfaceSize = sizeof(ResourceInterface),
            .initialize = initialize,
            .destroy = destroy,
        });
    });
 
    return clazz;
}

addResourcePath()

static void addResourcePath ( const char *  path )

static

Definition at line 61 of file Resource.c.

                                              {
 
    assert(path);
    String *string = str(path);
 
    $(_resourcePaths, addObject, string);
    release(string);
}

addResourceProvider()

static void addResourceProvider ( ResourceProvider  provider )

static

Definition at line 74 of file Resource.c.

                                                           {
 
    assert(provider);
    Value *value = $(alloc(Value), initWithValue, provider);
    
    $(_resourceProviders, addObject, value);
    release(value);
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 44 of file Resource.c.

                                  {
 
    Resource *this = (Resource *) self;
 
    release(this->data);
 
    free(this->name);
 
    super(Object, self, dealloc);
}

destroy()

static void destroy ( Class *  clazz )

static

See also

Class::destroy(Class *)

Definition at line 232 of file Resource.c.

                                  {
    release(_resourcePaths);
    release(_resourceProviders);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 193 of file Resource.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
    ((ResourceInterface *) clazz->interface)->addResourcePath = addResourcePath;
    ((ResourceInterface *) clazz->interface)->addResourceProvider = addResourceProvider;
    ((ResourceInterface *) clazz->interface)->initWithBytes = initWithBytes;
    ((ResourceInterface *) clazz->interface)->initWithData = initWithData;
    ((ResourceInterface *) clazz->interface)->initWithName = initWithName;
    ((ResourceInterface *) clazz->interface)->removeResourcePath = removeResourcePath;
    ((ResourceInterface *) clazz->interface)->removeResourceProvider = removeResourceProvider;
    ((ResourceInterface *) clazz->interface)->resourceWithName = resourceWithName;
 
    _resourcePaths = $(alloc(MutableArray), init);
    assert(_resourcePaths);
 
    const char *env = getenv("OBJECTIVELY_RESOURCE_PATH");
    if (env) {
 
        String *string = $$(String, stringWithCharacters, env);
        Array *paths = $(string, componentsSeparatedByCharacters, PATH_DELIM);
 
        for (size_t i = 0; i < paths->count; i++) {
            addResourcePath(((String *) $(paths, objectAtIndex, i))->chars);
        }
 
        release(paths);
        release(string);
    }
 
    addResourcePath(".");
 
    _resourceProviders = $(alloc(MutableArray), init);
    assert(_resourceProviders);
}

initWithBytes()

static Resource * initWithBytes ( Resource *  self, const uint8_t *  bytes, size_t  length, const char *  name  )

static

Definition at line 87 of file Resource.c.

                                                                                                      {
 
    Data *data = $$(Data, dataWithBytes, bytes, length);
    self = $(self, initWithData, data, name);
 
    release(data);
    return self;
}

initWithData()

static Resource * initWithData ( Resource *  self, Data *  data, const char *  name  )

static

Definition at line 100 of file Resource.c.

                                                                            {
 
    self = (Resource *) super(Object, self, init);
    if (self) {
        assert(data);
        self->data = retain(data);
 
        assert(name);
        self->name = strdup(name);
    }
 
    return self;
}

initWithName()

static Resource * initWithName ( Resource *  self, const char *  name  )

static

Definition at line 118 of file Resource.c.

                                                                {
 
    Data *data = NULL;
 
    const Array *resourceProviders = (Array *) _resourceProviders;
    for (size_t i = 0; i < resourceProviders->count && data == NULL; i++) {
 
        const Value *value = $(resourceProviders, objectAtIndex, i);
        data = ((ResourceProvider) (value->value))(name);
    }
 
    const Array *resourcePaths = (Array *) _resourcePaths;
    for (size_t i = 0; i < resourcePaths->count && data == NULL; i++) {
 
        const String *resourcePath = $(resourcePaths, objectAtIndex, i);
        String *path = str("%s%s%s", resourcePath->chars, PATH_SEPAR, name);
 
        struct stat s;
        if (stat(path->chars, &s) == 0 && S_ISREG(s.st_mode)) {
            data = $$(Data, dataWithContentsOfFile, path->chars);
        }
 
        release(path);
    }
 
    if (data) {
        self = $(self, initWithData, data, name);
    } else {
        self = release(self);
    }
 
    release(data);
 
    return self;
}

removeResourcePath()

static void removeResourcePath ( const char *  path )

static

Definition at line 158 of file Resource.c.

                                                 {
 
    String *string = $$(String, stringWithCharacters, path);
 
    $(_resourcePaths, removeObject, string);
 
    release(string);
}

removeResourceProvider()

static void removeResourceProvider ( ResourceProvider  provider )

static

Definition at line 171 of file Resource.c.

                                                              {
 
    Value *value = $(alloc(Value), initWithValue, provider);
 
    $(_resourceProviders, removeObject, value);
 
    release(value);
}

resourceWithName()

static Resource * resourceWithName ( const char *  name )

static

Definition at line 184 of file Resource.c.

                                                    {
    return $(alloc(Resource), initWithName, name);
}

Variable Documentation

_resourcePaths

MutableArray* _resourcePaths

static

Definition at line 36 of file Resource.c.

_resourceProviders

MutableArray* _resourceProviders

static

Definition at line 37 of file Resource.c.