SimpleSelector.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <Objectively/Hash.h>
#include <Objectively/MutableArray.h>
#include <Objectively/String.h>
#include "SimpleSelector.h"

Go to the source code of this file.

Macros
#define	_Class   _SimpleSelector

Functions
Class *	_SimpleSelector (void)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static int	hash (const Object *self)
static void	initialize (Class *clazz)
static SimpleSelector *	initWithPattern (SimpleSelector *self, const char *pattern)
static _Bool	isEqual (const Object *self, const Object *other)
static Array *	parse (const char *sequence)
static SimpleSelectorType	simpleSelectorType (const char c)

Macro Definition Documentation

_Class

#define _Class   _SimpleSelector

Definition at line 34 of file SimpleSelector.c.

Function Documentation

_SimpleSelector()

Class * _SimpleSelector

(

void

)

Definition at line 200 of file SimpleSelector.c.

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

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 41 of file SimpleSelector.c.

                                  {
 
    SimpleSelector *this = (SimpleSelector *) self;
 
    free(this->pattern);
 
    super(Object, self, dealloc);
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 53 of file SimpleSelector.c.

                                               {
 
    const SimpleSelector *this = (SimpleSelector *) self;
 
    return str(this->pattern);
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *)

Definition at line 63 of file SimpleSelector.c.

                                    {
 
    SimpleSelector *this = (SimpleSelector *) self;
 
    return HashForCString(HASH_SEED, this->pattern);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 185 of file SimpleSelector.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
    ((ObjectInterface *) clazz->interface)->description = description;
    ((ObjectInterface *) clazz->interface)->hash = hash;
    ((ObjectInterface *) clazz->interface)->isEqual = isEqual;
 
    ((SimpleSelectorInterface *) clazz->interface)->initWithPattern = initWithPattern;
    ((SimpleSelectorInterface *) clazz->interface)->parse = parse;
}

initWithPattern()

static SimpleSelector * initWithPattern ( SimpleSelector *  self, const char *  pattern  )

static

Definition at line 96 of file SimpleSelector.c.

                                                                                  {
 
    self = (SimpleSelector *) super(Object, self, init);
    if (self) {
 
        self->pattern = strtrim(pattern);
        assert(self->pattern);
 
        assert(strlen(self->pattern));
    }
 
    return self;
}

isEqual()

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

static

See also

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

Definition at line 73 of file SimpleSelector.c.

                                                              {
 
    if (super(Object, self, isEqual, other)) {
        return true;
    }
 
    if (other && $(other, isKindOfClass, _SimpleSelector())) {
 
        const SimpleSelector *this = (SimpleSelector *) self;
        const SimpleSelector *that = (SimpleSelector *) other;
 
        return strcmp(this->pattern, that->pattern) == 0;
    }
 
    return false;
}

parse()

static Array * parse ( const char *  sequence )

static

Definition at line 134 of file SimpleSelector.c.

                                          {
 
    MutableArray *simpleSelectors = $$(MutableArray, arrayWithCapacity, 4);
    assert(simpleSelectors);
 
    if (sequence) {
 
        const char *c = sequence;
        const char *delim = sequence;
        while (*c) {
            const size_t size = strcspn(c, "*.#:");
            if (size || *c == '*') {
 
                char *pattern;
                if (*c == '*') {
                    pattern = strdup("*");
                    assert(pattern);
                } else {
                    pattern = calloc(1, size + 1);
                    assert(pattern);
 
                    strncpy(pattern, c, size);
                }
 
                SimpleSelector *simpleSelector = $(alloc(SimpleSelector), initWithPattern, pattern);
                assert(simpleSelector);
 
                simpleSelector->type = simpleSelectorType(*delim);
                assert(simpleSelector->type);
 
                delim = c + size;
 
                $(simpleSelectors, addObject, simpleSelector);
 
                release(simpleSelector);
                free(pattern);
            }
 
            c += size;
            c += strspn(c, "*.#:");
        }
    }
 
    return (Array *) simpleSelectors;
}

simpleSelectorType()

static SimpleSelectorType simpleSelectorType ( const char  c )

static

Returns

The SimpleSelectorType for the given character.

Definition at line 113 of file SimpleSelector.c.

                                                           {
    switch (c) {
        case '\0':
            return SimpleSelectorTypeNone;
        case '*':
            return SimpleSelectorTypeUniversal;
        case '#':
            return SimpleSelectorTypeId;
        case '.':
            return SimpleSelectorTypeClass;
        case ':':
            return SimpleSelectorTypePseudo;
        default:
            return SimpleSelectorTypeType;
    }
}