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

private:

    19

	AIAbstractListSorter *sorter;

    20

    21

public:

    22

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

    23

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

    24

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

    25

    26

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

    27

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

    28

    29

protected:

    30

	/**

    31

	 * Add a single item to the list.

    32

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

    33

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

    34

	 */

    35

	void AddItem(int32 item);

    36

    37

	/**

    38

	 * Remove a single item from the list.

    39

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

    40

	 */

    41

	void RemoveItem(int32 item);

    42

    43

public:

    44

	/**

    45

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

    46

	 */

    47

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

    48

    49

	/**

    50

	 * Constructor of the AIAbstractList.

    51

	 */

    52

	AIAbstractList();

    53

    54

	/**

    55

	 * Destructor of the AIAbstractList.

    56

	 */

    57

	~AIAbstractList();

    58

    59

	/**

    60

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

    61

	 */

    62

	void Clear();

    63

    64

	/**

    65

	 * Check if an item is in the list.

    66

	 * @param item the item to check for.

    67

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

    68

	 */

    69

	bool HasItem(int32 item);

    70

    71

	/**

    72

	 * Go to the beginning of the list.

    73

	 * @return the item value of the first item.

    74

	 */

    75

	int32 Begin();

    76

    77

	/**

    78

	 * Go to the next item in the list.

    79

	 * @return the item value of the next item.

    80

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

    81

	 */

    82

	int32 Next();

    83

    84

	/**

    85

	 * Check if a list is empty.

    86

	 * @return true if the list is empty.

    87

	 **/

    88

	bool IsEmpty();

    89

    90

	/**

    91

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

    92

	 *   Next() will return a valid item.

    93

	 * @return true if there is a next item.

    94

	 */

    95

	bool HasNext();

    96

    97

	/**

    98

	 * Returns the amount of items in the list.

    99

	 * @return amount of items in the list.

   100

	 */

   101

	int32 Count();

   102

   103

	/**

   104

	 * Get the value that belongs to this item.

   105

	 * @param item the item to get the value from

   106

	 * @return the value that belongs to this item.

   107

	 */

   108

	int32 GetValue(int32 item);

   109

   110

	/**

   119

	 * Sort this list by item-value.

   120

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

   121

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

   122

	 */

   123

	void SortByItem(bool ascending);

   124

   125

	/**

   126

	 * Sort this list by the value of the items.

   127

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

   128

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

   129

	 */

   130

	void SortByValue(bool ascending);

   131

   132

	/**

   133

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

   134

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

   135

	 */

   136

	void RemoveAboveValue(int32 value);

   137

   138

	/**

   139

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

   140

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

   141

	 */

   142

	void RemoveBelowValue(int32 value);

   143

   144

	/**

   145

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

   146

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

   147

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

   148

	 */

   149

	void RemoveBetweenValue(int32 start, int32 end);

   150

   151

	/**

   152

	 * Remove all items with this value.

   153

	 * @param value the value to remove.

   154

	 */

   155

	void RemoveValue(int32 value);

   156

   157

	/**

   158

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

   159

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

   160

	 */

   161

	void KeepAboveValue(int32 value);

   162

   163

	/**

   164

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

   165

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

   166

	 */

   167

	void KeepBelowValue(int32 value);

   168

   169

	/**

   170

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

   171

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

   172

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

   173

	 */

   174

	void KeepBetweenValue(int32 start, int32 end);

   175

   176

	/**

   177

	 * Keep all items with this value.

   178

	 * @param value the value to keep.

   179

	 **/

   180

	void KeepValue(int32 value);

   181

   182

	/**

   183

	 * The definition how valuators should look.

   184

	 */

   185

	class Valuator {

   186

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

   187

		 *  Nobody else should ever call Valuate. */

   188

		friend class AIAbstractList;

   189

	public:

   190

		/**

   191

		 * Virtual destructor, needed to make compilers happy.

   192

		 */

   193

		virtual ~Valuator() {}

   194

   195

	private:

   196

		virtual int32 Valuate(int32 item) const = 0;

   197

	};

   198

   199

	/**

   200

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

   201

	 * @note the valuator should be a valid instance.

   202

	 */

   203

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

   204

};

   205

   206

#endif /* AI_LIST_HPP */