Selector.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <Objectively/Hash.h>
#include <Objectively/Array.h>
#include <Objectively/Set.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.
static void	__selectEnumerator (View *view, ident data)
	ViewEnumerator adapter for __select, so it may be passed to the View::enumerate* family of methods, which require the exact ViewEnumerator signature.
static bool	_matchesView (const View *view, Match *match)
	Recursive View match predicate, invoked directly by matchesView and indirectly, via _matchesViewEnumerator, by the View::enumerate* methods.
static void	_matchesViewEnumerator (View *view, ident data)
	ViewEnumerator adapter for _matchesView, so it may be passed to the View::enumerate* family of methods, which require the exact ViewEnumerator signature.
static Set *	_select (const Selector *self, View *view)
static void	_selectFirst (Selection *selection, View *view)
	Recursively selects the first View by iterating the SelectorSequences in the given Selection.
static void	_selectFirstEnumerator (View *view, ident data)
	ViewEnumerator adapter for _selectFirst, so it may be passed to the View::enumerate* family of methods, which require the exact ViewEnumerator signature. Note that _selectFirst's parameter order (Selection *, View *) is reversed from ViewEnumerator's (View *, ident); this adapter restores the correct order rather than relying on an incompatible raw cast.
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 View *	selectFirst (const Selector *self, View *view)
static int	specificity (const Selector *selector)

Macro Definition Documentation

_Class

#define _Class   _Selector

Definition at line 36 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 343 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, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorChild:
        selection->sequence++;
        $(view, enumerateSubviews, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorSibling:
        selection->sequence++;
        $(view, enumerateSiblings, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorAdjacent:
        selection->sequence++;
        $(view, enumerateAdjacent, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorTerminal:
        $(selection->selection, addObject, view);
        break;
    }
  }
 
  $(view, enumerateSubviews, __selectEnumerator, selection);
 
  return (Set *) selection->selection;
}

__selectEnumerator()

static void __selectEnumerator ( View *  view, ident  data  )

static

ViewEnumerator adapter for __select, so it may be passed to the View::enumerate* family of methods, which require the exact ViewEnumerator signature.

See also

__selectEnumerator(View *, ident)

Definition at line 387 of file Selector.c.

                                                       {
  __select(view, (Selection *) data);
}

_matchesView()

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

static

Recursive View match predicate, invoked directly by matchesView and indirectly, via _matchesViewEnumerator, by the View::enumerate* methods.

Definition at line 227 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, _matchesViewEnumerator, match);
        break;
 
      case SequenceCombinatorChild:
        match->sequence--;
        $(view, enumerateSuperview, _matchesViewEnumerator, match);
        break;
 
      case SequenceCombinatorSibling:
        match->sequence--;
        $(view, enumerateSiblings, _matchesViewEnumerator, match);
        break;
 
      case SequenceCombinatorAdjacent:
        match->sequence--;
        $(view, enumerateAdjacent, _matchesViewEnumerator, match);
        break;
 
      case SequenceCombinatorTerminal:
        break;
    }
  }
 
  return match->match;
}

_matchesViewEnumerator()

static void _matchesViewEnumerator ( View *  view, ident  data  )

static

ViewEnumerator adapter for _matchesView, so it may be passed to the View::enumerate* family of methods, which require the exact ViewEnumerator signature.

See also

_matchesViewEnumerator(View *, ident)

Definition at line 269 of file Selector.c.

                                                           {
  _matchesView(view, (Match *) data);
}

_select()

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

static

Definition at line 395 of file Selector.c.

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

_selectFirst()

static void _selectFirst ( Selection *  selection, View *  view  )

static

Recursively selects the first View by iterating the SelectorSequences in the given Selection.

Definition at line 417 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, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorChild:
        selection->sequence++;
        $(view, enumerateSubviews, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorSibling:
        selection->sequence++;
        $(view, enumerateSiblings, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorAdjacent:
        selection->sequence++;
        $(view, enumerateAdjacent, __selectEnumerator, selection);
        break;
 
      case SequenceCombinatorTerminal:
        selection->first = view;
        return;
    }
  }
 
  $(view, enumerateSubviews, _selectFirstEnumerator, selection);
}

_selectFirstEnumerator()

static void _selectFirstEnumerator ( View *  view, ident  data  )

static

ViewEnumerator adapter for _selectFirst, so it may be passed to the View::enumerate* family of methods, which require the exact ViewEnumerator signature. Note that _selectFirst's parameter order (Selection *, View *) is reversed from ViewEnumerator's (View *, ident); this adapter restores the correct order rather than relying on an incompatible raw cast.

See also

_selectFirstEnumerator(View *, ident)

Definition at line 459 of file Selector.c.

                                                           {
  _selectFirst((Selection *) data, view);
}

_Selector()

Class * _Selector

(

void

)

Definition at line 504 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 151 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 43 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 56 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 168 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 66 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 484 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;
  ((SelectorInterface *) clazz->interface)->selectFirst = selectFirst;
}

initWithRule()

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

static

Definition at line 190 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 76 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 277 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 291 of file Selector.c.

                                       {
 
  Array *selectors = $$(Array, 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;
}

selectFirst()

static View * selectFirst ( const Selector *  self, View *  view  )

static

Definition at line 467 of file Selector.c.

                                                           {
 
  assert(view);
 
  Selection selection = {
    .sequences = self->sequences,
  };
 
  _selectFirst(&selection, view);
  return selection.first;
}

specificity()

static int specificity ( const Selector *  selector )

static

Returns

The specificity of the given Selector.

Definition at line 98 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;
}