URL.c File Reference

#include <assert.h>
#include <stdlib.h>
#include "String.h"
#include "Regexp.h"
#include "URL.h"

Go to the source code of this file.

Macros
#define	_Class   _URL

Functions
Class *	_URL (void)
static URL *	baseURL (const URL *self)
static Object *	copy (const Object *self)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static void	destroy (Class *clazz)
static int	hash (const Object *self)
static void	initialize (Class *clazz)
static URL *	initWithCharacters (URL *self, const char *chars)
static URL *	initWithString (URL *self, const String *string)
static bool	isEqual (const Object *self, const Object *other)
static Array *	pathComponents (const URL *self)

Variables
static Regexp *	_re

Macro Definition Documentation

_Class

#define _Class   _URL

Definition at line 31 of file URL.c.

Function Documentation

_URL()

Class * _URL

(

void

)

Definition at line 248 of file URL.c.

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

baseURL()

static URL * baseURL ( const URL *  self )

static

Definition at line 108 of file URL.c.

                                     {
 
  String *string = $(alloc(String), init);
 
  $(string, appendString, self->scheme);
  $(string, appendFormat, "://");
 
  if (self->host) {
    $(string, appendString, self->host);
  }
 
  if (self->port) {
    $(string, appendFormat, ":%u", self->port);
  }
 
  URL *baseURL = $(alloc(URL), initWithString, (String *) string);
 
  release(string);
 
  return baseURL;
}

copy()

static Object * copy ( const Object *  self )

static

See also

Object::copy(const Object *)

Definition at line 38 of file URL.c.

                                        {
 
  const URL *this = (URL *) self;
 
  return (Object *) $(alloc(URL), initWithString, this->urlString);
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 48 of file URL.c.

                                  {
 
  URL *this = (URL *) self;
 
  release(this->fragment);
  release(this->host);
  release(this->path);
  release(this->query);
  release(this->scheme);
  release(this->urlString);
 
  super(Object, self, dealloc);
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 65 of file URL.c.

                                               {
 
  const URL *this = (URL *) self;
 
  return $((Object *) this->urlString, description);
}

destroy()

static void destroy ( Class *  clazz )

static

See also

Class::destroy(Class *)

Definition at line 220 of file URL.c.

                                  {
 
  release(_re);
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *self)

Definition at line 75 of file URL.c.

                                    {
 
  const URL *this = (URL *) self;
 
  return $((Object *) this->urlString, hash);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 228 of file URL.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->copy = copy;
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
  ((ObjectInterface *) clazz->interface)->description = description;
  ((ObjectInterface *) clazz->interface)->hash = hash;
  ((ObjectInterface *) clazz->interface)->isEqual = isEqual;
 
  ((URLInterface *) clazz->interface)->baseURL = baseURL;
  ((URLInterface *) clazz->interface)->initWithCharacters = initWithCharacters;
  ((URLInterface *) clazz->interface)->initWithString = initWithString;
  ((URLInterface *) clazz->interface)->pathComponents = pathComponents;
 
  _re = re("([a-z]+)://([^:/\?]+)?(:[0-9]+)?(/[^\?#]+)?([^#]+)?(#.*)?", 0);
}

initWithCharacters()

static URL * initWithCharacters ( URL *  self, const char *  chars  )

static

Definition at line 136 of file URL.c.

                                                             {
 
  assert(chars);
 
  self = (URL *) super(Object, self, init);
  if (self) {
 
    Range *ranges;
    if ($(_re, matchesCharacters, chars, 0, &ranges)) {
 
      self->urlString = $(alloc(String), initWithCharacters, chars);
 
      Range *scheme = &ranges[1];
      Range *host = &ranges[2];
      Range *port = &ranges[3];
      Range *path = &ranges[4];
      Range *query = &ranges[5];
      Range *fragment = &ranges[6];
 
      self->scheme = $(self->urlString, substring, *scheme);
 
      if (host->location > -1) {
        self->host = $(self->urlString, substring, *host);
 
        if (port->location > -1) {
          const char *s = self->urlString->chars + port->location + 1;
          self->port = strtoul(s, NULL, 10);
        }
      }
 
      if (path->location > -1) {
        self->path = $(self->urlString, substring, *path);
      }
 
      if (query->location > -1) {
 
        query->location++;
        query->length--;
 
        self->query = $(self->urlString, substring, *query);
      }
 
      if (fragment->location > -1) {
 
        fragment->location++;
        fragment->length--;
 
        self->fragment = $(self->urlString, substring, *fragment);
      }
 
      free(ranges);
    } else {
      self = release(self);
    }
  }
 
  return self;
}

initWithString()

static URL * initWithString ( URL *  self, const String *  string  )

static

Definition at line 199 of file URL.c.

                                                            {
 
  assert(string);
 
  return $(self, initWithCharacters, string->chars);
}

isEqual()

static bool isEqual ( const Object *  self, const Object *  other  )

static

See also

Object::isEqual(const Object *, const Object *)

Definition at line 85 of file URL.c.

                                                             {
 
  if (super(Object, self, isEqual, other)) {
    return true;
  }
 
  if (other && self->clazz == other->clazz) {
 
    const URL *this = (URL *) self;
    const URL *that = (URL *) other;
 
    return $((Object *) this->urlString, isEqual, (Object *) that->urlString);
  }
 
  return false;
}

pathComponents()

static Array * pathComponents ( const URL *  self )

static

Definition at line 210 of file URL.c.

                                              {
 
  return $(self->path, componentsSeparatedByCharacters, "/");
}

Variable Documentation

_re

Regexp* _re

static

Definition at line 130 of file URL.c.