Resource.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "Array.h"
#include "Resource.h"
#include "Pointer.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 Array *	_resourcePaths
static Array *	_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);
  Pointer *pointer = $(alloc(Pointer), initWithPointer, provider, NULL);
 
  $(_resourceProviders, addObject, pointer);
  release(pointer);
}

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 193 of file Resource.c.

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

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 201 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(Array), 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(Array), 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 Pointer *pointer = $(resourceProviders, objectAtIndex, i);
    data = ((ResourceProvider) (pointer->pointer))(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.

                                                              {
 
  Pointer *pointer = $(alloc(Pointer), initWithPointer, provider, NULL);
 
  $(_resourceProviders, removeObject, pointer);
 
  release(pointer);
}

resourceWithName()

static Resource * resourceWithName ( const char *  name )

static

Definition at line 184 of file Resource.c.

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

Variable Documentation

_resourcePaths

Array* _resourcePaths

static

Definition at line 36 of file Resource.c.

_resourceProviders

Array* _resourceProviders

static

Definition at line 37 of file Resource.c.