Remove custom ObjectList header.
This commit is contained in:
Barrett17
parent
512c5c085a
commit
7f7c723e3b
|
|
@ -7,7 +7,8 @@
|
||||||
|
|
||||||
#include <String.h>
|
#include <String.h>
|
||||||
|
|
||||||
#include "ObjectList.h"
|
#include <ObjectList.h>
|
||||||
|
|
||||||
#include "Observer.h"
|
#include "Observer.h"
|
||||||
|
|
||||||
class Notifier
|
class Notifier
|
||||||
|
|
|
||||||
|
|
@ -1,872 +0,0 @@
|
||||||
/*
|
|
||||||
Open Tracker License
|
|
||||||
|
|
||||||
Terms and Conditions
|
|
||||||
|
|
||||||
Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
||||||
this software and associated documentation files (the "Software"), to deal in
|
|
||||||
the Software without restriction, including without limitation the rights to
|
|
||||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
||||||
of the Software, and to permit persons to whom the Software is furnished to do
|
|
||||||
so, subject to the following conditions:
|
|
||||||
|
|
||||||
The above copyright notice and this permission notice applies to all licensees
|
|
||||||
and shall be included in all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
||||||
BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
||||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
|
|
||||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
|
|
||||||
Except as contained in this notice, the name of Be Incorporated shall not be
|
|
||||||
used in advertising or otherwise to promote the sale, use or other dealings in
|
|
||||||
this Software without prior written authorization from Be Incorporated.
|
|
||||||
|
|
||||||
Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
|
|
||||||
of Be Incorporated in the United States and other countries. Other brand product
|
|
||||||
names are registered trademarks or trademarks of their respective holders.
|
|
||||||
All rights reserved.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/****************************************************************************
|
|
||||||
** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING **
|
|
||||||
** **
|
|
||||||
** DANGER, WILL ROBINSON! **
|
|
||||||
** **
|
|
||||||
** The interfaces contained here are part of BeOS's **
|
|
||||||
** **
|
|
||||||
** >> PRIVATE NOT FOR PUBLIC USE << **
|
|
||||||
** **
|
|
||||||
** implementation. **
|
|
||||||
** **
|
|
||||||
** These interfaces WILL CHANGE in future releases. **
|
|
||||||
** If you use them, your app WILL BREAK at some future time. **
|
|
||||||
** **
|
|
||||||
** (And yes, this does mean that binaries built from OpenTracker will not **
|
|
||||||
** be compatible with some future releases of the OS. When that happens, **
|
|
||||||
** we will provide an updated version of this file to keep compatibility.) **
|
|
||||||
** **
|
|
||||||
** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING **
|
|
||||||
****************************************************************************/
|
|
||||||
|
|
||||||
//
|
|
||||||
// ObjectList is a wrapper around BList that adds type safety,
|
|
||||||
// optional object ownership, search, insert operations, etc.
|
|
||||||
//
|
|
||||||
|
|
||||||
#ifndef __OBJECT_LIST__
|
|
||||||
#define __OBJECT_LIST__
|
|
||||||
|
|
||||||
#ifndef _BE_H
|
|
||||||
#include <List.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <SupportDefs.h>
|
|
||||||
|
|
||||||
|
|
||||||
template<class T> class BObjectList;
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
struct UnaryPredicate {
|
|
||||||
|
|
||||||
virtual int operator()(const T*) const
|
|
||||||
// virtual could be avoided here if FindBinaryInsertionIndex,
|
|
||||||
// etc. were member template functions
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
static int _unary_predicate_glue(const void* item, void* context);
|
|
||||||
|
|
||||||
friend class BObjectList<T>;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
int
|
|
||||||
UnaryPredicate<T>::_unary_predicate_glue(const void* item, void* context)
|
|
||||||
{
|
|
||||||
return ((UnaryPredicate<T> *)context)->operator()((const T*)item);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
class _PointerList_ : public BList
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
_PointerList_(const _PointerList_ &list);
|
|
||||||
_PointerList_(int32 itemsPerBlock = 20, bool owning = false);
|
|
||||||
~_PointerList_();
|
|
||||||
|
|
||||||
typedef void *(* GenericEachFunction)(void*, void*);
|
|
||||||
typedef int (* GenericCompareFunction)(const void*, const void*);
|
|
||||||
typedef int (* GenericCompareFunctionWithState)(const void*, const void*,
|
|
||||||
void*);
|
|
||||||
typedef int (* UnaryPredicateGlue)(const void*, void*);
|
|
||||||
|
|
||||||
void* EachElement(GenericEachFunction, void*);
|
|
||||||
void SortItems(GenericCompareFunction);
|
|
||||||
void SortItems(GenericCompareFunctionWithState, void* state);
|
|
||||||
void HSortItems(GenericCompareFunction);
|
|
||||||
void HSortItems(GenericCompareFunctionWithState, void* state);
|
|
||||||
|
|
||||||
void* BinarySearch(const void*, GenericCompareFunction) const;
|
|
||||||
void* BinarySearch(const void*, GenericCompareFunctionWithState, void* state) const;
|
|
||||||
|
|
||||||
int32 BinarySearchIndex(const void*, GenericCompareFunction) const;
|
|
||||||
int32 BinarySearchIndex(const void*, GenericCompareFunctionWithState, void* state) const;
|
|
||||||
int32 BinarySearchIndexByPredicate(const void*, UnaryPredicateGlue) const;
|
|
||||||
|
|
||||||
bool Owning() const;
|
|
||||||
bool ReplaceItem(int32, void*);
|
|
||||||
|
|
||||||
protected:
|
|
||||||
bool owning;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class BObjectList : private _PointerList_
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
// iteration and sorting
|
|
||||||
typedef T *(* EachFunction)(T*, void*);
|
|
||||||
typedef const T *(* ConstEachFunction)(const T*, void*);
|
|
||||||
typedef int (* CompareFunction)(const T*, const T*);
|
|
||||||
typedef int (* CompareFunctionWithState)(const T*, const T*, void* state);
|
|
||||||
|
|
||||||
BObjectList(int32 itemsPerBlock = 20, bool owning = false);
|
|
||||||
BObjectList(const BObjectList& list);
|
|
||||||
// clones list; if list is owning, makes copies of all
|
|
||||||
// the items
|
|
||||||
|
|
||||||
virtual ~BObjectList();
|
|
||||||
|
|
||||||
BObjectList& operator=(const BObjectList& list);
|
|
||||||
// clones list; if list is owning, makes copies of all
|
|
||||||
// the items
|
|
||||||
|
|
||||||
// adding and removing
|
|
||||||
// ToDo:
|
|
||||||
// change Add calls to return const item
|
|
||||||
bool AddItem(T*);
|
|
||||||
bool AddItem(T*, int32);
|
|
||||||
bool AddList(BObjectList*);
|
|
||||||
bool AddList(BObjectList*, int32);
|
|
||||||
|
|
||||||
bool RemoveItem(T*, bool deleteIfOwning = true);
|
|
||||||
// if owning, deletes the removed item
|
|
||||||
T* RemoveItemAt(int32);
|
|
||||||
// returns the removed item
|
|
||||||
|
|
||||||
void MakeEmpty();
|
|
||||||
|
|
||||||
// item access
|
|
||||||
T* ItemAt(int32) const;
|
|
||||||
|
|
||||||
bool ReplaceItem(int32 index, T*);
|
|
||||||
// if list is owning, deletes the item at <index> first
|
|
||||||
T* SwapWithItem(int32 index, T* newItem);
|
|
||||||
// same as ReplaceItem, except does not delete old item at <index>,
|
|
||||||
// returns it instead
|
|
||||||
|
|
||||||
T* FirstItem() const;
|
|
||||||
T* LastItem() const;
|
|
||||||
|
|
||||||
// misc. getters
|
|
||||||
int32 IndexOf(const T*) const;
|
|
||||||
bool HasItem(const T*) const;
|
|
||||||
bool IsEmpty() const;
|
|
||||||
int32 CountItems() const;
|
|
||||||
|
|
||||||
T* EachElement(EachFunction, void*);
|
|
||||||
const T* EachElement(ConstEachFunction, void*) const;
|
|
||||||
|
|
||||||
void SortItems(CompareFunction);
|
|
||||||
void SortItems(CompareFunctionWithState, void* state);
|
|
||||||
void HSortItems(CompareFunction);
|
|
||||||
void HSortItems(CompareFunctionWithState, void* state);
|
|
||||||
|
|
||||||
// linear search, returns first item that matches predicate
|
|
||||||
const T* FindIf(const UnaryPredicate<T> &) const;
|
|
||||||
T* FindIf(const UnaryPredicate<T> &);
|
|
||||||
|
|
||||||
// list must be sorted with CompareFunction for these to work
|
|
||||||
T* BinarySearch(const T&, CompareFunction) const;
|
|
||||||
T* BinarySearch(const T&, CompareFunctionWithState, void* state) const;
|
|
||||||
|
|
||||||
template<typename Key>
|
|
||||||
T* BinarySearchByKey(const Key& key, int (*compare)(const Key*, const T*))
|
|
||||||
const;
|
|
||||||
|
|
||||||
template<typename Key>
|
|
||||||
T* BinarySearchByKey(const Key& key,
|
|
||||||
int (*compare)(const Key*, const T*, void*), void* state) const;
|
|
||||||
|
|
||||||
int32 BinarySearchIndex(const T& item, CompareFunction compare) const;
|
|
||||||
int32 BinarySearchIndex(const T& item, CompareFunctionWithState compare,
|
|
||||||
void* state) const;
|
|
||||||
|
|
||||||
template<typename Key>
|
|
||||||
int32 BinarySearchIndexByKey(const Key& key,
|
|
||||||
int (*compare)(const Key*, const T*)) const;
|
|
||||||
|
|
||||||
// Binary insertion - list must be sorted with CompareFunction for
|
|
||||||
// these to work
|
|
||||||
|
|
||||||
// simple insert
|
|
||||||
bool BinaryInsert(T*, CompareFunction);
|
|
||||||
bool BinaryInsert(T*, CompareFunctionWithState, void* state);
|
|
||||||
bool BinaryInsert(T*, const UnaryPredicate<T> &);
|
|
||||||
|
|
||||||
// unique insert, returns false if item already in list
|
|
||||||
bool BinaryInsertUnique(T*, CompareFunction);
|
|
||||||
bool BinaryInsertUnique(T*, CompareFunctionWithState, void* state);
|
|
||||||
bool BinaryInsertUnique(T*, const UnaryPredicate<T> &);
|
|
||||||
|
|
||||||
// insert a copy of the item, returns new inserted item
|
|
||||||
T* BinaryInsertCopy(const T& copyThis, CompareFunction);
|
|
||||||
T* BinaryInsertCopy(const T& copyThis, CompareFunctionWithState, void* state);
|
|
||||||
|
|
||||||
// insert a copy of the item if not in list already
|
|
||||||
// returns new inserted item or existing item in case of a conflict
|
|
||||||
T* BinaryInsertCopyUnique(const T& copyThis, CompareFunction);
|
|
||||||
T* BinaryInsertCopyUnique(const T& copyThis, CompareFunctionWithState, void* state);
|
|
||||||
|
|
||||||
int32 FindBinaryInsertionIndex(const UnaryPredicate<T> &, bool* alreadyInList = 0) const;
|
|
||||||
// returns either the index into which a new item should be inserted
|
|
||||||
// or index of an existing item that matches the predicate
|
|
||||||
|
|
||||||
// deprecated API, will go away
|
|
||||||
BList* AsBList() {
|
|
||||||
return this;
|
|
||||||
}
|
|
||||||
const BList* AsBList() const {
|
|
||||||
return this;
|
|
||||||
}
|
|
||||||
private:
|
|
||||||
void SetItem(int32, T*);
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class Item, class Result, class Param1>
|
|
||||||
Result
|
|
||||||
WhileEachListItem(BObjectList<Item> *list, Result (Item::*func)(Param1), Param1 p1)
|
|
||||||
{
|
|
||||||
Result result = 0;
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if ((result = (list->ItemAt(index)->*func)(p1)) != 0)
|
|
||||||
break;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Result, class Param1>
|
|
||||||
Result
|
|
||||||
WhileEachListItem(BObjectList<Item> *list, Result (*func)(Item*, Param1), Param1 p1)
|
|
||||||
{
|
|
||||||
Result result = 0;
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if ((result = (*func)(list->ItemAt(index), p1)) != 0)
|
|
||||||
break;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Result, class Param1, class Param2>
|
|
||||||
Result
|
|
||||||
WhileEachListItem(BObjectList<Item> *list, Result (Item::*func)(Param1, Param2),
|
|
||||||
Param1 p1, Param2 p2)
|
|
||||||
{
|
|
||||||
Result result = 0;
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if ((result = (list->ItemAt(index)->*func)(p1, p2)) != 0)
|
|
||||||
break;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Result, class Param1, class Param2>
|
|
||||||
Result
|
|
||||||
WhileEachListItem(BObjectList<Item> *list, Result (*func)(Item*, Param1, Param2),
|
|
||||||
Param1 p1, Param2 p2)
|
|
||||||
{
|
|
||||||
Result result = 0;
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if ((result = (*func)(list->ItemAt(index), p1, p2)) != 0)
|
|
||||||
break;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Result, class Param1, class Param2, class Param3, class Param4>
|
|
||||||
Result
|
|
||||||
WhileEachListItem(BObjectList<Item> *list, Result (*func)(Item*, Param1, Param2,
|
|
||||||
Param3, Param4), Param1 p1, Param2 p2, Param3 p3, Param4 p4)
|
|
||||||
{
|
|
||||||
Result result = 0;
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if ((result = (*func)(list->ItemAt(index), p1, p2, p3, p4)) != 0)
|
|
||||||
break;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Result>
|
|
||||||
void
|
|
||||||
EachListItemIgnoreResult(BObjectList<Item> *list, Result (Item::*func)())
|
|
||||||
{
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
(list->ItemAt(index)->*func)();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Param1>
|
|
||||||
void
|
|
||||||
EachListItem(BObjectList<Item> *list, void (*func)(Item*, Param1), Param1 p1)
|
|
||||||
{
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
(func)(list->ItemAt(index), p1);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Param1, class Param2>
|
|
||||||
void
|
|
||||||
EachListItem(BObjectList<Item> *list, void (Item::*func)(Param1, Param2),
|
|
||||||
Param1 p1, Param2 p2)
|
|
||||||
{
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
(list->ItemAt(index)->*func)(p1, p2);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Param1, class Param2>
|
|
||||||
void
|
|
||||||
EachListItem(BObjectList<Item> *list, void (*func)(Item*, Param1, Param2),
|
|
||||||
Param1 p1, Param2 p2)
|
|
||||||
{
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
(func)(list->ItemAt(index), p1, p2);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Item, class Param1, class Param2, class Param3>
|
|
||||||
void
|
|
||||||
EachListItem(BObjectList<Item> *list, void (*func)(Item*, Param1, Param2,
|
|
||||||
Param3), Param1 p1, Param2 p2, Param3 p3)
|
|
||||||
{
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
(func)(list->ItemAt(index), p1, p2, p3);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class Item, class Param1, class Param2, class Param3, class Param4>
|
|
||||||
void
|
|
||||||
EachListItem(BObjectList<Item> *list, void (*func)(Item*, Param1, Param2,
|
|
||||||
Param3, Param4), Param1 p1, Param2 p2, Param3 p3, Param4 p4)
|
|
||||||
{
|
|
||||||
int32 count = list->CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
(func)(list->ItemAt(index), p1, p2, p3, p4);
|
|
||||||
}
|
|
||||||
|
|
||||||
// inline code
|
|
||||||
|
|
||||||
inline bool
|
|
||||||
_PointerList_::Owning() const
|
|
||||||
{
|
|
||||||
return owning;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BObjectList<T>::BObjectList(int32 itemsPerBlock, bool owning)
|
|
||||||
: _PointerList_(itemsPerBlock, owning)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BObjectList<T>::BObjectList(const BObjectList<T> &list)
|
|
||||||
: _PointerList_(list)
|
|
||||||
{
|
|
||||||
owning = list.owning;
|
|
||||||
if (owning) {
|
|
||||||
// make our own copies in an owning list
|
|
||||||
int32 count = list.CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++) {
|
|
||||||
T* item = list.ItemAt(index);
|
|
||||||
if (item)
|
|
||||||
item = new T(*item);
|
|
||||||
SetItem(index, item);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BObjectList<T>::~BObjectList()
|
|
||||||
{
|
|
||||||
if (Owning())
|
|
||||||
// have to nuke elements first
|
|
||||||
MakeEmpty();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BObjectList<T> &
|
|
||||||
BObjectList<T>::operator=(const BObjectList<T> &list)
|
|
||||||
{
|
|
||||||
owning = list.owning;
|
|
||||||
BObjectList<T> &result = (BObjectList<T> &)_PointerList_::operator=(list);
|
|
||||||
if (owning) {
|
|
||||||
// make our own copies in an owning list
|
|
||||||
int32 count = list.CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++) {
|
|
||||||
T* item = list.ItemAt(index);
|
|
||||||
if (item)
|
|
||||||
item = new T(*item);
|
|
||||||
SetItem(index, item);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::AddItem(T* item)
|
|
||||||
{
|
|
||||||
// need to cast to void * to make T work for const pointers
|
|
||||||
return _PointerList_::AddItem((void*)item);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::AddItem(T* item, int32 atIndex)
|
|
||||||
{
|
|
||||||
return _PointerList_::AddItem((void*)item, atIndex);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::AddList(BObjectList<T> *newItems)
|
|
||||||
{
|
|
||||||
return _PointerList_::AddList(newItems);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::AddList(BObjectList<T> *newItems, int32 atIndex)
|
|
||||||
{
|
|
||||||
return _PointerList_::AddList(newItems, atIndex);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::RemoveItem(T* item, bool deleteIfOwning)
|
|
||||||
{
|
|
||||||
bool result = _PointerList_::RemoveItem((void*)item);
|
|
||||||
|
|
||||||
if (result && Owning() && deleteIfOwning)
|
|
||||||
delete item;
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::RemoveItemAt(int32 index)
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::RemoveItem(index);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
inline T *
|
|
||||||
BObjectList<T>::ItemAt(int32 index) const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::ItemAt(index);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::ReplaceItem(int32 index, T* item)
|
|
||||||
{
|
|
||||||
if (owning)
|
|
||||||
delete ItemAt(index);
|
|
||||||
return _PointerList_::ReplaceItem(index, (void*)item);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::SwapWithItem(int32 index, T* newItem)
|
|
||||||
{
|
|
||||||
T* result = ItemAt(index);
|
|
||||||
_PointerList_::ReplaceItem(index, (void*)newItem);
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void
|
|
||||||
BObjectList<T>::SetItem(int32 index, T* newItem)
|
|
||||||
{
|
|
||||||
_PointerList_::ReplaceItem(index, (void*)newItem);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
int32
|
|
||||||
BObjectList<T>::IndexOf(const T* item) const
|
|
||||||
{
|
|
||||||
return _PointerList_::IndexOf((void*)item);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::FirstItem() const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::FirstItem();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::LastItem() const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::LastItem();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::HasItem(const T* item) const
|
|
||||||
{
|
|
||||||
return _PointerList_::HasItem((void*)item);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::IsEmpty() const
|
|
||||||
{
|
|
||||||
return _PointerList_::IsEmpty();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
int32
|
|
||||||
BObjectList<T>::CountItems() const
|
|
||||||
{
|
|
||||||
return _PointerList_::CountItems();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void
|
|
||||||
BObjectList<T>::MakeEmpty()
|
|
||||||
{
|
|
||||||
if (owning) {
|
|
||||||
int32 count = CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
delete ItemAt(index);
|
|
||||||
}
|
|
||||||
_PointerList_::MakeEmpty();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::EachElement(EachFunction func, void* params)
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::EachElement((GenericEachFunction)func, params);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
const T *
|
|
||||||
BObjectList<T>::EachElement(ConstEachFunction func, void* params) const
|
|
||||||
{
|
|
||||||
return (const T*)
|
|
||||||
const_cast<BObjectList<T> *>(this)->_PointerList_::EachElement(
|
|
||||||
(GenericEachFunction)func, params);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
const T *
|
|
||||||
BObjectList<T>::FindIf(const UnaryPredicate<T> &predicate) const
|
|
||||||
{
|
|
||||||
int32 count = CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if (predicate.operator()(ItemAt(index)) == 0)
|
|
||||||
return ItemAt(index);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::FindIf(const UnaryPredicate<T> &predicate)
|
|
||||||
{
|
|
||||||
int32 count = CountItems();
|
|
||||||
for (int32 index = 0; index < count; index++)
|
|
||||||
if (predicate.operator()(ItemAt(index)) == 0)
|
|
||||||
return ItemAt(index);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void
|
|
||||||
BObjectList<T>::SortItems(CompareFunction function)
|
|
||||||
{
|
|
||||||
_PointerList_::SortItems((GenericCompareFunction)function);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void
|
|
||||||
BObjectList<T>::SortItems(CompareFunctionWithState function, void* state)
|
|
||||||
{
|
|
||||||
_PointerList_::SortItems((GenericCompareFunctionWithState)function, state);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void
|
|
||||||
BObjectList<T>::HSortItems(CompareFunction function)
|
|
||||||
{
|
|
||||||
_PointerList_::HSortItems((GenericCompareFunction)function);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void
|
|
||||||
BObjectList<T>::HSortItems(CompareFunctionWithState function, void* state)
|
|
||||||
{
|
|
||||||
_PointerList_::HSortItems((GenericCompareFunctionWithState)function, state);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinarySearch(const T& key, CompareFunction func) const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::BinarySearch(&key,
|
|
||||||
(GenericCompareFunction)func);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinarySearch(const T& key, CompareFunctionWithState func, void* state) const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::BinarySearch(&key,
|
|
||||||
(GenericCompareFunctionWithState)func, state);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
template<typename Key>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinarySearchByKey(const Key& key,
|
|
||||||
int (*compare)(const Key*, const T*)) const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::BinarySearch(&key,
|
|
||||||
(GenericCompareFunction)compare);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
template<typename Key>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinarySearchByKey(const Key& key,
|
|
||||||
int (*compare)(const Key*, const T*, void*), void* state) const
|
|
||||||
{
|
|
||||||
return (T*)_PointerList_::BinarySearch(&key,
|
|
||||||
(GenericCompareFunctionWithState)compare, state);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
int32
|
|
||||||
BObjectList<T>::BinarySearchIndex(const T& item, CompareFunction compare) const
|
|
||||||
{
|
|
||||||
return _PointerList_::BinarySearchIndex(&item,
|
|
||||||
(GenericCompareFunction)compare);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
int32
|
|
||||||
BObjectList<T>::BinarySearchIndex(const T& item,
|
|
||||||
CompareFunctionWithState compare, void* state) const
|
|
||||||
{
|
|
||||||
return _PointerList_::BinarySearchIndex(&item,
|
|
||||||
(GenericCompareFunctionWithState)compare, state);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
template<typename Key>
|
|
||||||
int32
|
|
||||||
BObjectList<T>::BinarySearchIndexByKey(const Key& key,
|
|
||||||
int (*compare)(const Key*, const T*)) const
|
|
||||||
{
|
|
||||||
return _PointerList_::BinarySearchIndex(&key,
|
|
||||||
(GenericCompareFunction)compare);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::BinaryInsert(T* item, CompareFunction func)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(item,
|
|
||||||
(GenericCompareFunction)func);
|
|
||||||
if (index >= 0) {
|
|
||||||
// already in list, add after existing
|
|
||||||
return AddItem(item, index + 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
return AddItem(item, -index - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::BinaryInsert(T* item, CompareFunctionWithState func, void* state)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(item,
|
|
||||||
(GenericCompareFunctionWithState)func, state);
|
|
||||||
if (index >= 0) {
|
|
||||||
// already in list, add after existing
|
|
||||||
return AddItem(item, index + 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
return AddItem(item, -index - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::BinaryInsertUnique(T* item, CompareFunction func)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(item,
|
|
||||||
(GenericCompareFunction)func);
|
|
||||||
if (index >= 0)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
return AddItem(item, -index - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::BinaryInsertUnique(T* item, CompareFunctionWithState func, void* state)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(item,
|
|
||||||
(GenericCompareFunctionWithState)func, state);
|
|
||||||
if (index >= 0)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
return AddItem(item, -index - 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinaryInsertCopy(const T& copyThis, CompareFunction func)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(©This,
|
|
||||||
(GenericCompareFunction)func);
|
|
||||||
|
|
||||||
if (index >= 0)
|
|
||||||
index++;
|
|
||||||
else
|
|
||||||
index = -index - 1;
|
|
||||||
|
|
||||||
T* newItem = new T(copyThis);
|
|
||||||
AddItem(newItem, index);
|
|
||||||
return newItem;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinaryInsertCopy(const T& copyThis, CompareFunctionWithState func, void* state)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(©This,
|
|
||||||
(GenericCompareFunctionWithState)func, state);
|
|
||||||
|
|
||||||
if (index >= 0)
|
|
||||||
index++;
|
|
||||||
else
|
|
||||||
index = -index - 1;
|
|
||||||
|
|
||||||
T* newItem = new T(copyThis);
|
|
||||||
AddItem(newItem, index);
|
|
||||||
return newItem;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinaryInsertCopyUnique(const T& copyThis, CompareFunction func)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(©This,
|
|
||||||
(GenericCompareFunction)func);
|
|
||||||
if (index >= 0)
|
|
||||||
return ItemAt(index);
|
|
||||||
|
|
||||||
index = -index - 1;
|
|
||||||
T* newItem = new T(copyThis);
|
|
||||||
AddItem(newItem, index);
|
|
||||||
return newItem;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T *
|
|
||||||
BObjectList<T>::BinaryInsertCopyUnique(const T& copyThis, CompareFunctionWithState func,
|
|
||||||
void* state)
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndex(©This,
|
|
||||||
(GenericCompareFunctionWithState)func, state);
|
|
||||||
if (index >= 0)
|
|
||||||
return ItemAt(index);
|
|
||||||
|
|
||||||
index = -index - 1;
|
|
||||||
T* newItem = new T(copyThis);
|
|
||||||
AddItem(newItem, index);
|
|
||||||
return newItem;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
int32
|
|
||||||
BObjectList<T>::FindBinaryInsertionIndex(const UnaryPredicate<T> &pred, bool* alreadyInList)
|
|
||||||
const
|
|
||||||
{
|
|
||||||
int32 index = _PointerList_::BinarySearchIndexByPredicate(&pred,
|
|
||||||
(UnaryPredicateGlue)&UnaryPredicate<T>::_unary_predicate_glue);
|
|
||||||
|
|
||||||
if (alreadyInList)
|
|
||||||
*alreadyInList = index >= 0;
|
|
||||||
|
|
||||||
if (index < 0)
|
|
||||||
index = -index - 1;
|
|
||||||
|
|
||||||
return index;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::BinaryInsert(T* item, const UnaryPredicate<T> &pred)
|
|
||||||
{
|
|
||||||
return AddItem(item, FindBinaryInsertionIndex(pred));
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
bool
|
|
||||||
BObjectList<T>::BinaryInsertUnique(T* item, const UnaryPredicate<T> &pred)
|
|
||||||
{
|
|
||||||
bool alreadyInList;
|
|
||||||
int32 index = FindBinaryInsertionIndex(pred, &alreadyInList);
|
|
||||||
if (alreadyInList)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
AddItem(item, index);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif /* __OBJECT_LIST__ */
|
|
||||||
|
|
@ -36,20 +36,20 @@
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
#include <assert.h>
|
#include <assert.h>
|
||||||
|
|
||||||
|
#include <Bitmap.h>
|
||||||
|
#include <Clipboard.h>
|
||||||
|
#include <Cursor.h>
|
||||||
#include <Message.h>
|
#include <Message.h>
|
||||||
#include <Messenger.h>
|
#include <Messenger.h>
|
||||||
#include <MessageRunner.h>
|
#include <MessageRunner.h>
|
||||||
#include <PopUpMenu.h>
|
#include <PopUpMenu.h>
|
||||||
#include <MenuItem.h>
|
#include <MenuItem.h>
|
||||||
#include <Clipboard.h>
|
#include <ObjectList.h>
|
||||||
#include <ScrollView.h>
|
#include <ScrollView.h>
|
||||||
#include <ScrollBar.h>
|
#include <ScrollBar.h>
|
||||||
#include <Region.h>
|
#include <Region.h>
|
||||||
#include <Window.h>
|
#include <Window.h>
|
||||||
#include <Bitmap.h>
|
|
||||||
#include <Cursor.h>
|
|
||||||
|
|
||||||
#include "ObjectList.h"
|
|
||||||
#include "Theme.h"
|
#include "Theme.h"
|
||||||
#include "RunView.h"
|
#include "RunView.h"
|
||||||
#include "URLCrunch.h"
|
#include "URLCrunch.h"
|
||||||
|
|
|
||||||
Ŝarĝante…
Reference in New Issue