1

/* $Id$ */

     2

     3

/** @file ai_abstractlist.hpp A list which can keep item/value pairs, which you can walk. */

     4

/** @defgroup AIList Classes that create a list of items. */

     5

     6

#ifndef AI_ABSTRACTLIST_HPP

     7

#define AI_ABSTRACTLIST_HPP

     8

     9

#include "ai_object.hpp"

    10

#include <map>

    11

#include <set>

    12

    13

class AIAbstractListSorter;

    14

    15

/**

    16

 * Class that creates a list which can keep item/value pairs, which you can walk.

    17

 */

    18

class AIAbstractList : public AIObject {

    19

public:

    20

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

    21

    22

	/** Type of sorter */

    23

	enum SorterType {

    24

		SORT_BY_VALUE,

    25

		SORT_BY_ITEM,

    26

	};

    27

    28

private:

    29

	AIAbstractListSorter *sorter;

    30

	SorterType sorter_type;

    31

	bool sort_ascending;

    32

	bool initialized;

    33

    34

public:

    35

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

    36

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

    37

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

    38

    39

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

    40

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

    41

    42

protected:

    43

	/**

    44

	 * Add a single item to the list.

    45

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

    46

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

    47

	 */

    48

	void AddItem(int32 item);

    49

    50

	/**

    51

	 * Remove a single item from the list.

    52

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

    53

	 */

    54

	void RemoveItem(int32 item);

    55

    56

public:

    57

	AIAbstractList();

    58

	~AIAbstractList();

    59

    60

	/**

    61

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

    62

	 */

    63

	void Clear();

    64

    65

	/**

    66

	 * Check if an item is in the list.

    67

	 * @param item the item to check for.

    68

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

    69

	 */

    70

	bool HasItem(int32 item);

    71

    72

	/**

    73

	 * Go to the beginning of the list.

    74

	 * @return the item value of the first item.

    75

	 */

    76

	int32 Begin();

    77

    78

	/**

    79

	 * Go to the next item in the list.

    80

	 * @return the item value of the next item.

    81

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

    82

	 */

    83

	int32 Next();

    84

    85

	/**

    86

	 * Check if a list is empty.

    87

	 * @return true if the list is empty.

    88

	 */

    89

	bool IsEmpty();

    90

    91

	/**

    92

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

    93

	 *   Next() will return a valid item.

    94

	 * @return true if there is a next item.

    95

	 */

    96

	bool HasNext();

    97

    98

	/**

    99

	 * Returns the amount of items in the list.

   100

	 * @return amount of items in the list.

   101

	 */

   102

	int32 Count();

   103

   104

	/**

   105

	 * Get the value that belongs to this item.

   106

	 * @param item the item to get the value from

   107

	 * @return the value that belongs to this item.

   108

	 */

   109

	int32 GetValue(int32 item);

   110

   111

	/**

   112

	 * Set a value of an item directly.

   113

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

   114

	 * @param value the value to give to the item

   115

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

   116

	 */

   117

	bool SetValue(int32 item, int32 value);

   118

   119

	/**

   120

	 * Sort this list by the given sorter and direction.

   121

	 * @param sorter    the type of sorter to use

   122

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

   123

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

   124

	 */

   125

	void Sort(SorterType sorter, bool ascending);

   126

   127

	/**

   128

	 * Add one list to an other one.

   129

	 * @param list The list that will be added to the caller.

   130

	 * @post The list to be added ('list') stays unmodified.

   131

	 * @note All added items keep their value as it was in 'list'.

   132

	 * @note If the item already exists inside the caller, the value of the

   133

	 *  list that is added is set on the item.

   134

	 */

   135

	void AddList(AIAbstractList *list);

   136

   137

	/**

   138

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

   139

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

   140

	 */

   141

	void RemoveAboveValue(int32 value);

   142

   143

	/**

   144

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

   145

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

   146

	 */

   147

	void RemoveBelowValue(int32 value);

   148

   149

	/**

   150

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

   151

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

   152

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

   153

	 */

   154

	void RemoveBetweenValue(int32 start, int32 end);

   155

   156

	/**

   157

	 * Remove all items with this value.

   158

	 * @param value the value to remove.

   159

	 */

   160

	void RemoveValue(int32 value);

   161

   162

	/**

   163

	 * Remove the first count items.

   164

	 * @param count the amount of items to remove.

   165

	 */

   166

	void RemoveTop(int32 count);

   167

   168

	/**

   169

	 * Remove the last count items.

   170

	 * @param count the amount of items to remove.

   171

	 */

   172

	void RemoveBottom(int32 count);

   173

   174

	/**

   175

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

   176

	 * @param list the list of items to remove.

   177

	 * @pre list != NULL

   178

	 */

   179

	void RemoveList(AIAbstractList *list);

   180

   181

	/**

   182

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

   183

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

   184

	 */

   185

	void KeepAboveValue(int32 value);

   186

   187

	/**

   188

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

   189

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

   190

	 */

   191

	void KeepBelowValue(int32 value);

   192

   193

	/**

   194

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

   195

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

   196

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

   197

	 */

   198

	void KeepBetweenValue(int32 start, int32 end);

   199

   200

	/**

   201

	 * Keep all items with this value.

   202

	 * @param value the value to keep.

   203

	 **/

   204

	void KeepValue(int32 value);

   205

   206

	/**

   207

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

   208

	 * @param count the amount of items to keep.

   209

	 */

   210

	void KeepTop(int32 count);

   211

   212

	/**

   213

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

   214

	 * @param count the amount of items to keep.

   215

	 */

   216

	void KeepBottom(int32 count);

   217

   218

	/**

   219

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

   220

	 * @param list the list of items to keep.

   221

	 * @pre list != NULL

   222

	 */

   223

	void KeepList(AIAbstractList *list);

   224

   225

	/**

   226

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

   227

	 * @param vm Internal pointer, not something you need to specify.

   228

	 * @return The result of the valuation.

   229

	 * @note The first param for this function is the function you want to use

   230

	 *  to valuate the items in the list. It should accept at least one integer

   231

	 *  which will be set to the item, and should return an integer, which will

   232

	 *  become the value of the item. Additional parameters are possible, then

   233

	 *  you need to add them to the Valuator to. Example:

   234

	 *  list.Valuate(AIBridge.GetPrice, 5);

   235

	 *  list.Valuate(AIBridge.GetMaxLength);

   236

	 *  function MyVal(bridge_id, myparam) {

   237

	 *    return myparam * bridge_id; // This is silly

   238

	 *  }

   239

	 *  list.Valuate(MyVal, 12);

   240

	 */

   241

	SQInteger Valuate(HSQUIRRELVM vm);

   242

};

   243

   244

#endif /* AI_LIST_HPP */