mirror of
https://github.com/gnustep/libs-base.git
synced 2025-05-21 04:32:03 +00:00
New version from Albin Jones, plus fixes by McCallum.
git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@948 72102866-910b-0410-8b05-ffd578937521
This commit is contained in:
Andrew McCallum
parent
b07609e467
commit
873bc50fa4
34 changed files with 1259 additions and 1292 deletions
|
|
@ -26,17 +26,19 @@
|
|||
|
||||
/**** Included Headers *******************************************************/
|
||||
|
||||
#include <Foundation/NSObject.h>
|
||||
#include <Foundation/NSString.h>
|
||||
#include <Foundation/NSArray.h>
|
||||
#include <Foundation/NSException.h>
|
||||
#include <Foundation/_NSLibfn.h>
|
||||
#include <Foundation/NSMapTable.h>
|
||||
#include <fn/map.h>
|
||||
#include <NSCallBacks.h>
|
||||
#include <Foundation/atoz.h>
|
||||
#include <objects/map.h>
|
||||
|
||||
/**** Type, Constant, and Macro Definitions **********************************/
|
||||
|
||||
/* This is for keeping track of information... */
|
||||
typedef struct _NSMT_extra NSMT_extra_t;
|
||||
typedef struct _NSMT_extra _NSMT_extra_t;
|
||||
|
||||
struct _NSMT_extra
|
||||
{
|
||||
|
|
@ -56,43 +58,43 @@ const NSMapTableKeyCallBacks NSIntMapKeyCallBacks =
|
|||
{
|
||||
(NSMT_hash_func_t) _NS_int_hash,
|
||||
(NSMT_is_equal_func_t) _NS_int_is_equal,
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) fn_null_function,
|
||||
(NSMT_retain_func_t) _NS_int_retain,
|
||||
(NSMT_release_func_t) _NS_int_release,
|
||||
(NSMT_describe_func_t) _NS_int_describe,
|
||||
(const void *) 0
|
||||
0
|
||||
};
|
||||
|
||||
const NSMapTableKeyCallBacks NSNonOwnedPointerMapKeyCallBacks =
|
||||
{
|
||||
(NSMT_hash_func_t) _NS_void_p_hash,
|
||||
(NSMT_is_equal_func_t) _NS_void_p_is_equal,
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) fn_null_function,
|
||||
(NSMT_describe_func_t) _NS_void_p_describe,
|
||||
(const void *) NULL
|
||||
(NSMT_hash_func_t) _NS_non_owned_void_p_hash,
|
||||
(NSMT_is_equal_func_t) _NS_non_owned_void_p_is_equal,
|
||||
(NSMT_retain_func_t) _NS_non_owned_void_p_retain,
|
||||
(NSMT_release_func_t) _NS_non_owned_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_non_owned_void_p_describe,
|
||||
0
|
||||
};
|
||||
|
||||
const NSMapTableKeyCallBacks NSNonOwnedPointerOrNullMapKeyCallBacks =
|
||||
{
|
||||
(NSMT_hash_func_t) _NS_void_p_hash,
|
||||
(NSMT_is_equal_func_t) _NS_void_p_is_equal,
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) fn_null_function,
|
||||
(NSMT_describe_func_t) _NS_void_p_describe,
|
||||
(NSMT_hash_func_t) _NS_non_owned_void_p_hash,
|
||||
(NSMT_is_equal_func_t) _NS_non_owned_void_p_is_equal,
|
||||
(NSMT_retain_func_t) _NS_non_owned_void_p_retain,
|
||||
(NSMT_release_func_t) _NS_non_owned_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_non_owned_void_p_describe,
|
||||
/* FIXME: Oh my. Is this really ok? I did it in a moment of
|
||||
* weakness. A fit of madness, I say! And if this is wrong, what
|
||||
* *should* it be?!? */
|
||||
(const void *) -1
|
||||
(const void *)-1
|
||||
};
|
||||
|
||||
const NSMapTableKeyCallBacks NSNonRetainedObjectMapKeyCallBacks =
|
||||
{
|
||||
(NSMT_hash_func_t) _NS_id_hash,
|
||||
(NSMT_is_equal_func_t) _NS_id_is_equal,
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) fn_null_function,
|
||||
(NSMT_describe_func_t) _NS_id_describe,
|
||||
(const void *) NULL
|
||||
(NSMT_hash_func_t) _NS_non_retained_id_hash,
|
||||
(NSMT_is_equal_func_t) _NS_non_retained_id_is_equal,
|
||||
(NSMT_retain_func_t) _NS_non_retained_id_retain,
|
||||
(NSMT_release_func_t) _NS_non_retained_id_release,
|
||||
(NSMT_describe_func_t) _NS_non_retained_id_describe,
|
||||
0
|
||||
};
|
||||
|
||||
const NSMapTableKeyCallBacks NSObjectMapKeyCallBacks =
|
||||
|
|
@ -102,31 +104,31 @@ const NSMapTableKeyCallBacks NSObjectMapKeyCallBacks =
|
|||
(NSMT_retain_func_t) _NS_id_retain,
|
||||
(NSMT_release_func_t) _NS_id_release,
|
||||
(NSMT_describe_func_t) _NS_id_describe,
|
||||
(const void *) NULL
|
||||
0
|
||||
};
|
||||
|
||||
const NSMapTableKeyCallBacks NSOwnedPointerMapKeyCallBacks =
|
||||
{
|
||||
(NSMT_hash_func_t) _NS_void_p_hash,
|
||||
(NSMT_is_equal_func_t) _NS_void_p_is_equal,
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) _NS_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_void_p_describe,
|
||||
(const void *) NULL
|
||||
(NSMT_hash_func_t) _NS_owned_void_p_hash,
|
||||
(NSMT_is_equal_func_t) _NS_owned_void_p_is_equal,
|
||||
(NSMT_retain_func_t) _NS_owned_void_p_retain,
|
||||
(NSMT_release_func_t) _NS_owned_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_owned_void_p_describe,
|
||||
0
|
||||
};
|
||||
|
||||
const NSMapTableValueCallBacks NSIntMapValueCallBacks =
|
||||
{
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) fn_null_function,
|
||||
(NSMT_retain_func_t) _NS_int_retain,
|
||||
(NSMT_release_func_t) _NS_int_release,
|
||||
(NSMT_describe_func_t) _NS_int_describe
|
||||
};
|
||||
|
||||
const NSMapTableValueCallBacks NSNonOwnedPointerMapValueCallBacks =
|
||||
{
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) fn_null_function,
|
||||
(NSMT_describe_func_t) _NS_void_p_describe
|
||||
(NSMT_retain_func_t) _NS_non_owned_void_p_retain,
|
||||
(NSMT_release_func_t) _NS_non_owned_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_non_owned_void_p_describe
|
||||
};
|
||||
|
||||
const NSMapTableValueCallBacks NSObjectMapValueCallBacks =
|
||||
|
|
@ -138,18 +140,18 @@ const NSMapTableValueCallBacks NSObjectMapValueCallBacks =
|
|||
|
||||
const NSMapTableValueCallBacks NSOwnedPointerMapValueCallBacks =
|
||||
{
|
||||
(NSMT_retain_func_t) fn_null_function,
|
||||
(NSMT_release_func_t) _NS_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_void_p_describe
|
||||
(NSMT_retain_func_t) _NS_owned_void_p_retain,
|
||||
(NSMT_release_func_t) _NS_owned_void_p_release,
|
||||
(NSMT_describe_func_t) _NS_owned_void_p_describe
|
||||
};
|
||||
|
||||
/** Macros **/
|
||||
|
||||
#define NSMT_ZONE(T) \
|
||||
((NSZone *)((fn_map_allocs((fn_map_t *)(T))).user_data))
|
||||
((NSZone *)((objects_map_allocs((objects_map_t *)(T))).user_data))
|
||||
|
||||
#define NSMT_EXTRA(T) \
|
||||
((NSMT_extra_t *)(__void_p__(fn_map_extra((fn_map_t *)(T)))))
|
||||
((_NSMT_extra_t *)(objects_map_extra((objects_map_t *)(T))))
|
||||
|
||||
#define NSMT_KEY_CALLBACKS(T) \
|
||||
((NSMT_EXTRA((T)))->keyCallBacks)
|
||||
|
|
@ -166,126 +168,118 @@ const NSMapTableValueCallBacks NSOwnedPointerMapValueCallBacks =
|
|||
/** Dummy callbacks **/
|
||||
|
||||
size_t
|
||||
_NSMT_key_hash(fn_generic_t element, void *table)
|
||||
_NSMT_key_hash (const void *element, const void *table)
|
||||
{
|
||||
return NSMT_KEY_CALLBACKS(table).hash((NSMapTable *)table,
|
||||
__void_p__(element));
|
||||
element);
|
||||
}
|
||||
|
||||
int
|
||||
_NSMT_key_compare(fn_generic_t element1,
|
||||
fn_generic_t element2,
|
||||
void *table)
|
||||
_NSMT_key_compare (const void *element1, const void *element2,
|
||||
const void *table)
|
||||
{
|
||||
return !(NSMT_KEY_CALLBACKS(table).isEqual((NSMapTable *)table,
|
||||
__void_p__(element1),
|
||||
__void_p__(element2)));
|
||||
element1,
|
||||
element2));
|
||||
}
|
||||
|
||||
int
|
||||
_NSMT_key_is_equal(fn_generic_t element1,
|
||||
fn_generic_t element2,
|
||||
void *table)
|
||||
_NSMT_key_is_equal (const void *element1, const void *element2,
|
||||
const void *table)
|
||||
{
|
||||
return NSMT_KEY_CALLBACKS(table).isEqual((NSMapTable *) table,
|
||||
__void_p__(element1),
|
||||
__void_p__(element2));
|
||||
element1,
|
||||
element2);
|
||||
}
|
||||
|
||||
fn_generic_t
|
||||
_NSMT_key_retain(fn_generic_t element, void *table)
|
||||
void *
|
||||
_NSMT_key_retain (const void *element, const void *table)
|
||||
{
|
||||
NSMT_KEY_CALLBACKS(table).retain((NSMapTable *)table,
|
||||
__void_p__(element));
|
||||
return element;
|
||||
NSMT_KEY_CALLBACKS(table).retain((NSMapTable *)table, element);
|
||||
return (void*) element;
|
||||
}
|
||||
|
||||
void
|
||||
_NSMT_key_release(fn_generic_t element, void *table)
|
||||
_NSMT_key_release (void *element, const void *table)
|
||||
{
|
||||
NSMT_KEY_CALLBACKS(table).release(table, __void_p__(element));
|
||||
NSMT_KEY_CALLBACKS(table).release ((NSMapTable*)table, element);
|
||||
return;
|
||||
}
|
||||
|
||||
fn_generic_t
|
||||
_NSMT_value_retain(fn_generic_t element, void *table)
|
||||
void *
|
||||
_NSMT_value_retain (const void *element, const void *table)
|
||||
{
|
||||
NSMT_VALUE_CALLBACKS(table).retain((NSMapTable *)table,
|
||||
__void_p__(element));
|
||||
return element;
|
||||
NSMT_VALUE_CALLBACKS(table).retain ((NSMapTable *)table, element);
|
||||
return (void*) element;
|
||||
}
|
||||
|
||||
void
|
||||
_NSMT_value_release(fn_generic_t element, void *table)
|
||||
_NSMT_value_release (void *element, const void *table)
|
||||
{
|
||||
NSMT_VALUE_CALLBACKS(table).release(table, __void_p__(element));
|
||||
NSMT_VALUE_CALLBACKS(table).release ((NSMapTable*)table, element);
|
||||
return;
|
||||
}
|
||||
|
||||
/* These are wrappers for getting at the real callbacks. */
|
||||
fn_callbacks_t _NSMT_key_callbacks =
|
||||
objects_callbacks_t _NSMT_key_callbacks =
|
||||
{
|
||||
_NSMT_key_hash,
|
||||
_NSMT_key_compare,
|
||||
_NSMT_key_is_equal,
|
||||
_NSMT_key_retain,
|
||||
_NSMT_key_release,
|
||||
(fn_describe_func_t)fn_null_function,
|
||||
0,
|
||||
0
|
||||
};
|
||||
|
||||
fn_callbacks_t
|
||||
_NSMT_callbacks_for_key_callbacks(NSMapTableKeyCallBacks keyCallBacks)
|
||||
objects_callbacks_t
|
||||
_NSMT_callbacks_for_key_callbacks (NSMapTableKeyCallBacks keyCallBacks)
|
||||
{
|
||||
fn_callbacks_t cb = _NSMT_key_callbacks;
|
||||
objects_callbacks_t cb = _NSMT_key_callbacks;
|
||||
|
||||
__void_p__(cb.not_an_item_marker) = (void *)(keyCallBacks.notAKeyMarker);
|
||||
cb.not_an_item_marker = keyCallBacks.notAKeyMarker;
|
||||
|
||||
return callbacks;
|
||||
return cb;
|
||||
}
|
||||
|
||||
fn_callbacks_t _NSMT_value_callbacks =
|
||||
objects_callbacks_t _NSMT_value_callbacks =
|
||||
{
|
||||
(fn_hash_func_t) fn_generic_hash,
|
||||
(fn_compare_func_t) fn_generic_compare,
|
||||
(fn_is_equal_func_t) fn_generic_is_equal,
|
||||
(objects_hash_func_t) objects_void_p_hash,
|
||||
(objects_compare_func_t) objects_void_p_compare,
|
||||
(objects_is_equal_func_t) objects_void_p_is_equal,
|
||||
_NSMT_value_retain,
|
||||
_NSMT_value_release,
|
||||
(fn_describe_func_t)fn_null_function,
|
||||
0,
|
||||
0
|
||||
};
|
||||
|
||||
/** Extra, extra **/
|
||||
|
||||
/* Make a copy of a hash table's callbacks. */
|
||||
fn_generic_t
|
||||
_NSMT_extra_retain(fn_generic_t g, void *table)
|
||||
void *
|
||||
_NSMT_extra_retain(const void *extra, const void *table)
|
||||
{
|
||||
/* A pointer to some space for new callbacks. */
|
||||
NSMT_extra_t *new_extra;
|
||||
_NSMT_extra_t *new_extra;
|
||||
|
||||
/* Set aside space for our new callbacks in the right zone. */
|
||||
new_extra = (NSMT_extra_t *)NSZoneMalloc(NSMT_ZONE(table),
|
||||
sizeof(NSMT_extra_t));
|
||||
new_extra = (_NSMT_extra_t *)NSZoneMalloc(NSMT_ZONE(table),
|
||||
sizeof(_NSMT_extra_t));
|
||||
|
||||
/* Copy the old callbacks into NEW_EXTRA. */
|
||||
*new_extra = *((NSMT_extra_t *)(__void_p__(g)))
|
||||
|
||||
/* Stuff NEW_EXTRA into G. */
|
||||
__void_p__(g) = new_extra;
|
||||
*new_extra = *((_NSMT_extra_t *)(extra));
|
||||
|
||||
/* Return our new EXTRA. */
|
||||
return g;
|
||||
return new_extra;
|
||||
}
|
||||
|
||||
void
|
||||
_NSMT_extra_release(fn_generic_t extra, void *table)
|
||||
_NSMT_extra_release(void *extra, const void *table)
|
||||
{
|
||||
void *ptr = __void_p__(extra);
|
||||
NSZone *zone = NSMT_ZONE(table);
|
||||
|
||||
if (ptr != NULL)
|
||||
NSZoneFree(zone, ptr);
|
||||
if (extra != 0)
|
||||
NSZoneFree(zone, extra);
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -293,14 +287,14 @@ _NSMT_extra_release(fn_generic_t extra, void *table)
|
|||
/* The idea here is that these callbacks ensure that the
|
||||
* NSMapTableCallbacks which are associated with a given NSMapTable
|
||||
* remain so throughout the life of the table and its copies. */
|
||||
fn_callbacks_t _NSMT_extra_callbacks =
|
||||
objects_callbacks_t _NSMT_extra_callbacks =
|
||||
{
|
||||
(fn_hash_func_t) fn_generic_hash,
|
||||
(fn_is_equal_func_t) fn_generic_is_equal,
|
||||
(fn_compare_func_t) fn_generic_compare,
|
||||
(objects_hash_func_t) objects_void_p_hash,
|
||||
(objects_compare_func_t) objects_void_p_compare,
|
||||
(objects_is_equal_func_t) objects_void_p_is_equal,
|
||||
_NSMT_extra_retain,
|
||||
_NSMT_extra_release,
|
||||
(fn_describe_func_t) fn_null_function,
|
||||
0,
|
||||
0
|
||||
};
|
||||
|
||||
|
|
@ -315,33 +309,38 @@ NSCreateMapTableWithZone(NSMapTableKeyCallBacks keyCallBacks,
|
|||
NSZone *zone)
|
||||
{
|
||||
NSMapTable *table;
|
||||
fn_callbacks_t key_callbacks, value_callbacks;
|
||||
fn_allocs_t alloc;
|
||||
objects_callbacks_t key_callbacks, value_callbacks;
|
||||
objects_allocs_t allocs;
|
||||
|
||||
/* Transform the callbacks we were given. */
|
||||
key_callbacks = _NSMT_callbacks_for_key_callbacks(keyCallBacks);
|
||||
value_callbacks = _NSMT_value_callbacks;
|
||||
|
||||
/* Get some useful allocs. */
|
||||
alloc = fn_allocs_for_zone(zone);
|
||||
allocs = objects_allocs_for_zone(zone);
|
||||
|
||||
/* Create a map table. */
|
||||
table = fn_map_with_allocs_with_callbacks(allocs, key_callbacks,
|
||||
value_callbacks);
|
||||
table = objects_map_with_allocs_with_callbacks(allocs, key_callbacks,
|
||||
value_callbacks);
|
||||
|
||||
/* Adjust the capacity of TABLE. */
|
||||
fn_map_resize(table, capacity);
|
||||
objects_map_resize(table, capacity);
|
||||
|
||||
if (table != NULL)
|
||||
if (table != 0)
|
||||
{
|
||||
NSMapTableExtras *extras;
|
||||
_NSMT_extra_t extra;
|
||||
|
||||
/* Set aside space for the NSMapTableExtras. */
|
||||
extras = _NSNewMapTableExtrasWithZone(zone);
|
||||
extras->keyCallBacks = keyCallBacks;
|
||||
extras->valueCallBacks = valueCallBacks;
|
||||
/* Set aside space for TABLE's extra. */
|
||||
extra.keyCallBacks = keyCallBacks;
|
||||
extra.valueCallBacks = valueCallBacks;
|
||||
|
||||
table->extras = extras;
|
||||
/* These callbacks are defined above. */
|
||||
objects_map_set_extra_callbacks(table, _NSMT_extra_callbacks);
|
||||
|
||||
/* We send a pointer because that's all the room we have.
|
||||
* The callbacks make a copy of these extras, so we needn't
|
||||
* worry about the way they disappear real soon now. */
|
||||
objects_map_set_extra(table, &extra);
|
||||
}
|
||||
|
||||
return table;
|
||||
|
|
@ -352,21 +351,18 @@ NSCreateMapTable(NSMapTableKeyCallBacks keyCallBacks,
|
|||
NSMapTableValueCallBacks valueCallBacks,
|
||||
unsigned int capacity)
|
||||
{
|
||||
return NSCreateMapTableWithZone(keyCallBacks,
|
||||
valueCallBacks,
|
||||
capacity,
|
||||
NULL);
|
||||
return NSCreateMapTableWithZone(keyCallBacks, valueCallBacks,
|
||||
capacity, 0);
|
||||
}
|
||||
|
||||
/* FIXME: CODE THIS! */
|
||||
NSMapTable *
|
||||
NSCopyMapTableWithZone(NSMapTable *table, NSZone *zone)
|
||||
{
|
||||
fn_allocs_t allocs;
|
||||
objects_allocs_t allocs;
|
||||
NSMapTable *new_table;
|
||||
|
||||
allocs = fn_allocs_for_zone(zone);
|
||||
new_table = fn_map_copy_with_allocs(table, alloc);
|
||||
allocs = objects_allocs_for_zone(zone);
|
||||
new_table = objects_map_copy_with_allocs(table, allocs);
|
||||
|
||||
return new_table;
|
||||
}
|
||||
|
|
@ -376,14 +372,14 @@ NSCopyMapTableWithZone(NSMapTable *table, NSZone *zone)
|
|||
void
|
||||
NSFreeMapTable(NSMapTable *table)
|
||||
{
|
||||
fn_map_dealloc(table);
|
||||
objects_map_dealloc(table);
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
NSResetMapTable(NSMapTable *table)
|
||||
{
|
||||
fn_map_empty(table);
|
||||
objects_map_empty(table);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -392,7 +388,7 @@ NSResetMapTable(NSMapTable *table)
|
|||
BOOL
|
||||
NSCompareMapTables(NSMapTable *table1, NSMapTable *table2)
|
||||
{
|
||||
return fn_map_is_equal_map(table1, table2) ? YES : NO;
|
||||
return objects_map_is_equal_to_map(table1, table2) ? YES : NO;
|
||||
}
|
||||
|
||||
/** Getting the number of items in an NSMapTable **/
|
||||
|
|
@ -400,7 +396,7 @@ NSCompareMapTables(NSMapTable *table1, NSMapTable *table2)
|
|||
unsigned int
|
||||
NSCountMapTable(NSMapTable *table)
|
||||
{
|
||||
return (unsigned int) fn_map_count(table);
|
||||
return (unsigned int) objects_map_count(table);
|
||||
}
|
||||
|
||||
/** Retrieving items from an NSMapTable **/
|
||||
|
|
@ -409,20 +405,10 @@ BOOL
|
|||
NSMapMember(NSMapTable *table, const void *key,
|
||||
void **originalKey, void **value)
|
||||
{
|
||||
fn_generic_t k, ok, v;
|
||||
int i;
|
||||
|
||||
/* Stuff KEY into K. */
|
||||
__void_p__(k) = key;
|
||||
|
||||
/* Check for K in TABLE. */
|
||||
i = fn_map_key_and_value(table, k, &ok, &v);
|
||||
|
||||
/* Put the `void *' facet of OK and V into ORIGINALKEY and VALUE. */
|
||||
if (originalKey != NULL)
|
||||
*originalKey = __void_p__(ok);
|
||||
if (value != NULL)
|
||||
*value = __void_p__(v);
|
||||
i = objects_map_key_and_value_at_key (table, key, originalKey, value);
|
||||
|
||||
/* Indicate our state of success. */
|
||||
return i ? YES : NO;
|
||||
|
|
@ -431,28 +417,25 @@ NSMapMember(NSMapTable *table, const void *key,
|
|||
void *
|
||||
NSMapGet(NSMapTable *table, const void *key)
|
||||
{
|
||||
return fn_map_value(table, key);
|
||||
return (void*) objects_map_value_at_key (table, key);
|
||||
}
|
||||
|
||||
NSMapEnumerator
|
||||
NSEnumerateMapTable(NSMapTable *table)
|
||||
{
|
||||
return fn_map_enumerator(table);
|
||||
return objects_map_enumerator(table);
|
||||
}
|
||||
|
||||
BOOL
|
||||
NSNextMapEnumeratorPair(NSMapEnumerator *enumerator,
|
||||
void **key, void **value)
|
||||
{
|
||||
fn_generic_t k, v;
|
||||
int i;
|
||||
|
||||
/* Get the next pair. */
|
||||
i = fn_map_enumerator_next_key_and_value(enumerator, &k, &v);
|
||||
|
||||
/* Put the `void *' facet of K and V into KEY and VALUE. */
|
||||
*key = __void_p__(k);
|
||||
*value = __void_p__(v);
|
||||
i = objects_map_enumerator_next_key_and_value (enumerator,
|
||||
(const void**)key,
|
||||
(const void**)value);
|
||||
|
||||
/* Indicate our success or failure. */
|
||||
return i ? YES : NO;
|
||||
|
|
@ -461,50 +444,41 @@ NSNextMapEnumeratorPair(NSMapEnumerator *enumerator,
|
|||
NSArray *
|
||||
NSAllMapTableKeys(NSMapTable *table)
|
||||
{
|
||||
NSArray *array;
|
||||
fn_generic_t *keys;
|
||||
id *objects;
|
||||
unsigned int count;
|
||||
NSMutableArray *keyArray;
|
||||
NSMapEnumerator enumerator;
|
||||
id key;
|
||||
|
||||
count = fn_map_count(table);
|
||||
keys = fn_map_all_keys(table);
|
||||
objects = fn_calloc(fn_set_allocs(table), count + 1, sizeof(id));
|
||||
/* Create our mutable key array. */
|
||||
keyArray = [NSMutableArray arrayWithCapacity: NSCountMapTable (table)];
|
||||
|
||||
for (i = 0; i < count; ++i)
|
||||
objects[i] = __id__(keys[i]);
|
||||
/* Get an enumerator for TABLE. */
|
||||
enumerator = NSEnumerateMapTable (table);
|
||||
|
||||
objects[i] = nil;
|
||||
|
||||
array = [[NSArray alloc] initWithObjects:objects count:count];
|
||||
|
||||
fn_free(fn_map_allocs(table), keys);
|
||||
fn_free(fn_map_allocs(table), objects);
|
||||
/* Step through TABLE... */
|
||||
while (NSNextMapEnumeratorPair (&enumerator, (void**)&key, 0))
|
||||
[keyArray addObject: key];
|
||||
|
||||
/* FIXME: Should ARRAY returned be `autorelease'd? */
|
||||
return [array autorelease];
|
||||
return [keyArray autorelease];
|
||||
}
|
||||
|
||||
NSArray *
|
||||
NSAllMapTableValues(NSMapTable *table)
|
||||
{
|
||||
NSArray *array;
|
||||
fn_generic_t *values;
|
||||
id *objects;
|
||||
unsigned int count;
|
||||
NSMutableArray *array;
|
||||
NSMapEnumerator enumerator;
|
||||
id valueArray;
|
||||
id value;
|
||||
|
||||
count = fn_map_count(table);
|
||||
values = fn_map_all_values(table);
|
||||
objects = fn_calloc(fn_set_allocs(table), count + 1, sizeof(id));
|
||||
/* Create our mutable value array. */
|
||||
valueArray = [NSMutableArray arrayWithCapacity:NSCountMapTable(table)];
|
||||
|
||||
for (i = 0; i < count; ++i)
|
||||
objects[i] = __id__(values[i]);
|
||||
/* Get an enumerator for TABLE. */
|
||||
enumerator = NSEnumerateMapTable(table);
|
||||
|
||||
objects[i] = nil;
|
||||
|
||||
array = [[NSArray alloc] initWithObjects:objects count:count];
|
||||
|
||||
fn_free(fn_map_allocs(table), keys);
|
||||
fn_free(fn_map_allocs(table), objects);
|
||||
/* Step through TABLE... */
|
||||
while (NSNextMapEnumeratorPair (&enumerator, 0, (void**)&value))
|
||||
[valueArray addObject:value];
|
||||
|
||||
/* FIXME: Should ARRAY returned be `autorelease'd? */
|
||||
return [array autorelease];
|
||||
|
|
@ -515,14 +489,8 @@ NSAllMapTableValues(NSMapTable *table)
|
|||
void
|
||||
NSMapInsert(NSMapTable *table, const void *key, const void *value)
|
||||
{
|
||||
fn_generic_t k, v;
|
||||
|
||||
/* Stuff KEY and VALUE into K and V. */
|
||||
__void_p__(k) = key;
|
||||
__void_p__(v) = value;
|
||||
|
||||
/* Put K -> V into TABLE. */
|
||||
fn_map_at_key_put_value(table, k, v);
|
||||
/* Put KEY -> VALUE into TABLE. */
|
||||
objects_map_at_key_put_value (table, key, value);
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -530,30 +498,23 @@ NSMapInsert(NSMapTable *table, const void *key, const void *value)
|
|||
void *
|
||||
NSMapInsertIfAbsent(NSMapTable *table, const void *key, const void *value)
|
||||
{
|
||||
fn_generic_t k, v, m;
|
||||
void *old_key;
|
||||
|
||||
/* Stuff KEY and VALUE into K and V. */
|
||||
__void_p__(k) = key;
|
||||
__void_p__(v) = value;
|
||||
|
||||
/* Put K -> V into TABLE. */
|
||||
m = fn_map_at_key_put_value_if_absent(table, k, v);
|
||||
|
||||
/* Return the `void *' facet of M. */
|
||||
return __void_p__(m);
|
||||
if (objects_map_contains_key (table, key))
|
||||
return (void*) objects_map_key (table, key);
|
||||
else
|
||||
{
|
||||
/* Put KEY -> VALUE into TABLE. */
|
||||
objects_map_at_key_put_value_known_absent (table, key, value);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
NSMapInsertKnownAbsent(NSMapTable *table, const void *key, const void *value)
|
||||
{
|
||||
fn_generic_t k, v;
|
||||
|
||||
/* Stuff KEY and VALUE into K and V. */
|
||||
__void_p__(k) = key;
|
||||
__void_p__(v) = value;
|
||||
|
||||
/* Is the key already in the table? */
|
||||
if (fn_map_contains_key(table, k))
|
||||
if (objects_map_contains_key(table, key))
|
||||
{
|
||||
/* Ooh. Bad. The docs say to raise an exception! */
|
||||
/* FIXME: I should make this much more informative. */
|
||||
|
|
@ -563,7 +524,7 @@ NSMapInsertKnownAbsent(NSMapTable *table, const void *key, const void *value)
|
|||
else
|
||||
{
|
||||
/* Well, we know it's not there, so... */
|
||||
fn_map_at_key_put_value_known_absent(table, k, v);
|
||||
objects_map_at_key_put_value_known_absent (table, key, value);
|
||||
}
|
||||
|
||||
/* Yah-hoo! */
|
||||
|
|
@ -575,7 +536,7 @@ NSMapInsertKnownAbsent(NSMapTable *table, const void *key, const void *value)
|
|||
void
|
||||
NSMapRemove(NSMapTable *table, const void *key)
|
||||
{
|
||||
fn_map_remove_key(table, key);
|
||||
objects_map_remove_key (table, key);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -584,14 +545,14 @@ NSMapRemove(NSMapTable *table, const void *key)
|
|||
NSString *
|
||||
NSStringFromMapTable(NSMapTable *table)
|
||||
{
|
||||
NSString *string;
|
||||
NSMutableString *string;
|
||||
NSMapEnumerator enumerator;
|
||||
NSMapTableKeyCallBacks keyCallBacks;
|
||||
NSMapTableValueCallBacks valueCallBacks;
|
||||
void *key, *value;
|
||||
|
||||
/* Get an empty mutable string. */
|
||||
string = [NSMutableString string];
|
||||
string = [NSMutableString stringWithCapacity:0];
|
||||
|
||||
/* Pull the NSMapTable...CallBacks out of the mess. */
|
||||
keyCallBacks = NSMT_KEY_CALLBACKS(table);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue