Set Struct Reference

#include <Set.h>

Overview

Immutable sets.

Definition at line 55 of file Set.h.

Inheritance diagram for Set:

Properties
size_t	count
	The count of elements. More...
Object	object
	The superclass. More...
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class. More...

Methods
Class *	_Set (void)
	The Set archetype. More...
Array *	allObjects (const Set *self)
_Bool	containsObject (const Set *self, const ident obj)
_Bool	containsObjectMatching (const Set *self, Predicate predicate, ident data)
void	enumerateObjects (const Set *self, SetEnumerator enumerator, ident data)
	Enumerate the elements of this Set with the given function. More...
Set *	filteredSet (const Set *self, Predicate predicate, ident data)
	Creates a new Set with elements that pass predicate. More...
Set *	initWithArray (Set *self, const Array *array)
	Initializes this Set to contain the Objects in array. More...
Set *	initWithObjects (Set *self,...)
	Initializes this Set with the specified objects. More...
Set *	initWithSet (Set *self, const Set *set)
	Initializes this Set to contain the Objects in set. More...
Set *	mappedSet (const Set *self, Functor functor, ident data)
	Transforms the elements in this Set by functor. More...
MutableSet *	mutableCopy (const Set *self)
ident	reduce (const Set *self, Reducer reducer, ident accumulator, ident data)
Set *	setWithArray (const Array *array)
	Returns a new Set with the contents of array. More...
Set *	setWithObjects (ident obj,...)
	Returns a new Set containing the specified Objects. More...
Set *	setWithSet (const Set *set)
	Returns a new Set with the contents of set. More...
Methods inherited from Object
Class *	_Object (void)
	The Object archetype. More...
Object *	copy (const Object *self)
	Creates a shallow copy of this Object. More...
void	dealloc (Object *self)
	Frees all resources held by this Object. More...
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object. More...
_Bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object. More...
_Bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership. More...

Protected Attributes
SetInterface *	interface
	The interface. More...
Protected Attributes inherited from Object
ObjectInterface *	interface
	The interface. More...

Property Details

count

size_t Set::count

The count of elements.

Definition at line 77 of file Set.h.

interface

SetInterface* Set::interface

protected

The interface.

Definition at line 66 of file Set.h.

object

Object Set::object

The superclass.

Definition at line 60 of file Set.h.

Method Details

_Set()

Class * _Set

(

void

)

The Set archetype.

Returns

The Set Class.

Definition at line 454 of file Set.c.

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

allObjects()

Array * allObjects

(

const Set *

self

)

Parameters

self

The Set.

Returns

An Array containing all Objects in this Set.

Definition at line 142 of file Set.c.

                                          {
 
    MutableArray *objects = $(alloc(MutableArray), initWithCapacity, self->count);
 
    $(self, enumerateObjects, allObjects_enumerator, objects);
 
    return (Array *) objects;
}

containsObject()

_Bool containsObject	(	const Set *	self,
		const ident	obj
	)

Parameters

self	The Set.
obj	The Object to check.

Returns

true if this Set contains the given Object, false otherwise.

Definition at line 155 of file Set.c.

                                                              {
 
    if (self->capacity) {
        const size_t bin = HashForObject(HASH_SEED, obj) % self->capacity;
 
        const Array *array = self->elements[bin];
        if (array) {
            return $(array, containsObject, obj);
        }
    }
 
    return false;
}

containsObjectMatching()

_Bool containsObjectMatching	(	const Set *	self,
		Predicate	predicate,
		ident	data
	)

Parameters

self	The Set.
predicate	The predicate function.
data	User data.

Returns

true if this Set contains an Object matching predicate, false otherwise.

Definition at line 173 of file Set.c.

                                                                                      {
 
    assert(predicate);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j++) {
                if (predicate($(array, objectAtIndex, j), data)) {
                    return true;
                }
            }
        }
    }
 
    return false;
}

enumerateObjects()

void enumerateObjects	(	const Set *	self,
		SetEnumerator	enumerator,
		ident	data
	)

Enumerate the elements of this Set with the given function.

Parameters

self	The Set.
enumerator	The enumerator function.
data	User data.

Remarks

The enumerator should return true to break the iteration.

Definition at line 197 of file Set.c.

                                                                                    {
 
    assert(enumerator);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j++) {
                enumerator(self, $(array, objectAtIndex, j), data);
            }
        }
    }
}

filteredSet()

Set * filteredSet	(	const Set *	self,
		Predicate	predicate,
		ident	data
	)

Creates a new Set with elements that pass predicate.

Parameters

self	The Set.
predicate	The predicate function.
data	User data.

Returns

The new, filtered Set.

Definition at line 217 of file Set.c.

                                                                          {
 
    assert(predicate);
 
    MutableSet *set = $(alloc(MutableSet), init);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j++) {
                ident obj = $(array, objectAtIndex, j);
 
                if (predicate(obj, data)) {
                    $(set, addObject, obj);
                }
            }
        }
    }
 
    return (Set *) set;
}

initWithArray()

Set * initWithArray	(	Set *	self,
		const Array *	array
	)

Initializes this Set to contain the Objects in array.

Parameters

self	The Set.
array	An Array.

Returns

The initialized Set, or NULL on error.

Definition at line 252 of file Set.c.

                                                         {
 
    self = (Set *) super(Object, self, init);
    if (self) {
        if (array) {
            $(array, enumerateObjects, initWithArray_enumerator, self);
        }
    }
 
    return self;
}

initWithObjects()

Set * initWithObjects	(	Set *	self,
			...
	)

Initializes this Set with the specified objects.

Parameters

self

The Set.

Returns

The initialized Set, or NULL on error.

Definition at line 268 of file Set.c.

                                            {
 
    self = (Set *) super(Object, self, init);
    if (self) {
 
        va_list args;
        va_start(args, self);
 
        while (true) {
 
            ident obj = va_arg(args, ident);
            if (obj) {
                $$(MutableSet, addObject, (MutableSet *) self, obj);
            } else {
                break;
            }
        }
 
        va_end(args);
    }
 
    return self;
}

initWithSet()

Set * initWithSet	(	Set *	self,
		const Set *	set
	)

Initializes this Set to contain the Objects in set.

Parameters

self	The Set.
set	A Set.

Returns

The initialized Set, or NULL on error.

Definition at line 303 of file Set.c.

                                                   {
 
    self = (Set *) super(Object, self, init);
    if (self) {
        if (set) {
            $(set, enumerateObjects, initWithSet_enumerator, self);
        }
    }
 
    return self;
}

mappedSet()

Set * mappedSet	(	const Set *	self,
		Functor	functor,
		ident	data
	)

Transforms the elements in this Set by functor.

Parameters

self	The Set.
functor	The Functor.
data	User data.

Returns

A Set containing the transformed elements of this Set.

Definition at line 319 of file Set.c.

                                                                    {
 
    assert(functor);
 
    MutableSet *set = $(alloc(MutableSet), initWithCapacity, self->count);
    assert(set);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        const Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j++) {
 
                ident obj = functor(array->elements[j], data);
 
                $(set, addObject, obj);
 
                release(obj);
            }
        }
    }
 
    return (Set *) set;
}

mutableCopy()

MutableSet * mutableCopy

(

const Set *

self

)

Parameters

self

The Set.

Returns

A MutableSet with the contents of this Set.

Definition at line 349 of file Set.c.

                                                {
 
    MutableSet *copy = $(alloc(MutableSet), initWithCapacity, self->count);
    assert(copy);
 
    $(copy, addObjectsFromSet, self);
    return copy;
}

reduce()

ident reduce	(	const Set *	self,
		Reducer	reducer,
		ident	accumulator,
		ident	data
	)

Parameters

self	The Set.
reducer	The Reducer.
accumulator	The initial accumulator value.
data	User data.

Returns

The reduction result.

Definition at line 362 of file Set.c.

                                                                                     {
 
    assert(reducer);
 
    for (size_t i = 0; i < self->capacity; i++) {
 
        const Array *array = self->elements[i];
        if (array) {
 
            for (size_t j = 0; j < array->count; j++) {
                accumulator = reducer(array->elements[j], accumulator, data);
            }
        }
    }
 
    return accumulator;
}

setWithArray()

Set * setWithArray

(

const Array *

array

)

Returns a new Set with the contents of array.

Parameters

array

An Array.

Returns

The new Set, or NULL on error.

Definition at line 384 of file Set.c.

                                             {
 
    return $(alloc(Set), initWithArray, array);
}

setWithObjects()

Set * setWithObjects	(	ident	obj,
			...
	)

Returns a new Set containing the specified Objects.

Parameters

obj	A NULL-terminated list of Objects.

Returns

The new Set, or NULL on error.

Definition at line 393 of file Set.c.

                                           {
 
    Set *set = (Set *) $((Object *) alloc(Set), init);
    if (set) {
 
        va_list args;
        va_start(args, obj);
 
        while (obj) {
            $$(MutableSet, addObject, (MutableSet * ) set, obj);
            obj = va_arg(args, ident);
        }
 
        va_end(args);
    }
 
    return set;
}

setWithSet()

Set * setWithSet

(

const Set *

set

)

Returns a new Set with the contents of set.

Parameters

set

A set.

Returns

The new Set, or NULL on error.

Definition at line 416 of file Set.c.

                                       {
 
    return $(alloc(Set), initWithSet, set);
}

---

The documentation for this struct was generated from the following files:

• Sources/Objectively/Set.h
• Sources/Objectively/Set.c