uint16 vehicle_flags;               ///< Used for gradual loading and other miscellaneous things (@see VehicleFlags enum)

	void CopyConsistPropertiesFrom(const BaseConsist *src);

};

/** Base methods for 32bpp SSE blitters. */

class Blitter_32bppSSE_Base {

public:

	struct MapValue {

		uint8 m;

	 */

	virtual void PostResize() { };

	template <typename SetPixelT> void DrawLineGeneric(int x, int y, int x2, int y2, int screen_width, int screen_height, int width, int dash, SetPixelT set_pixel);

};

{

public:

	ZeroedMemoryAllocator() {}

	/**

	 * Memory allocator for a single class instance.

public:

	/** Stub destructor to silence some compilers. */

	char *FillCrashLog(char *buffer, const char *last) const;

	bool WriteCrashLog(const char *buffer, char *filename, const char *filename_last) const;

	DisasterVehicle() : SpecializedVehicleBase() {}

	DisasterVehicle(int x, int y, Direction direction, DisasterSubType subtype, VehicleID big_ufo_destroyer_target = VEH_INVALID);

	/** We want to 'destruct' the right class. */

	void UpdatePosition(int x, int y, int z);

	void UpdateDeltaXY();

	 */

	virtual void Stop() = 0;

	/** The type of driver */

	enum Type {

	/** We don't want GCC to zero our struct! It already is zeroed and has an index! */

	EffectVehicle() : SpecializedVehicleBase() {}

	/** We want to 'destruct' the right class. */

	void UpdateDeltaXY();

	bool Tick();

	Subdirectory subdir; ///< The current sub directory we are searching through

public:

	/** Destruct the proper one... */

	uint Scan(const char *extension, Subdirectory sd, bool tars = true, bool recursive = true);

	uint Scan(const char *extension, const std::string &directory, bool recursive = true);

 */

class ParagraphLayouter {

public:

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

	class VisualRun {

	public:

		virtual const Font *GetFont() const = 0;

		virtual int GetGlyphCount() const = 0;

		virtual const GlyphID *GetGlyphs() const = 0;

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

	class Line {

	public:

		virtual int GetLeading() const = 0;

		virtual int GetWidth() const = 0;

		virtual int CountRuns() const = 0;

	/**

	 * Virtual destructor has to be defined because of virtual Run().

	 */

};

#endif /* DEMANDS_H */

	FlowMapper(bool scale) : scale(scale) {}

	virtual void Run(LinkGraphJob &job) const;

private:

	/**

	 * @param job Job to be initialized.

	 */

	virtual void Run(LinkGraphJob &job) const { job.Init(); }

};

#endif /* INIT_H */

	/**

	 * Destroy the handler. Must be given due to virtual Run.

	 */

	/**

	 * Run the handler. A link graph handler must not read or write any data

	 * @param graph Component to be calculated.

	 */

	virtual void Run(LinkGraphJob &job) const { Tpass pass(job); }

};

#endif /* MCF_H */

	NetworkSocketHandler() { this->has_quit = false; }

	/** Close the socket when destructing the socket handler */

	/**

	 * Mark the connection as closed.

	virtual bool IsCancelled() const = 0;

	/** Silentium */

};

/** Base socket handler for HTTP traffic. */

	 * @param status The reason the connection got closed.

	 */

	virtual NetworkRecvStatus CloseConnection(NetworkRecvStatus status) = 0;

	/**

	 * Sets the client info for this socket handler.

	virtual void OnDownloadComplete(ContentID cid) {}

	/** Silentium */

};

/**

		this->height = d.height + WidgetDimensions::scaled.framerect.Vertical();

		this->width = d.width + WidgetDimensions::scaled.framerect.Horizontal();

	}

	/**

	 * OnClick handler for when the button is pressed.

	 * @param addresses The addresses to bind on.

	 */

	ServerNetworkUDPSocketHandler(NetworkAddressList *addresses) : NetworkUDPSocketHandler(addresses) {}

};

void ServerNetworkUDPSocketHandler::Receive_CLIENT_FIND_SERVER(Packet *p, NetworkAddress *client_addr)

protected:

	void Receive_SERVER_RESPONSE(Packet *p, NetworkAddress *client_addr) override;

public:

};

void ClientNetworkUDPSocketHandler::Receive_SERVER_RESPONSE(Packet *p, NetworkAddress *client_addr)

	std::vector<EntityIDMapping> mappings; ///< mapping of ids from grf files.  Public out of convenience

	OverrideManagerBase(uint16 offset, uint16 maximum, uint16 invalid);

	void ResetOverride();

	void ResetMapping();

/** Callback for NewGRF scanning. */

struct NewGRFScanCallback {

	/** Make sure the right destructor gets called. */

	/** Called whenever the NewGRF scan completed. */

	virtual void OnNewGRFsScanned() = 0;

};

class NIHelper {

public:

	/** Silence a warning. */

	/**

	 * Is the item with the given index inspectable?

	virtual const SpriteGroup *Resolve(ResolverObject &object) const { return this; };

public:

	uint32 nfo_line;

	SpriteGroupType type;

	ResolverObject &ro; ///< Surrounding resolver object.

	ScopeResolver(ResolverObject &ro) : ro(ro) {}

	virtual uint32 GetRandomBits() const;

	virtual uint32 GetTriggers() const;

		this->ResetState();

	}

	ScopeResolver default_scope; ///< Default implementation of the grf scope.

/** Container for any custom data that must be deleted after the news item has reached end-of-life. */

struct NewsAllocatedData {

};

	ChunkHandler(uint32 id, ChunkType type) : id(id), type(type) {}

	/**

	 * Save the chunk.

public:

	std::optional<std::vector<SaveLoad>> load_description;

	/**

	 * Save the object to disk.

	/**

	 * Virtual dtor, needed to mute warnings.

	 */

	/**

	 * Get the first item of the sorter.

	byte level; ///< Nesting level of this setting entry

	BaseSettingEntry() : flags(0), level(0) {}

	virtual void Init(byte level = 0);

	virtual void FoldAll() {}

struct SettingDesc {

	SettingDesc(const SaveLoad &save, SettingFlag flags, bool startup) :

		flags(flags), startup(startup), save(save) {}

	SettingFlag flags;  ///< Handles how a setting would show up in the GUI (text/currency, etc.).

	bool startup;       ///< Setting has to be loaded directly at startup?.

		SettingDesc(save, flags, startup), def(def), min(min), max(max), interval(interval),

			str(str), str_help(str_help), str_val(str_val), cat(cat), pre_check(pre_check),

			post_callback(post_callback) {}

	int32 def;              ///< default value given when none is present

	int32 min;              ///< minimum values

			PreChangeCheck pre_check, PostChangeCallback post_callback) :

		IntSettingDesc(save, flags, startup, def, 0, 1, 0, str, str_help, str_val, cat,

			pre_check, post_callback) {}

	bool IsBoolSetting() const override { return true; }

	size_t ParseValue(const char *str) const override;

		for (auto one : many) this->many.push_back(one);

	}

	std::vector<std::string> many; ///< possible values for this type

	OnConvert *many_cnvt;          ///< callback procedure when loading value mechanism fails

		std::initializer_list<const char *> many, OnConvert *many_cnvt) :

		OneOfManySettingDesc(save, flags, startup, def, (1 << many.size()) - 1, str, str_help,

			str_val, cat, pre_check, post_callback, many, many_cnvt) {}

	size_t ParseValue(const char *str) const override;

	void FormatValue(char *buf, const char *last, const void *object) const override;

			uint32 max_length, PreChangeCheck pre_check, PostChangeCallback post_callback) :

		SettingDesc(save, flags, startup), def(def == nullptr ? "" : def), max_length(max_length),

			pre_check(pre_check), post_callback(post_callback) {}

	std::string def;                   ///< Default value given when none is present

	uint32 max_length;                 ///< Maximum length of the string, 0 means no maximum length

struct ListSettingDesc : SettingDesc {

	ListSettingDesc(const SaveLoad &save, SettingFlag flags, bool startup, const char *def) :

		SettingDesc(save, flags, startup), def(def) {}

	const char *def;        ///< default value given when none is present

struct NullSettingDesc : SettingDesc {

	NullSettingDesc(const SaveLoad &save) :

		SettingDesc(save, SF_NOT_IN_CONFIG, false) {}

	void FormatValue(char *buf, const char *last, const void *object) const override { NOT_REACHED(); }

	void ParseValue(const IniItem *item, void *object) const override { NOT_REACHED(); }

	 */

	virtual uint8 LoadSprite(SpriteLoader::Sprite *sprite, SpriteFile &file, size_t file_pos, SpriteType sprite_type, bool load_32bpp, byte control_flags) = 0;

};

/** Interface for something that can encode a sprite. */

class SpriteEncoder {

public:

	/**

	 * Can the sprite encoder make use of RGBA sprites?

	virtual void Finalise(const StringData &data) = 0;

	/** Especially destroy the subclasses. */

	void WriteHeader(const StringData &data);

};

	virtual void Finalise() = 0;

	/** Especially destroy the subclasses. */

	virtual void WriteLength(uint length);

	virtual void WriteLang(const StringData &data);

	 */

	static std::unique_ptr<StringIterator> Create();

	/**

	 * Set a new iteration string. Must also be called if the string contents

class MissingGlyphSearcher {

public:

	/** Make sure everything gets destructed right. */

	/**

	 * Get the next string to search through.

	bool masked; ///< Masked and unselectable item

	DropDownListItem(int result, bool masked) : result(result), masked(masked) {}

	virtual bool Selectable() const { return false; }

	virtual uint Height(uint width) const { return FONT_HEIGHT_NORMAL; }