IndexSet.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "Hash.h"
#include "IndexSet.h"
#include "MutableString.h"

Go to the source code of this file.

Macros
#define	_Class   _IndexSet

Functions
Class *	_IndexSet (void)
static size_t	compact (size_t *indexes, size_t count)
	Sorts and compacts the given array to contain only unique values. More...
static int	compare (const void *a, const void *b)
	qsort comparator for indexes. More...
static _Bool	containsIndex (const IndexSet *self, size_t index)
static Object *	copy (const Object *self)
static void	dealloc (Object *self)
static String *	description (const Object *self)
static int	hash (const Object *self)
static void	initialize (Class *clazz)
static IndexSet *	initWithIndex (IndexSet *self, size_t index)
static IndexSet *	initWithIndexes (IndexSet *self, size_t *indexes, size_t count)
static _Bool	isEqual (const Object *self, const Object *other)

Macro Definition Documentation

_Class

#define _Class   _IndexSet

Definition at line 65 of file IndexSet.c.

Function Documentation

_IndexSet()

Class * _IndexSet

(

void

)

Definition at line 218 of file IndexSet.c.

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

compact()

static size_t compact ( size_t *  indexes, size_t  count  )

static

Sorts and compacts the given array to contain only unique values.

Definition at line 46 of file IndexSet.c.

                                                     {
 
    size_t size = 0;
 
    if (count) {
        qsort(indexes, count, sizeof(size_t), compare);
 
        for (size_t i = 1; i < count; i++) {
            if (indexes[i] != indexes[size]) {
                indexes[++size] = indexes[i];
            }
        }
 
        size++;
    }
 
    return size;
}

compare()

static int compare ( const void *  a, const void *  b  )

static

qsort comparator for indexes.

Definition at line 35 of file IndexSet.c.

                                                 {
 
    const size_t sa = *(size_t *) a;
    const size_t sb = *(size_t *) b;
 
    return sa < sb ? -1 : sa > sb ? 1 : 0;
}

containsIndex()

static _Bool containsIndex ( const IndexSet *  self, size_t  index  )

static

Definition at line 155 of file IndexSet.c.

                                                               {
 
    for (size_t i = 0; i < self->count; i++) {
        if (self->indexes[i] == index) {
            return true;
        }
    }
 
    return false;
}

copy()

static Object * copy ( const Object *  self )

static

See also

Object::copy(const Object *)

Definition at line 72 of file IndexSet.c.

                                        {
 
    IndexSet *this = (IndexSet *) self;
    IndexSet *that = $(alloc(IndexSet), initWithIndexes, this->indexes, this->count);
 
    return (Object *) that;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 83 of file IndexSet.c.

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

description()

static String * description ( const Object *  self )

static

See also

Object::description(const Object *)

Definition at line 95 of file IndexSet.c.

                                               {
 
    const IndexSet *this = (IndexSet *) self;
    MutableString *desc = mstr("[");
 
    for (size_t i = 0; i < this->count; i++) {
        $(desc, appendFormat, "%d", this->indexes[i]);
        if (i < this->count - 1) {
            $(desc, appendCharacters, ", ");
        }
    }
 
    $(desc, appendCharacters, "]");
    return (String *) desc;
}

hash()

static int hash ( const Object *  self )

static

See also

Object::hash(const Object *)

Definition at line 114 of file IndexSet.c.

                                    {
 
    int hash = HASH_SEED;
 
    const IndexSet *this = (IndexSet *) self;
 
    for (size_t i = 0; i < this->count; i++) {
        hash = HashForInteger(hash, this->indexes[i]);
    }
 
    return hash;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 201 of file IndexSet.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;
 
    ((IndexSetInterface *) clazz->interface)->containsIndex = containsIndex;
    ((IndexSetInterface *) clazz->interface)->initWithIndex = initWithIndex;
    ((IndexSetInterface *) clazz->interface)->initWithIndexes = initWithIndexes;
}

initWithIndex()

static IndexSet * initWithIndex ( IndexSet *  self, size_t  index  )

static

Definition at line 170 of file IndexSet.c.

                                                             {
    return $(self, initWithIndexes, &index, 1);
}

initWithIndexes()

static IndexSet * initWithIndexes ( IndexSet *  self, size_t *  indexes, size_t  count  )

static

Definition at line 178 of file IndexSet.c.

                                                                                {
 
    self = (IndexSet *) super(Object, self, init);
    if (self) {
 
        self->count = compact(indexes, count);
        if (self->count) {
 
            self->indexes = calloc(sizeof(size_t), self->count);
            assert(self->indexes);
 
            memcpy(self->indexes, indexes, sizeof(size_t) * self->count);
        }
    }
 
    return self;
}

isEqual()

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

static

See also

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

Definition at line 130 of file IndexSet.c.

                                                              {
 
    if (super(Object, self, isEqual, other)) {
        return true;
    }
 
    if (other && $(other, isKindOfClass, _IndexSet())) {
 
        const IndexSet *this = (IndexSet *) self;
        const IndexSet *that = (IndexSet *) other;
 
        if (this->count == that->count) {
            return memcmp(this->indexes, that->indexes, this->count * sizeof(size_t)) == 0;
        }
    }
 
    return false;
}