* @tparam T Key type.

 * @tparam U Value type.

 * @tparam S Unit of allocation.

 *

 * @see SmallVector

 */

struct SmallMap : std::vector<SmallPair<T, U> > {

	typedef ::SmallPair<T, U> Pair;

	typedef Pair *iterator;

	typedef const Pair *const_iterator;

	/** Creates new SmallMap. Data are initialized in SmallVector constructor */

 *

 * @note There are no asserts in the class so you have

 *       to care about that you grab an item which is

 *       inside the list.

 *

 * @param T The type of the items stored, must be a pointer

 */

class AutoFreeSmallVector : public std::vector<T> {

public:

	~AutoFreeSmallVector()

	{

		this->Clear();

	}

 *

 * @note There are no asserts in the class so you have

 *       to care about that you grab an item which is

 *       inside the list.

 *

 * @param T The type of the items stored, must be a pointer

 */

class AutoDeleteSmallVector : public std::vector<T> {

public:

	~AutoDeleteSmallVector()

	{

		this->Clear();

	}

		}

		std::vector<T>::clear();

	}

};

#endif /* SMALLVEC_TYPE_HPP */

/** Container for all the game strings. */

struct GameStrings {

	uint version;                  ///< The version of the language strings.

	LanguageStrings *cur_language; ///< The current (compiled) language.

	StringList string_names;                                      ///< The names of the compiled strings.

	void Compile();

};

#endif /* GAME_TEXT_HPP */

	return FALSE;

}

/**

 * Wrapper for doing layouts with ICU.

 */

	icu::ParagraphLayout *p; ///< The actual ICU paragraph layout.

public:

	/** Visual run contains data about the bit of text with the same font. */

	class ICUVisualRun : public ParagraphLayouter::VisualRun {

		const icu::ParagraphLayout::VisualRun *vr; ///< The actual ICU vr.

		const float *GetPositions() const    { return vr->getPositions(); }

		int GetLeading() const               { return vr->getLeading(); }

		const int *GetGlyphToCharMap() const { return vr->getGlyphToCharMap(); }

	};

	/** A single line worth of VisualRuns. */

		icu::ParagraphLayout::Line *l; ///< The actual ICU line.

	public:

		ICULine(icu::ParagraphLayout::Line *l) : l(l)

		{

			for (int i = 0; i < l->countRuns(); i++) {

		const float *GetPositions() const;

		int GetLeading() const;

		const int *GetGlyphToCharMap() const;

	};

	/** A single line worth of VisualRuns. */

	public:

		int GetLeading() const;

		int GetWidth() const;

		int CountRuns() const;

		const ParagraphLayouter::VisualRun *GetVisualRun(int run) const;

/**

 * The layouter performs all the layout work.

 *

 * It also accounts for the memory allocations and frees.

 */

	const char *string; ///< Pointer to the original string.

	/** Key into the linecache */

	struct LineCacheKey {

		FontState state_before;  ///< Font state at the beginning of the line.

		std::string str;         ///< Source string of the line (including colour and font size codes).

#include "config.h"

#include "../../string_func.h"

#include "../../core/smallmap_type.hpp"

class NetworkAddress;

typedef std::vector<NetworkAddress> NetworkAddressList; ///< Type for a list of addresses.

/**

 * Wrapper for (un)resolved network addresses; there's no reason to transform

 * a numeric IP to a string and then back again to pass it to functions. It

 * furthermore allows easier delaying of the hostname lookup.

 */

/** Read some packets, and when do use that data as initial load filter. */

struct PacketReader : LoadFilter {

	static const size_t CHUNK = 32 * 1024;  ///< 32 KiB chunks of memory.

	byte *buf;                              ///< Buffer we're going to write to/read from.

	byte *bufe;                             ///< End of the buffer we write to/read from.

	byte **block;                           ///< The block we're reading from/writing to.

	size_t written_bytes;                   ///< The total number of bytes we've written.

	size_t read_bytes;                      ///< The total number of read bytes.

	uint32 min_value;      ///< The minimal value this parameter can have

	uint32 max_value;      ///< The maximal value of this parameter

	uint32 def_value;      ///< Default value of this parameter

	byte param_nr;         ///< GRF parameter to store content in

	byte first_bit;        ///< First bit to use in the GRF parameter

	byte num_bit;          ///< Number of bits to use for this parameter

	bool complete_labels;  ///< True if all values have a label.

	uint32 GetValue(struct GRFConfig *config) const;

	void SetValue(struct GRFConfig *config, uint32 value);

	void Finalize();

};

		virtual int GetLeading() const { return this->font->fc->GetHeight(); }

		virtual int GetGlyphCount() const { return (int)this->glyphs.size(); }

		int GetAdvance() const { return this->total_advance; }

	};

	/** A single line worth of VisualRuns. */

	public:

		CoreTextLine(CTLineRef line, const FontMap &fontMapping, const CoreTextParagraphLayoutFactory::CharType *buff)

		{

			CFArrayRef runs = CTLineGetGlyphRuns(line);

			for (CFIndex i = 0; i < CFArrayGetCount(runs); i++) {

				CTRunRef run = (CTRunRef)CFArrayGetValueAtIndex(runs, i);

		virtual int GetLeading() const { return this->font->fc->GetHeight(); }

		virtual int GetGlyphCount() const { return this->num_glyphs; }

		int GetAdvance() const { return this->total_advance; }

	};

	/** A single line worth of VisualRuns. */

	public:

		virtual int GetLeading() const;

		virtual int GetWidth() const;

		virtual int CountRuns() const { return this->size();  }

		virtual const VisualRun *GetVisualRun(int run) const { return this->at(run);  }

	}

};

/** Container for dumping the savegame (quickly) to memory. */

struct MemoryDumper {

	byte *buf;                              ///< Buffer we're going to write to.

	byte *bufe;                             ///< End of the buffer we write to.

	/** Initialise our variables. */

	MemoryDumper() : buf(NULL), bufe(NULL)

	{

void IniLoadWindowSettings(IniFile *ini, const char *grpname, void *desc);

void IniSaveWindowSettings(IniFile *ini, const char *grpname, void *desc);

/* Functions to load and save NewGRF settings to a separate

 * configuration file, used for presets. */

void GetGRFPresetList(GRFPresetList *list);

struct GRFConfig *LoadGRFPresetFromConfig(const char *config_name);

void SaveGRFPresetToConfig(const char *config_name, struct GRFConfig *config);

void DeleteGRFPresetFromConfig(const char *config_name);

		default:

			return CalcClosestTownFromTile(tile, threshold);

	}

}

static bool _town_rating_test = false; ///< If \c true, town rating is in test-mode.

/**

 * Switch the town rating to test-mode, to allow commands to be tested without affecting current ratings.

 * The function is safe to use in nested calls.

 * @param mode Test mode switch (\c true means go to test-mode, \c false means leave test-mode).

 */

}

/**

 * List of vehicles that should check for autoreplace this tick.

 * Mapping of vehicle -> leave depot immediately after autoreplace.

 */

static AutoreplaceMap _vehicles_to_autoreplace;

void InitializeVehicles()

{

	_vehicles_to_autoreplace.clear();

	_vehicles_to_autoreplace.shrink_to_fit();

	void SetDimension(Dimension d);

};

/**

 * A drop down list is a collection of drop down list items.

 */

void ShowDropDownListAt(Window *w, const DropDownList *list, int selected, int button, Rect wi_rect, Colours wi_colour, bool auto_width = false, bool instant_close = false);

void ShowDropDownList(Window *w, const DropDownList *list, int selected, int button, uint width = 0, bool auto_width = false, bool instant_close = false);

#endif /* WIDGETS_DROPDOWN_TYPE_H */