Selector.c File Reference

#include <assert.h>
#include <string.h>
#include <Objectively/Hash.h>
#include <Objectively/MutableArray.h>
#include <Objectively/MutableSet.h>
#include "Log.h"
#include "Selector.h"
#include "View.h"

Go to the source code of this file.

Data Structures
struct	Match
	A context for View matching. More...
struct	Selection
	A context for View selection. More...

Macros
#define	_Class   _Selector

Functions
static Set *	__select (View *view, Selection *selection)
	Recursively selects Views by iterating the SelectorSequences in the given Selection. More...
static _Bool	_matchesView (const View *view, Match *match)
	ViewEnumerator for matchesView. More...
static Set *	_select (const Selector *self, View *view)
Class *	_Selector (void)
static Order	compareTo (const Selector *self, const Selector *other)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static void	enumerateSelection (const Selector *self, View *view, ViewEnumerator enumerator, ident data)
static int	hash (const Object *self)
static void	initialize (Class *clazz)
static Selector *	initWithRule (Selector *self, const char *rule)
static _Bool	isEqual (const Object *self, const Object *other)
static _Bool	matchesView (const Selector *self, const View *view)
static Array *	parse (const char *rules)
static int	specificity (const Selector *selector)

Macro Definition Documentation

_Class

#define _Class   _Selector

Definition at line 35 of file Selector.c.

Function Documentation

__select()

static Set * __select ( View *  view, Selection *  selection  )

static

Recursively selects Views by iterating the SelectorSequences in the given Selection.

Definition at line 318 of file Selector.c.

                                                       {
 
    const SelectorSequence *sequence = $(selection->sequences, objectAtIndex, selection->sequence);
    
    if ($(sequence, matchesView, view)) {
 
        switch (sequence->right) {
            case SequenceCombinatorNone:
                break;
 
            case SequenceCombinatorDescendent:
                selection->sequence++;
                $(view, enumerateDescendants, (ViewEnumerator) __select, selection);
                break;
 
            case SequenceCombinatorChild:
                selection->sequence++;
                $(view, enumerateSubviews, (ViewEnumerator) __select, selection);
                break;
 
            case SequenceCombinatorSibling:
                selection->sequence++;
                $(view, enumerateSiblings, (ViewEnumerator) __select, selection);
                break;
 
            case SequenceCombinatorAdjacent:
                selection->sequence++;
                $(view, enumerateAdjacent, (ViewEnumerator) __select, selection);
                break;
 
            case SequenceCombinatorTerminal:
                $(selection->selection, addObject, view);
                break;
        }
    }
 
    $(view, enumerateSubviews, (ViewEnumerator) __select, selection);
 
    return (Set *) selection->selection;
}

_matchesView()

static _Bool _matchesView ( const View *  view, Match *  match  )

static

ViewEnumerator for matchesView.

Definition at line 217 of file Selector.c.

                                                          {
 
    const SelectorSequence *sequence = $(match->sequences, objectAtIndex, match->sequence);
 
    if ($(sequence, matchesView, view)) {
 
        switch (sequence->left) {
            case SequenceCombinatorNone:
                match->match = true;
                break;
 
            case SequenceCombinatorDescendent:
                match->sequence--;
                $(view, enumerateAncestors, (ViewEnumerator) _matchesView, match);
                break;
 
            case SequenceCombinatorChild:
                match->sequence--;
                $(view, enumerateSuperview, (ViewEnumerator) _matchesView, match);
                break;
 
            case SequenceCombinatorSibling:
                match->sequence--;
                $(view, enumerateSiblings, (ViewEnumerator) _matchesView, match);
                break;
 
            case SequenceCombinatorAdjacent:
                match->sequence--;
                $(view, enumerateAdjacent, (ViewEnumerator) _matchesView, match);
                break;
 
            case SequenceCombinatorTerminal:
                break;
        }
    }
 
    return match->match;
}

_select()

static Set * _select ( const Selector *  self, View *  view  )

static

Definition at line 364 of file Selector.c.

                                                      {
 
    assert(view);
 
    return __select(view, &(Selection) {
        .sequences = self->sequences,
        .selection = $$(MutableSet, set)
    });
}

_Selector()

Class * _Selector

(

void

)

Definition at line 398 of file Selector.c.

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

compareTo()

static Order compareTo ( const Selector *  self, const Selector *  other  )

static

Definition at line 149 of file Selector.c.

                                                                    {
 
    assert(other);
 
    if (self->specificity < other->specificity) {
        return OrderAscending;
    } else if (self->specificity > other->specificity) {
        return OrderDescending;
    }
 
    return OrderSame;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 42 of file Selector.c.

                                  {
 
    Selector *this = (Selector *) self;
 
    release(this->sequences);
    free(this->rule);
 
    super(Object, self, dealloc);
}

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 55 of file Selector.c.

                                               {
 
    const Selector *this = (Selector *) self;
 
    return str(this->rule);
}

enumerateSelection()

static void enumerateSelection ( const Selector *  self, View *  view, ViewEnumerator  enumerator, ident  data  )

static

Definition at line 166 of file Selector.c.

                                                                                                        {
 
    assert(enumerator);
 
    Set *selection = $(self, select, view);
    assert(selection);
 
    Array *array = $(selection, allObjects);
    assert(array);
 
    for (size_t i = 0; i < array->count; i++) {
        enumerator($(array, objectAtIndex, i), data);
    }
 
    release(array);
    release(selection);
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *)

Definition at line 65 of file Selector.c.

                                    {
 
    Selector *this = (Selector *) self;
 
    return HashForCString(HASH_SEED, this->rule);
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 379 of file Selector.c.

                                     {
 
    ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
    ((ObjectInterface *) clazz->interface)->description = description;
    ((ObjectInterface *) clazz->interface)->hash = hash;
    ((ObjectInterface *) clazz->interface)->isEqual = isEqual;
 
    ((SelectorInterface *) clazz->interface)->enumerateSelection = enumerateSelection;
    ((SelectorInterface *) clazz->interface)->compareTo = compareTo;
    ((SelectorInterface *) clazz->interface)->initWithRule = initWithRule;
    ((SelectorInterface *) clazz->interface)->matchesView = matchesView;
    ((SelectorInterface *) clazz->interface)->parse = parse;
    ((SelectorInterface *) clazz->interface)->select = _select;
}

initWithRule()

static Selector * initWithRule ( Selector *  self, const char *  rule  )

static

Definition at line 188 of file Selector.c.

                                                                {
 
    self = (Selector *) super(Object, self, init);
    if (self) {
 
        self->rule = strtrim(rule);
        assert(self->rule);
 
        self->sequences = $$(SelectorSequence, parse, self->rule);
        assert(self->sequences->count);
 
        self->specificity = specificity(self);
    }
 
    return self;
}

isEqual()

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

static

See also

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

Definition at line 75 of file Selector.c.

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

matchesView()

static _Bool matchesView ( const Selector *  self, const View *  view  )

static

Definition at line 260 of file Selector.c.

                                                                 {
 
    assert(view);
 
    return _matchesView(view, &(Match) {
        .sequences = self->sequences,
        .sequence = self->sequences->count - 1
    });
}

parse()

static Array * parse ( const char *  rules )

static

Definition at line 274 of file Selector.c.

                                       {
 
    MutableArray *selectors = $$(MutableArray, arrayWithCapacity, 4);
    assert(selectors);
 
    if (rules) {
 
        const char *c = rules;
        while (*c) {
            const size_t size = strcspn(c, ",");
            if (size) {
                char *rule = calloc(1, size + 1);
                assert(rule);
 
                strncpy(rule, c, size);
 
                Selector *selector = $(alloc(Selector), initWithRule, rule);
                assert(selector);
 
                $(selectors, addObject, selector);
 
                release(selector);
                free(rule);
            }
            c += size;
            c += strspn(c, ", \t\n");
        }
    }
 
    return (Array *) selectors;
}

specificity()

static int specificity ( const Selector *  selector )

static

Returns

The specificity of the given Selector.

Definition at line 97 of file Selector.c.

                                                 {
 
    int specificity = 0;
 
    for (size_t i = 0; i < selector->sequences->count; i++) {
        SelectorSequence *sequence = $(selector->sequences, objectAtIndex, i);
 
        for (size_t j = 0; j < sequence->simpleSelectors->count; j++) {
            SimpleSelector *simpleSelector = $(sequence->simpleSelectors, objectAtIndex, j);
 
            switch (simpleSelector->type) {
                case SimpleSelectorTypeId:
                    specificity += 100;
                    break;
                case SimpleSelectorTypeClass:
                case SimpleSelectorTypePseudo:
                    specificity += 10;
                    break;
                case SimpleSelectorTypeType:
                    specificity += 1;
                    Class *clazz = classForName(simpleSelector->pattern);
                    if (clazz) {
                        while (clazz) {
                            if (clazz == _View()) {
                                break;
                            }
                            specificity += 1;
                            clazz = clazz->def.superclass;
                        }
                        if (clazz != _View()) {
                            MVC_LogError("Class `%s` in Selector `%s` does not extend View\n",
                                         simpleSelector->pattern, selector->rule);
                        }
                    } else {
                        MVC_LogWarn("Class `%s` in Selector `%s` not found\n",
                                    simpleSelector->pattern, selector->rule);
                    }
 
                    break;
                default:
                    break;
            }
        }
    }
 
    return specificity;
}