Set Struct Reference

#include <Set.h>

Overview

Sets.

Definition at line 55 of file Set.h.

Inheritance diagram for Set:

Properties
size_t	count
	The count of elements.
Object	object
	The superclass.
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class.
unsigned int	magic
	A header to allow introspection of Object types.

Methods
Class *	_Set (void)
	The Set archetype.
void	addObject (Set *self, const ident obj)
	Adds the specified Object to this Set.
void	addObjectsFromArray (Set *self, const Array *array)
	Adds the Objects contained in array to this Set.
void	addObjectsFromSet (Set *self, const Set *set)
	Adds the Objects contained in set to this Set.
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.
void	filter (Set *self, Predicate predicate, ident data)
	Filters this Set in place using predicate.
Set *	filteredSet (const Set *self, Predicate predicate, ident data)
	Creates a new Set with elements that pass predicate.
Set *	init (Set *self)
	Initializes this Set.
Set *	initWithArray (Set *self, const Array *array)
	Initializes this Set to contain the Objects in array.
Set *	initWithCapacity (Set *self, size_t capacity)
	Initializes this Set with the specified capacity.
Set *	initWithObjects (Set *self,...)
	Initializes this Set with the specified objects.
Set *	initWithSet (Set *self, const Set *set)
	Initializes this Set to contain the Objects in set.
Set *	mappedSet (const Set *self, Functor functor, ident data)
	Transforms the elements in this Set by functor.
ident	reduce (const Set *self, Reducer reducer, ident accumulator, ident data)
void	removeAllObjects (Set *self)
	Removes all Objects from this Set.
void	removeObject (Set *self, const ident obj)
	Removes the specified Object from this Set.
Set *	set (void)
	Returns a new Set.
Set *	setWithArray (const Array *array)
	Returns a new Set with the contents of array.
Set *	setWithCapacity (size_t capacity)
	Returns a new Set with the given capacity.
Set *	setWithObjects (ident obj,...)
	Returns a new Set containing the specified Objects.
Set *	setWithSet (const Set *set)
	Returns a new Set with the contents of set.
Methods inherited from Object
Class *	_Object (void)
	The Object archetype.
Object *	copy (const Object *self)
	Creates a shallow copy of this Object.
void	dealloc (Object *self)
	Frees all resources held by this Object.
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object.
bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object.
bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership.

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

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 669 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;
}

addObject()

void addObject	(	Set *	self,
		const ident	obj
	)

Adds the specified Object to this Set.

Parameters

self	The Set.
obj	An Object.

Definition at line 175 of file Set.c.

                                                  {
 
  addObject_resize(self);
 
  const size_t bin = HashForObject(HASH_SEED, obj) % self->capacity;
 
  Array *array = self->elements[bin];
  if (array == NULL) {
    array = self->elements[bin] = $(alloc(Array), init);
  }
 
  if ($((Array *) array, containsObject, obj) == false) {
    $(array, addObject, obj);
    self->count++;
  }
}

addObjectsFromArray()

void addObjectsFromArray	(	Set *	self,
		const Array *	array
	)

Adds the Objects contained in array to this Set.

Parameters

self	The Set.
array	An Array.

Definition at line 203 of file Set.c.

                                                               {
 
  if (array) {
    $(array, enumerate, addObjectsFromArray_enumerator, self);
  }
}

addObjectsFromSet()

void addObjectsFromSet	(	Set *	self,
		const Set *	set
	)

Adds the Objects contained in set to this Set.

Parameters

self	The Set.
set	A Set.

Definition at line 221 of file Set.c.

                                                         {
 
  if (set) {
    $(set, enumerateObjects, addObjectsFromSet_enumerator, self);
  }
}

allObjects()

Array * allObjects

(

const Set *

self

)

Parameters

self

The Set.

Returns

An Array containing all Objects in this Set.

Definition at line 239 of file Set.c.

                                          {
 
  Array *objects = $(alloc(Array), initWithCapacity, self->count);
 
  $(self, enumerateObjects, allObjects_enumerator, objects);
 
  return 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 252 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 270 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 294 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);
      }
    }
  }
}

filter()

void filter	(	Set *	self,
		Predicate	predicate,
		ident	data
	)

Filters this Set in place using predicate.

Parameters

self	The Set.
predicate	A Predicate.
data	User data.

Definition at line 314 of file Set.c.

                                                               {
 
  assert(predicate);
 
  self->count = 0;
 
  for (size_t i = 0; i < self->capacity; i++) {
 
    Array *array = self->elements[i];
    if (array) {
 
      $(array, filter, predicate, data);
 
      if (array->count == 0) {
        release(array);
        self->elements[i] = NULL;
      } else {
        self->count += array->count;
      }
    }
  }
}

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 341 of file Set.c.

                                                                          {
 
  assert(predicate);
 
  Set *set = $(alloc(Set), 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;
}

init()

Set * init

(

Set *

self

)

Initializes this Set.

Parameters

self

The Set.

Returns

The initialized Set, or NULL on error.

Definition at line 369 of file Set.c.

                            {
 
  return $(self, initWithCapacity, SET_DEFAULT_CAPACITY);
}

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 385 of file Set.c.

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

initWithCapacity()

Set * initWithCapacity	(	Set *	self,
		size_t	capacity
	)

Initializes this Set with the specified capacity.

Parameters

self	The Set.
capacity	The desired initial capacity.

Returns

The initialized Set, or NULL on error.

Definition at line 401 of file Set.c.

                                                         {
 
  self = (Set *) super(Object, self, init);
  if (self) {
 
    self->capacity = capacity;
    if (self->capacity) {
 
      self->elements = calloc(self->capacity, sizeof(ident));
      assert(self->elements);
    }
  }
 
  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 421 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) {
        $(self, addObject, 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 456 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 472 of file Set.c.

                                                                    {
 
  assert(functor);
 
  Set *set = $(alloc(Set), 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;
}

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 502 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;
}

removeAllObjects()

void removeAllObjects

(

Set *

self

)

Removes all Objects from this Set.

Parameters

self

The Set.

Definition at line 524 of file Set.c.

                                        {
 
  for (size_t i = 0; i < self->capacity; i++) {
 
    Array *array = self->elements[i];
    if (array) {
      release(array);
      self->elements[i] = NULL;
    }
  }
 
  self->count = 0;
}

removeObject()

void removeObject	(	Set *	self,
		const ident	obj
	)

Removes the specified Object from this Set.

Parameters

self	The Set.
obj	The Object to remove.

Definition at line 542 of file Set.c.

                                                     {
 
  if (self->capacity == 0) {
    return;
  }
 
  const size_t bin = HashForObject(HASH_SEED, obj) % self->capacity;
 
  Array *array = self->elements[bin];
  if (array) {
 
    const ssize_t index = $(array, indexOfObject, obj);
    if (index > -1) {
 
      $(array, removeObjectAtIndex, index);
 
      if (((Array *) array)->count == 0) {
        release(array);
        self->elements[bin] = NULL;
      }
 
      self->count--;
    }
  }
}

set()

Set * set

(

void

)

Returns a new Set.

Returns

The new Set, or NULL on error.

Definition at line 572 of file Set.c.

                      {
 
  return $(alloc(Set), init);
}

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 581 of file Set.c.

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

setWithCapacity()

Set * setWithCapacity

(

size_t

capacity

)

Returns a new Set with the given capacity.

Parameters

capacity

The desired initial capacity.

Returns

The new Set, or NULL on error.

Definition at line 590 of file Set.c.

                                             {
 
  return $(alloc(Set), initWithCapacity, capacity);
}

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 599 of file Set.c.

                                           {
 
  Set *set = (Set *) $((Object *) alloc(Set), init);
  if (set) {
 
    va_list args;
    va_start(args, obj);
 
    while (obj) {
      $(set, addObject, 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 622 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