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;

    29

    30

public:

    31

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

    32

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

    33

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

    34

    35

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

    36

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

    37

    38

protected:

    39

	/**

    40

	 * Add a single item to the list.

    41

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

    42

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

    43

	 */

    44

	void AddItem(int32 item);

    45

    46

	/**

    47

	 * Remove a single item from the list.

    48

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

    49

	 */

    50

	void RemoveItem(int32 item);

    51

    52

public:

    53

	/**

    54

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

    55

	 */

    56

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

    57

    58

	/**

    59

	 * Constructor of the AIAbstractList.

    60

	 */

    61

	AIAbstractList();

    62

    63

	/**

    64

	 * Destructor of the AIAbstractList.

    65

	 */

    66

	~AIAbstractList();

    67

    68

	/**

    69

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

    70

	 */

    71

	void Clear();

    72

    73

	/**

    74

	 * Check if an item is in the list.

    75

	 * @param item the item to check for.

    76

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

    77

	 */

    78

	bool HasItem(int32 item);

    79

    80

	/**

    81

	 * Go to the beginning of the list.

    82

	 * @return the item value of the first item.

    83

	 */

    84

	int32 Begin();

    85

    86

	/**

    87

	 * Go to the next item in the list.

    88

	 * @return the item value of the next item.

    89

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

    90

	 */

    91

	int32 Next();

    92

    93

	/**

    94

	 * Check if a list is empty.

    95

	 * @return true if the list is empty.

    96

	 **/

    97

	bool IsEmpty();

    98

    99

	/**

   100

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

   101

	 *   Next() will return a valid item.

   102

	 * @return true if there is a next item.

   103

	 */

   104

	bool HasNext();

   105

   106

	/**

   107

	 * Returns the amount of items in the list.

   108

	 * @return amount of items in the list.

   109

	 */

   110

	int32 Count();

   111

   112

	/**

   113

	 * Get the value that belongs to this item.

   114

	 * @param item the item to get the value from

   115

	 * @return the value that belongs to this item.

   116

	 */

   117

	int32 GetValue(int32 item);

   118

   119

	/**

   120

	 * Set a value of an item directly.

   121

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

   122

	 * @param value the value to give to the item

   123

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

   124

	 */

   125

	bool SetValue(int32 item, int32 value);

   126

   127

	/**

   128

	 * Sort this list by the given sorter and direction.

   129

	 * @param sorter    the type of sorter to use

   130

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

   131

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

   132

	 */

   133

	void Sort(SorterType sorter, bool ascending);

   134

   135

	/**

   136

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

   137

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

   138

	 */

   139

	void RemoveAboveValue(int32 value);

   140

   141

	/**

   142

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

   143

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

   144

	 */

   145

	void RemoveBelowValue(int32 value);

   146

   147

	/**

   148

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

   149

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

   150

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

   151

	 */

   152

	void RemoveBetweenValue(int32 start, int32 end);

   153

   154

	/**

   155

	 * Remove all items with this value.

   156

	 * @param value the value to remove.

   157

	 */

   158

	void RemoveValue(int32 value);

   159

   160

	/**

   161

	 * Remove the first count items.

   162

	 * @param count the amount of items to remove.

   163

	 */

   164

	void RemoveTop(int32 count);

   165

   166

	/**

   167

	 * Remove the last count items.

   168

	 * @param count the amount of items to remove.

   169

	 */

   170

	void RemoveBottom(int32 count);

   171

   172

	/**

   173

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

   174

	 * @param list the list of items to remove.

   175

	 * @pre list != NULL

   176

	 */

   177

	void RemoveList(AIAbstractList *list);

   178

   179

	/**

   180

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

   181

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

   182

	 */

   183

	void KeepAboveValue(int32 value);

   184

   185

	/**

   186

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

   187

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

   188

	 */

   189

	void KeepBelowValue(int32 value);

   190

   191

	/**

   192

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

   193

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

   194

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

   195

	 */

   196

	void KeepBetweenValue(int32 start, int32 end);

   197

   198

	/**

   199

	 * Keep all items with this value.

   200

	 * @param value the value to keep.

   201

	 **/

   202

	void KeepValue(int32 value);

   203

   204

	/**

   205

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

   206

	 * @param count the amount of items to keep.

   207

	 */

   208

	void KeepTop(int32 count);

   209

   210

	/**

   211

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

   212

	 * @param count the amount of items to keep.

   213

	 */

   214

	void KeepBottom(int32 count);

   215

   216

	/**

   217

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

   218

	 * @param list the list of items to keep.

   219

	 * @pre list != NULL

   220

	 */

   221

	void KeepList(AIAbstractList *list);

   222

   223

	/**

   224

	 * The definition how valuators should look.

   225

	 */

   226

	class Valuator : public AIObject {

   227

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

   228

		 *  Nobody else should ever call Valuate. */

   229

		friend class AIAbstractList;

   230

	public:

   231

		/**

   232

		 * Virtual destructor, needed to make compilers happy.

   233

		 */

   234

		virtual ~Valuator() {}

   235

   236

	private:

   237

		virtual int32 Valuate(int32 item) const = 0;

   238

	};

   239

   240

	/**

   241

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

   242

	 * @note the valuator should be a valid instance.

   243

	 */

   244

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

   245

};

   246

   247

#endif /* AI_LIST_HPP */