Author: zooey Date: 2011-01-20 13:09:16 +0100 (Thu, 20 Jan 2011) New Revision: 40252 Changeset: http://dev.haiku-os.org/changeset/40252 Added: haiku/trunk/headers/os/support/ObjectList.h haiku/trunk/headers/private/support/ObjectListPrivate.h Removed: haiku/trunk/headers/private/shared/ObjectList.h Modified: haiku/trunk/src/kits/interface/ColumnListView.cpp haiku/trunk/src/kits/interface/Jamfile haiku/trunk/src/kits/tracker/Jamfile haiku/trunk/src/kits/tracker/PoseView.cpp haiku/trunk/src/servers/app/Jamfile haiku/trunk/src/servers/app/ServerPicture.cpp haiku/trunk/src/servers/input/InputServer.cpp haiku/trunk/src/servers/input/Jamfile Log: Make BObjectList<> publically available: * cleaned up ObjectList.h * switched several uses of new() to new(std::nothrow) * moved ugly AsBList() hack into BObjectList<>::Private class and adjusted all callers accordingly Copied: haiku/trunk/headers/os/support/ObjectList.h (from rev 40238, haiku/trunk/headers/private/shared/ObjectList.h) =================================================================== --- haiku/trunk/headers/os/support/ObjectList.h (rev 0) +++ haiku/trunk/headers/os/support/ObjectList.h 2011-01-20 12:09:16 UTC (rev 40252) @@ -0,0 +1,935 @@ +/* +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. +*/ +#ifndef _OBJECT_LIST_H +#define _OBJECT_LIST_H + + +#include <new> + +#include <List.h> +#include <SupportDefs.h> + + +// +// ObjectList is a wrapper around BList that adds type safety, +// optional object ownership, search, insert operations, etc. +// + +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 + 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(bool deleteIfOwning = true); + + // 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 + + class Private; +private: + friend class 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 (std::nothrow) 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 (std::nothrow) 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(bool deleteIfOwning) +{ + if (owning && deleteIfOwning) { + 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 (std::nothrow) 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 (std::nothrow) 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 (std::nothrow) 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 (std::nothrow) 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_H */ Added: haiku/trunk/headers/private/support/ObjectListPrivate.h =================================================================== --- haiku/trunk/headers/private/support/ObjectListPrivate.h (rev 0) +++ haiku/trunk/headers/private/support/ObjectListPrivate.h 2011-01-20 12:09:16 UTC (rev 40252) @@ -0,0 +1,38 @@ +/* + * Copyright 2011, Oliver Tappe <zooey@xxxxxxxxxxxxxxx> + * Distributed under the terms of the MIT License. + */ +#ifndef _OBJECT_LIST_PRIVATE_H +#define _OBJECT_LIST_PRIVATE_H + + +#include <ObjectList.h> + + +template<class T> +class BObjectList<T>::Private { +public: + Private(BObjectList<T>* objectList) + : + fObjectList(objectList) + { + } + + BList* + AsBList() + { + return fObjectList; + } + + const BList* + AsBList() const + { + return fObjectList; + } + +private: + BObjectList<T>* fObjectList; +}; + + +#endif // _OBJECT_LIST_PRIVATE_H Modified: haiku/trunk/src/kits/interface/ColumnListView.cpp =================================================================== --- haiku/trunk/src/kits/interface/ColumnListView.cpp 2011-01-20 11:58:03 UTC (rev 40251) +++ haiku/trunk/src/kits/interface/ColumnListView.cpp 2011-01-20 12:09:16 UTC (rev 40252) @@ -64,6 +64,8 @@ #include <String.h> #include <Window.h> +#include <ObjectListPrivate.h> + #include "ColorTools.h" #include "ObjectList.h" @@ -4520,7 +4522,8 @@ { [... truncated: 158 lines follow ...]