i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Code and header indentation cleanup

Browse Source 
* Added operator== and !=
 * Added check for list != this in operator=
 * Added HasItem() and IndexOf() versions that take const void*, duplicating
   the code, since I didn't want to introduce another function call in these
   potentially time critical methods.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34520 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stephan Aßmus
2009-12-06 12:44:38 +00:00
parent bc69c291c2
commit b0850e9ba1
2 changed files with 206 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/support/List.h
+16 -6
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2001-2007, Haiku, Inc. All Rights Reserved. * Copyright 2001-2009, Haiku, Inc. All Rights Reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
*/ */
#ifndef _BE_LIST_H #ifndef _BE_LIST_H
@@ -15,28 +15,33 @@ class BList {
BList(const BList& anotherList); BList(const BList& anotherList);
virtual ~BList(); virtual ~BList();
BList& operator =(const BList &); BList& operator=(const BList& other);
bool operator==(const BList& other) const;
bool operator!=(const BList& other) const;
/* Adding and removing items. */ // Adding and removing items.
bool AddItem(void* item, int32 index); bool AddItem(void* item, int32 index);
bool AddItem(void* item); bool AddItem(void* item);
bool AddList(const BList* list, int32 index); bool AddList(const BList* list, int32 index);
bool AddList(const BList* list); bool AddList(const BList* list);
bool RemoveItem(void* item); bool RemoveItem(void* item);
void* RemoveItem(int32 index); void* RemoveItem(int32 index);
bool RemoveItems(int32 index, int32 count); bool RemoveItems(int32 index, int32 count);
bool ReplaceItem(int32 index, void* newItem); bool ReplaceItem(int32 index, void* newItem);
void MakeEmpty(); void MakeEmpty();
// Reorder items // Reorder items
void SortItems(int (*compareFunc)(const void*, const void*)); void SortItems(int (*compareFunc)(const void*,
const void*));
bool SwapItems(int32 indexA, int32 indexB); bool SwapItems(int32 indexA, int32 indexB);
bool MoveItem(int32 fromIndex, int32 toIndex); bool MoveItem(int32 fromIndex, int32 toIndex);
// Retrieve items // Retrieve items
void* ItemAt(int32 index) const; void* ItemAt(int32 index) const;
void* FirstItem() const; void* FirstItem() const;
void* ItemAtFast(int32) const; void* ItemAtFast(int32 index) const;
// does not check the array bounds! // does not check the array bounds!
void* LastItem() const; void* LastItem() const;
@@ -44,25 +49,30 @@ class BList {
// Query // Query
bool HasItem(void* item) const; bool HasItem(void* item) const;
bool HasItem(const void* item) const;
int32 IndexOf(void* item) const; int32 IndexOf(void* item) const;
int32 IndexOf(const void* item) const;
int32 CountItems() const; int32 CountItems() const;
bool IsEmpty() const; bool IsEmpty() const;
// Iteration // Iteration
void DoForEach(bool (*func)(void* item)); void DoForEach(bool (*func)(void* item));
void DoForEach(bool (*func)(void* item, void* arg2), void *arg2); void DoForEach(bool (*func)(void* item,
void* arg2), void* arg2);
private: private:
virtual void _ReservedList1(); virtual void _ReservedList1();
virtual void _ReservedList2(); virtual void _ReservedList2();
bool _ResizeArray(int32 count); bool _ResizeArray(int32 count);
private: private:
void** fObjectList; void** fObjectList;
int32 fPhysicalSize; int32 fPhysicalSize;
int32 fItemCount; int32 fItemCount;
int32 fBlockSize; int32 fBlockSize;
int32 fResizeThreshold; int32 fResizeThreshold;
uint32 _reserved[1]; uint32 _reserved[1];
}; };
src/kits/support/List.cpp
+107 -90
View File
@@ -1,44 +1,26 @@
//------------------------------------------------------------------------------ /*
// Copyright (c) 2001-2008, Haiku, Inc. * Copyright 2001-2009, Haiku, Inc. All Rights Reserved.
// * Distributed under the terms of the MIT License.
// Permission is hereby granted, free of charge, to any person obtaining a *
// copy of this software and associated documentation files (the "Software"), * Authors:
// to deal in the Software without restriction, including without limitation * The Storage kit Team
// the rights to use, copy, modify, merge, publish, distribute, sublicense, * Isaac Yonemoto
// and/or sell copies of the Software, and to permit persons to whom the * Rene Gollent
// Software is furnished to do so, subject to the following conditions: * Stephan Aßmus
// */
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software. //! BList class provides storage for pointers. Not thread safe.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS 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.
//
// File Name: List.cpp
// Author(s): The Storage kit Team
// Isaac Yonemoto
// Rene Gollent
// Description: BList class provides storage for pointers.
// Not thread safe.
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
#include <List.h> #include <List.h>
// System Includes -------------------------------------------------------------
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
// helper function // helper function
static inline static inline void
void
move_items(void** items, int32 offset, int32 count) move_items(void** items, int32 offset, int32 count)
{ {
if (count > 0 && offset != 0) if (count > 0 && offset != 0)
@@ -46,9 +28,9 @@ move_items(void** items, int32 offset, int32 count)
} }
// constructor
BList::BList(int32 count) BList::BList(int32 count)
: fObjectList(NULL), :
fObjectList(NULL),
fPhysicalSize(0), fPhysicalSize(0),
fItemCount(0), fItemCount(0),
fBlockSize(count), fBlockSize(count),
@@ -60,9 +42,9 @@ BList::BList(int32 count)
} }
// copy constructor
BList::BList(const BList& anotherList) BList::BList(const BList& anotherList)
: fObjectList(NULL), :
fObjectList(NULL),
fPhysicalSize(0), fPhysicalSize(0),
fItemCount(0), fItemCount(0),
fBlockSize(anotherList.fBlockSize) fBlockSize(anotherList.fBlockSize)
@@ -71,28 +53,52 @@ BList::BList(const BList& anotherList)
} }
// destructor
BList::~BList() BList::~BList()
{ {
free(fObjectList); free(fObjectList);
} }
// =
BList& BList&
BList::operator=(const BList& list) BList::operator=(const BList& list)
{ {
if (&list != this) {
fBlockSize = list.fBlockSize; fBlockSize = list.fBlockSize;
if (_ResizeArray(list.fItemCount)) { if (_ResizeArray(list.fItemCount)) {
fItemCount = list.fItemCount; fItemCount = list.fItemCount;
memcpy(fObjectList, list.fObjectList, fItemCount * sizeof(void*)); memcpy(fObjectList, list.fObjectList, fItemCount * sizeof(void*));
} }
}
return *this; return *this;
} }
// AddItem bool
BList::operator==(const BList& list) const
{
if (&list == this)
return true;
if (list.fItemCount != fItemCount)
return false;
if (fItemCount > 0) {
return memcmp(fObjectList, list.fObjectList,
fItemCount * sizeof(void*)) == 0;
}
return true;
}
bool
BList::operator!=(const BList& list) const
{
return !(*this == list);
}
bool bool
BList::AddItem(void* item, int32 index) BList::AddItem(void* item, int32 index)
{ {
@@ -112,7 +118,6 @@ BList::AddItem(void *item, int32 index)
} }
// AddItem
bool bool
BList::AddItem(void* item) BList::AddItem(void* item)
{ {
@@ -130,7 +135,6 @@ BList::AddItem(void *item)
} }
// AddList
bool bool
BList::AddList(const BList* list, int32 index) BList::AddList(const BList* list, int32 index)
{ {
@@ -150,7 +154,6 @@ BList::AddList(const BList *list, int32 index)
} }
// AddList
bool bool
BList::AddList(const BList* list) BList::AddList(const BList* list)
{ {
@@ -170,7 +173,6 @@ BList::AddList(const BList *list)
} }
// RemoveItem
bool bool
BList::RemoveItem(void* item) BList::RemoveItem(void* item)
{ {
@@ -182,7 +184,6 @@ BList::RemoveItem(void *item)
} }
// RemoveItem
void* void*
BList::RemoveItem(int32 index) BList::RemoveItem(int32 index)
{ {
@@ -198,7 +199,6 @@ BList::RemoveItem(int32 index)
} }
// RemoveItems
bool bool
BList::RemoveItems(int32 index, int32 count) BList::RemoveItems(int32 index, int32 count)
{ {
@@ -219,7 +219,6 @@ BList::RemoveItems(int32 index, int32 count)
} }
//ReplaceItem
bool bool
BList::ReplaceItem(int32 index, void* newItem) BList::ReplaceItem(int32 index, void* newItem)
{ {
@@ -233,7 +232,6 @@ BList::ReplaceItem(int32 index, void *newItem)
} }
// MakeEmpty
void void
BList::MakeEmpty() BList::MakeEmpty()
{ {
@@ -242,8 +240,9 @@ BList::MakeEmpty()
} }
/* Reordering items. */ // #pragma mark - Reordering items.
// SortItems
void void
BList::SortItems(int (*compareFunc)(const void*, const void*)) BList::SortItems(int (*compareFunc)(const void*, const void*))
{ {
@@ -252,7 +251,6 @@ BList::SortItems(int (*compareFunc)(const void *, const void *))
} }
//SwapItems
bool bool
BList::SwapItems(int32 indexA, int32 indexB) BList::SwapItems(int32 indexA, int32 indexB)
{ {
@@ -272,18 +270,20 @@ BList::SwapItems(int32 indexA, int32 indexB)
} }
// MoveItem /*! This moves a list item from posititon a to position b, moving the
// This moves a list item from posititon a to position b, moving the appropriate appropriate block of list elements to make up for the move. For example,
// block of list elements to make up for the move. For example, in the array: in the array:
// A B C D E F G H I J A B C D E F G H I J
// Moveing 1(B)->6(G) would result in this: Moveing 1(B)->6(G) would result in this:
// A C D E F G B H I J A C D E F G B H I J
*/
bool bool
BList::MoveItem(int32 fromIndex, int32 toIndex) BList::MoveItem(int32 fromIndex, int32 toIndex)
{ {
if ((fromIndex >= fItemCount) || (toIndex >= fItemCount) || (fromIndex < 0) if ((fromIndex >= fItemCount) || (toIndex >= fItemCount) || (fromIndex < 0)
|| (toIndex < 0)) || (toIndex < 0)) {
return false; return false;
}
void* tmpMover = fObjectList[fromIndex]; void* tmpMover = fObjectList[fromIndex];
if (fromIndex < toIndex) { if (fromIndex < toIndex) {
@@ -299,8 +299,9 @@ BList::MoveItem(int32 fromIndex, int32 toIndex)
} }
/* Retrieving items. */ // #pragma mark - Retrieving items.
// ItemAt
void* void*
BList::ItemAt(int32 index) const BList::ItemAt(int32 index) const
{ {
@@ -311,7 +312,6 @@ BList::ItemAt(int32 index) const
} }
// FirstItem
void* void*
BList::FirstItem() const BList::FirstItem() const
{ {
@@ -322,7 +322,6 @@ BList::FirstItem() const
} }
// ItemAtFast
void* void*
BList::ItemAtFast(int32 index) const BList::ItemAtFast(int32 index) const
{ {
@@ -330,7 +329,6 @@ BList::ItemAtFast(int32 index) const
} }
// Items
void* void*
BList::Items() const BList::Items() const
{ {
@@ -338,7 +336,6 @@ BList::Items() const
} }
// LastItem
void* void*
BList::LastItem() const BList::LastItem() const
{ {
@@ -349,8 +346,9 @@ BList::LastItem() const
} }
/* Querying the list. */ // #pragma mark - Querying the list.
// HasItem
bool bool
BList::HasItem(void* item) const BList::HasItem(void* item) const
{ {
@@ -358,7 +356,13 @@ BList::HasItem(void *item) const
} }
// IndexOf bool
BList::HasItem(const void* item) const
{
return (IndexOf(item) >= 0);
}
int32 int32
BList::IndexOf(void* item) const BList::IndexOf(void* item) const
{ {
@@ -370,7 +374,17 @@ BList::IndexOf(void *item) const
} }
// CountItems int32
BList::IndexOf(const void* item) const
{
for (int32 i = 0; i < fItemCount; i++) {
if (fObjectList[i] == item)
return i;
}
return -1;
}
int32 int32
BList::CountItems() const BList::CountItems() const
{ {
@@ -378,49 +392,52 @@ BList::CountItems() const
} }
// IsEmpty
bool bool
BList::IsEmpty() const BList::IsEmpty() const
{ {
return (fItemCount == 0); return fItemCount == 0;
} }
/* Iterating over the list. */ // #pragma mark - Iterating over the list.
//iterate a function over the whole list. If the function outputs a true
//value, then the process is terminated.
/*! Iterate a function over the whole list. If the function outputs a true
value, then the process is terminated.
*/
void void
BList::DoForEach(bool (*func)(void*)) BList::DoForEach(bool (*func)(void*))
{ {
bool terminate = false; int32 index = 0; //set terminate condition variables to go. if (func == NULL)
if (func != NULL) return;
{
while ((!terminate) && (index < fItemCount)) //check terminate condition.
{
terminate = func(fObjectList[index]); //reset immediate terminator
index++; //advance along the list.
};
}
bool terminate = false;
int32 index = 0;
while ((!terminate) && (index < fItemCount)) {
terminate = func(fObjectList[index]);
index++;
}
} }
//same as above, except this function takes an argument. /*! Iterate a function over the whole list. If the function outputs a true
value, then the process is terminated. This version takes an additional
argument which is passed to the function.
*/
void void
BList::DoForEach(bool (*func)(void*, void*), void* arg) BList::DoForEach(bool (*func)(void*, void*), void* arg)
{ {
if (func == NULL)
return;
bool terminate = false; int32 index = 0; bool terminate = false; int32 index = 0;
if (func != NULL) while ((!terminate) && (index < fItemCount)) {
{
while ((!terminate) && (index < fItemCount))
{
terminate = func(fObjectList[index], arg); terminate = func(fObjectList[index], arg);
index++; index++;
};
} }
} }
#if (__GNUC__ == 2) #if (__GNUC__ == 2)
// This is somewhat of a hack for backwards compatibility - // This is somewhat of a hack for backwards compatibility -
@@ -449,9 +466,9 @@ AddList__5BListP5BList(BList* self, BList* list)
void BList::_ReservedList1() {} void BList::_ReservedList1() {}
void BList::_ReservedList2() {} void BList::_ReservedList2() {}
// Resize
// /*! Resizes fObjectList to be large enough to contain count items.
// Resizes fObjectList to be large enough to contain count items. */
bool bool
BList::_ResizeArray(int32 count) BList::_ResizeArray(int32 count)
{ {