1

/* $Id$ */

     2

     3

/** @file ai_abstractlist.hpp a linked list which can keep item/value pairs */

     4

     5

#ifndef AI_ABSTRACTLIST_HPP

     6

#define AI_ABSTRACTLIST_HPP

     7

     8

#include "ai_object.hpp"

     9

#include <map>

    10

#include <set>

    11

    12

class AIAbstractListSorter;

    13

    14

/**

    15

 * Class that creates a linked list which can keep item/value pairs.

    16

 */

    17

class AIAbstractList : public AIObject {

    18

public:

    19

	/** Type of sorter */

    20

	enum SorterType {

    21

		SORT_BY_VALUE,

    22

		SORT_BY_ITEM,

    23

	};

    24

    25

private:

    26

	AIAbstractListSorter *sorter;

    27

	SorterType sorter_type;

    28

	bool sort_ascending;

    30

    31

public:

    32

	typedef std::set<int32> AIItemList;               ///< The list of items inside the bucket

    33

	typedef std::map<int32, AIItemList> AIAbstractListBucket; ///< The bucket list per value

    34

	typedef std::map<int32, int32> AIAbstractListMap;         ///< List per item

    35

    36

	AIAbstractListMap items;           ///< The items in the list

    37

	AIAbstractListBucket buckets;      ///< The items in the list, sorted by value

    38

    39

protected:

    40

	/**

    41

	 * Add a single item to the list.

    42

	 * @param item the item to add. Should be unique, otherwise it is ignored.

    43

	 * @note the value is set to 0 by default.

    44

	 */

    45

	void AddItem(int32 item);

    46

    47

	/**

    48

	 * Remove a single item from the list.

    49

	 * @param item the item to remove. If not existing, it is ignored.

    50

	 */

    51

	void RemoveItem(int32 item);

    52

    53

public:

    54

	/**

    55

	 * The name of the class, needed by several sub-processes.

    56

	 */

    57

	static const char *GetClassName() { return "AIAbstractList"; }

    58

    59

	/**

    60

	 * Constructor of the AIAbstractList.

    61

	 */

    62

	AIAbstractList();

    63

    64

	/**

    65

	 * Destructor of the AIAbstractList.

    66

	 */

    67

	~AIAbstractList();

    68

    69

	/**

    70

	 * Clear the list, making Count() returning 0 and IsEmpty() returning true.

    71

	 */

    72

	void Clear();

    73

    74

	/**

    75

	 * Check if an item is in the list.

    76

	 * @param item the item to check for.

    77

	 * @return true if the item is in the list.

    78

	 */

    79

	bool HasItem(int32 item);

    80

    81

	/**

    82

	 * Go to the beginning of the list.

    83

	 * @return the item value of the first item.

    84

	 */

    85

	int32 Begin();

    86

    87

	/**

    88

	 * Go to the next item in the list.

    89

	 * @return the item value of the next item.

    90

	 * @note returns 0 if beyond end-of-list. Use HasNext() to check for end-of-list.

    91

	 */

    92

	int32 Next();

    93

    94

	/**

    95

	 * Check if a list is empty.

    96

	 * @return true if the list is empty.

    97

	 **/

    98

	bool IsEmpty();

    99

   100

	/**

   101

	 * Check if there is a next element. In other words, if this is true,

   102

	 *   Next() will return a valid item.

   103

	 * @return true if there is a next item.

   104

	 */

   105

	bool HasNext();

   106

   107

	/**

   108

	 * Returns the amount of items in the list.

   109

	 * @return amount of items in the list.

   110

	 */

   111

	int32 Count();

   112

   113

	/**

   114

	 * Get the value that belongs to this item.

   115

	 * @param item the item to get the value from

   116

	 * @return the value that belongs to this item.

   117

	 */

   118

	int32 GetValue(int32 item);

   119

   120

	/**

   121

	 * Set a value of an item directly.

   122

	 * @param item the item to set the value for.

   123

	 * @param value the value to give to the item

   124

	 * @return true if we could set the item to value, false otherwise.

   125

	 */

   126

	bool SetValue(int32 item, int32 value);

   127

   128

	/**

   129

	 * Sort this list by the given sorter and direction.

   130

	 * @param sorter    the type of sorter to use

   131

	 * @param ascending if true, lowest value is on top, else at bottom.

   132

	 * @note the current item stays at the same place.

   133

	 */

   134

	void Sort(SorterType sorter, bool ascending);

   135

   136

	/**

   137

	 * Removes all items with a higher value than 'value'.

   138

	 * @param value the value above which all items are removed.

   139

	 */

   140

	void RemoveAboveValue(int32 value);

   141

   142

	/**

   143

	 * Removes all items with a lower value than 'value'.

   144

	 * @param value the value below which all items are removed.

   145

	 */

   146

	void RemoveBelowValue(int32 value);

   147

   148

	/**

   149

	 * Removes all items with a value above start and below end.

   150

	 * @param start the lower bound of the to be removed values (exclusive).

   151

	 * @param end   the upper bound of the to be removed valuens (exclusive).

   152

	 */

   153

	void RemoveBetweenValue(int32 start, int32 end);

   154

   155

	/**

   156

	 * Remove all items with this value.

   157

	 * @param value the value to remove.

   158

	 */

   159

	void RemoveValue(int32 value);

   160

   161

	/**

   162

	 * Remove the first count items.

   163

	 * @param count the amount of items to remove.

   164

	 */

   165

	void RemoveTop(int32 count);

   166

   167

	/**

   168

	 * Remove the last count items.

   169

	 * @param count the amount of items to remove.

   170

	 */

   171

	void RemoveBottom(int32 count);

   172

   173

	/**

   174

	 * Remove everything that is in the given list from this list (same item index that is).

   175

	 * @param list the list of items to remove.

   176

	 * @pre list != NULL

   177

	 */

   178

	void RemoveList(AIAbstractList *list);

   179

   180

	/**

   181

	 * Keep all items with a higher value than 'value'.

   182

	 * @param value the value above which all items are kept.

   183

	 */

   184

	void KeepAboveValue(int32 value);

   185

   186

	/**

   187

	 * Keep all items with a lower value than 'value'.

   188

	 * @param value the value below which all items are kept.

   189

	 */

   190

	void KeepBelowValue(int32 value);

   191

   192

	/**

   193

	 * Keep all items with a value above start and below end.

   194

	 * @param start the lower bound of the to be kept values (exclusive).

   195

	 * @param end   the upper bound of the to be kept values (exclusive).

   196

	 */

   197

	void KeepBetweenValue(int32 start, int32 end);

   198

   199

	/**

   200

	 * Keep all items with this value.

   201

	 * @param value the value to keep.

   202

	 **/

   203

	void KeepValue(int32 value);

   204

   205

	/**

   206

	 * Keep the first count items, i.e. remove everything except the first count items.

   207

	 * @param count the amount of items to keep.

   208

	 */

   209

	void KeepTop(int32 count);

   210

   211

	/**

   212

	 * Keep the last count items, i.e. remove everything except the last count items.

   213

	 * @param count the amount of items to keep.

   214

	 */

   215

	void KeepBottom(int32 count);

   216

   217

	/**

   218

	 * Keps everything that is in the given list from this list (same item index that is).

   219

	 * @param list the list of items to keep.

   220

	 * @pre list != NULL

   221

	 */

   222

	void KeepList(AIAbstractList *list);

   223

   224

	/**

   225

	 * The definition how valuators should look.

   226

	 */

   227

	class Valuator : public AIObject {

   228

		/* Make this valuator a friend of AIAbstractList, so we can access the private.

   229

		 *  Nobody else should ever call Valuate. */

   230

		friend class AIAbstractList;

   231

	public:

   232

		/**

   233

		 * Virtual destructor, needed to make compilers happy.

   234

		 */

   235

		virtual ~Valuator() {}

   236

   237

	private:

   238

		virtual int32 Valuate(int32 item) const = 0;

   239

	};

   240

   241

	/**

   242

	 * Give all items a value defined by the valuator you give.

   243

	 * @note the valuator should be a valid instance.

   244

	 */

   245

	void Valuate(const AIAbstractList::Valuator &proc);

   246

};

   247

   248

#endif /* AI_LIST_HPP */