(svn r11661) -Codechange: some header reworks in order to try to reduce the compile time of OpenTTD by reduce the amount of circular-ish dependencies.

19 files changed, 257 insertions, 234 deletions

diff --git a/src/airport.h b/src/airport.h
index 95501dfec..756a03c89 100644
--- a/src/airport.h
+++ b/src/airport.h
@@ -5,7 +5,7 @@
 #ifndef AIRPORT_H
 #define AIRPORT_H
 
-#include "direction.h"
+#include "direction_type.h"
 
 enum {MAX_TERMINALS =  10};
 enum {MAX_HELIPADS  =   4};
diff --git a/src/bridge_map.h b/src/bridge_map.h
index 3a329d93b..13030092f 100644
--- a/src/bridge_map.h
+++ b/src/bridge_map.h
@@ -5,7 +5,7 @@
 #ifndef BRIDGE_MAP_H
 #define BRIDGE_MAP_H
 
-#include "direction.h"
+#include "direction_func.h"
 #include "macros.h"
 #include "map.h"
 #include "rail.h"
diff --git a/src/cmd_helper.h b/src/cmd_helper.h
index 115b0e1cf..9fad39735 100644
--- a/src/cmd_helper.h
+++ b/src/cmd_helper.h
@@ -3,7 +3,7 @@
 #ifndef CMD_HELPER_H
 #define CMD_HELPER_H
 
-#include "direction.h"
+#include "direction_type.h"
 #include "macros.h"
 #include "road.h"
 
diff --git a/src/core/enum_type.hpp b/src/core/enum_type.hpp
new file mode 100644
index 000000000..725d3985f
--- /dev/null
+++ b/src/core/enum_type.hpp
@@ -0,0 +1,115 @@
+/* $Id$ */
+
+/** @file enum_type.hpp Type (helpers) for enums */
+
+#ifndef ENUM_TYPE_HPP
+#define ENUM_TYPE_HPP
+
+/** Some enums need to have allowed incrementing (i.e. StationClassID) */
+#define DECLARE_POSTFIX_INCREMENT(type) \
+	FORCEINLINE type operator ++(type& e, int) \
+	{ \
+		type e_org = e; \
+		e = (type)((int)e + 1); \
+		return e_org; \
+	} \
+	FORCEINLINE type operator --(type& e, int) \
+	{ \
+		type e_org = e; \
+		e = (type)((int)e - 1); \
+		return e_org; \
+	}
+
+
+
+/** Operators to allow to work with enum as with type safe bit set in C++ */
+# define DECLARE_ENUM_AS_BIT_SET(mask_t) \
+	FORCEINLINE mask_t operator | (mask_t m1, mask_t m2) {return (mask_t)((int)m1 | m2);} \
+	FORCEINLINE mask_t operator & (mask_t m1, mask_t m2) {return (mask_t)((int)m1 & m2);} \
+	FORCEINLINE mask_t operator ^ (mask_t m1, mask_t m2) {return (mask_t)((int)m1 ^ m2);} \
+	FORCEINLINE mask_t& operator |= (mask_t& m1, mask_t m2) {m1 = m1 | m2; return m1;} \
+	FORCEINLINE mask_t& operator &= (mask_t& m1, mask_t m2) {m1 = m1 & m2; return m1;} \
+	FORCEINLINE mask_t& operator ^= (mask_t& m1, mask_t m2) {m1 = m1 ^ m2; return m1;} \
+	FORCEINLINE mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);}
+
+
+/** Informative template class exposing basic enumeration properties used by several
+ *  other templates below. Here we have only forward declaration. For each enum type
+ *  we will create specialization derived from MakeEnumPropsT<>.
+ *  i.e.:
+ *    template <> struct EnumPropsT<Track> : MakeEnumPropsT<Track, byte, TRACK_BEGIN, TRACK_END, INVALID_TRACK> {};
+ *  followed by:
+ *    typedef TinyEnumT<Track> TrackByte;
+ */
+template <typename Tenum_t> struct EnumPropsT;
+
+/** Helper template class that makes basic properties of given enumeration type visible
+ *  from outsize. It is used as base class of several EnumPropsT specializations each
+ *  dedicated to one of commonly used enumeration types.
+ *  @param Tenum_t enumeration type that you want to describe
+ *  @param Tstorage_t what storage type would be sufficient (i.e. byte)
+ *  @param Tbegin first valid value from the contiguous range (i.e. TRACK_BEGIN)
+ *  @param Tend one past the last valid value from the contiguous range (i.e. TRACK_END)
+ *  @param Tinvalid value used as invalid value marker (i.e. INVALID_TRACK)
+ */
+template <typename Tenum_t, typename Tstorage_t, Tenum_t Tbegin, Tenum_t Tend, Tenum_t Tinvalid>
+struct MakeEnumPropsT {
+	typedef Tenum_t type;                     ///< enum type (i.e. Trackdir)
+	typedef Tstorage_t storage;               ///< storage type (i.e. byte)
+	static const Tenum_t begin = Tbegin;      ///< lowest valid value (i.e. TRACKDIR_BEGIN)
+	static const Tenum_t end = Tend;          ///< one after the last valid value (i.e. TRACKDIR_END)
+	static const Tenum_t invalid = Tinvalid;  ///< what value is used as invalid value (i.e. INVALID_TRACKDIR)
+};
+
+
+
+/** In some cases we use byte or uint16 to store values that are defined as enum. It is
+	*  necessary in order to control the sizeof() such values. Some compilers make enum
+	*  the same size as int (4 or 8 bytes instead of 1 or 2). As a consequence the strict
+	*  compiler type-checking causes errors like:
+	*     'HasPowerOnRail' : cannot convert parameter 1 from 'byte' to 'RailType' when
+	*  u->u.rail.railtype is passed as argument or type RailType. In such cases it is better
+	*  to teach the compiler that u->u.rail.railtype is to be treated as RailType. */
+template <typename Tenum_t> struct TinyEnumT;
+
+/** The general declaration of TinyEnumT<> (above) */
+template <typename Tenum_t> struct TinyEnumT
+{
+	typedef Tenum_t enum_type;                      ///< expose our enumeration type (i.e. Trackdir) to outside
+	typedef EnumPropsT<Tenum_t> Props;              ///< make easier access to our enumeration propeties
+	typedef typename Props::storage storage_type;   ///< small storage type
+	static const enum_type begin = Props::begin;    ///< enum beginning (i.e. TRACKDIR_BEGIN)
+	static const enum_type end = Props::end;        ///< enum end (i.e. TRACKDIR_END)
+	static const enum_type invalid = Props::invalid;///< invalid value (i.e. INVALID_TRACKDIR)
+
+	storage_type m_val;  ///< here we hold the actual value in small (i.e. byte) form
+
+	/** Cast operator - invoked then the value is assigned to the Tenum_t type */
+	FORCEINLINE operator enum_type () const
+	{
+		return (enum_type)m_val;
+	}
+
+	/** Assignment operator (from Tenum_t type) */
+	FORCEINLINE TinyEnumT& operator = (enum_type e)
+	{
+		m_val = (storage_type)e; return *this;
+	}
+
+	/** postfix ++ operator on tiny type */
+	FORCEINLINE TinyEnumT operator ++ (int)
+	{
+		TinyEnumT org = *this;
+		if (++m_val >= end) m_val -= (storage_type)(end - begin);
+		return org;
+	}
+
+	/** prefix ++ operator on tiny type */
+	FORCEINLINE TinyEnumT& operator ++ ()
+	{
+		if (++m_val >= end) m_val -= (storage_type)(end - begin);
+		return *this;
+	}
+};
+
+#endif /* HELPERS_HPP */
diff --git a/src/depot.h b/src/depot.h
index 2b47452cd..baa53573c 100644
--- a/src/depot.h
+++ b/src/depot.h
@@ -5,7 +5,7 @@
 #ifndef DEPOT_H
 #define DEPOT_H
 
-#include "direction.h"
+#include "direction_type.h"
 #include "oldpool.h"
 #include "tile.h"
 #include "variables.h"
diff --git a/src/direction.h b/src/direction_func.h
index 9e678c9c9..2cfe99534 100644
--- a/src/direction.h
+++ b/src/direction_func.h
@@ -1,38 +1,11 @@
 /* $Id$ */
 
-/** @file direction.h */
+/** @file direction_func.h Different functions related to conversions between directions. */
 
-#ifndef DIRECTION_H
-#define DIRECTION_H
+#ifndef DIRECTION_FUNC_H
+#define DIRECTION_FUNC_H
 
-#include "helpers.hpp"
-
-/**
- * Defines the 8 directions on the map.
- *
- * This enum defines 8 possible directions which are used for
- * the vehicles in the game. The directions are aligned straight
- * to the viewport, not to the map. So north points to the top of
- * your viewport and not rotated by 45 degrees left or right to get
- * a "north" used in you games.
- */
-enum Direction {
-	DIR_BEGIN = 0,          ///< Used to iterate
-	DIR_N   = 0,            ///< North
-	DIR_NE  = 1,            ///< Northeast
-	DIR_E   = 2,            ///< East
-	DIR_SE  = 3,            ///< Southeast
-	DIR_S   = 4,            ///< South
-	DIR_SW  = 5,            ///< Southwest
-	DIR_W   = 6,            ///< West
-	DIR_NW  = 7,            ///< Northwest
-	DIR_END,                ///< Used to iterate
-	INVALID_DIR = 0xFF,     ///< Flag for an invalid direction
-};
-
-/** Define basic enum properties */
-template <> struct EnumPropsT<Direction> : MakeEnumPropsT<Direction, byte, DIR_BEGIN, DIR_END, INVALID_DIR> {};
-typedef TinyEnumT<Direction> DirectionByte; //typedefing-enumification of Direction
+#include "direction_type.h"
 
 /**
  * Return the reverse of a direction
@@ -47,32 +20,6 @@ static inline Direction ReverseDir(Direction d)
 
 
 /**
- * Enumeration for the difference between two directions.
- *
- * This enumeration is used to mark differences between
- * two directions. If you get one direction you can align
- * a second direction in 8 different ways. This enumeration
- * only contains 6 of these 8 differences, but the remaining
- * two can be calculated by adding to differences together.
- * This also means you can add two differences together and
- * get the difference you really want to get. The difference
- * of 45 degrees left + the difference of 45 degrees right results in the
- * difference of 0 degrees.
- *
- * @note To get this mentioned addition of direction you must use
- *       modulo DIR_END or use the #ChangeDirDiff(DirDiff, DirDiff) function.
- * @see ChangeDirDiff(DirDiff, DirDiff)
- */
-enum DirDiff {
-	DIRDIFF_SAME    = 0,    ///< Both directions faces to the same direction
-	DIRDIFF_45RIGHT = 1,    ///< Angle of 45 degrees right
-	DIRDIFF_90RIGHT = 2,    ///< Angle of 90 degrees right
-	DIRDIFF_REVERSE = 4,    ///< One direction is the opposit of the other one
-	DIRDIFF_90LEFT  = 6,    ///< Angle of 90 degrees left
-	DIRDIFF_45LEFT  = 7     ///< Angle of 45 degrees left
-};
-
-/**
  * Calculate the difference between to directions
  *
  * @param d0 The first direction as the base
@@ -117,27 +64,6 @@ static inline Direction ChangeDir(Direction d, DirDiff delta)
 
 
 /**
- * Enumeration for diagonal directions.
- *
- * This enumeration is used for the 4 direction of the tile-edges.
- */
-enum DiagDirection {
-	DIAGDIR_BEGIN = 0,      ///< Used for iterations
-	DIAGDIR_NE  = 0,        ///< Northeast, upper right on your monitor
-	DIAGDIR_SE  = 1,        ///< Southeast
-	DIAGDIR_SW  = 2,        ///< Southwest
-	DIAGDIR_NW  = 3,        ///< Northwest
-	DIAGDIR_END,            ///< Used for iterations
-	INVALID_DIAGDIR = 0xFF, ///< Flag for an invalid DiagDirection
-};
-
-DECLARE_POSTFIX_INCREMENT(DiagDirection);
-
-/** Define basic enum properties */
-template <> struct EnumPropsT<DiagDirection> : MakeEnumPropsT<DiagDirection, byte, DIAGDIR_BEGIN, DIAGDIR_END, INVALID_DIAGDIR> {};
-typedef TinyEnumT<DiagDirection> DiagDirectionByte; //typedefing-enumification of DiagDirection
-
-/**
  * Returns the reverse direction of the given DiagDirection
  *
  * @param d The DiagDirection to get the reverse from
@@ -148,25 +74,6 @@ static inline DiagDirection ReverseDiagDir(DiagDirection d)
 	return (DiagDirection)(2 ^ d);
 }
 
-/**
- * Enumeration for the difference between to DiagDirection.
- *
- * As the DiagDirection only contains 4 possible directions the
- * difference between two of these directions can only be in 4 ways.
- * As the DirDiff enumeration the values can be added together and
- * you will get the resulting difference (use modulo DIAGDIR_END).
- *
- * @see DirDiff
- */
-enum DiagDirDiff {
-	DIAGDIRDIFF_SAME    = 0,        ///< Same directions
-	DIAGDIRDIFF_90RIGHT = 1,        ///< 90 degrees right
-	DIAGDIRDIFF_REVERSE = 2,        ///< Reverse directions
-	DIAGDIRDIFF_90LEFT  = 3         ///< 90 degrees left
-};
-
-/** Allow incrementing of DiagDirDiff variables */
-DECLARE_POSTFIX_INCREMENT(DiagDirDiff);
 
 /**
  * Applies a difference on a DiagDirection
@@ -215,21 +122,6 @@ static inline Direction DiagDirToDir(DiagDirection dir)
 
 
 /**
- * Enumeration for the two axis X and Y
- *
- * This enumeration represente the two axis X and Y in the game.
- * The X axis is the one which goes align the north-west edge
- * (and south-east edge). The Y axis must be so the one which goes
- * align the north-east edge (and south-west) edge.
- */
-enum Axis {
-	AXIS_X = 0,     ///< The X axis
-	AXIS_Y = 1,     ///< The y axis
-	AXIS_END        ///< Used for iterations
-};
-
-
-/**
  * Select the other axis as provided.
  *
  * This is basically the not-operator for the axis.
diff --git a/src/direction_type.h b/src/direction_type.h
new file mode 100644
index 000000000..d1f8d8920
--- /dev/null
+++ b/src/direction_type.h
@@ -0,0 +1,122 @@
+/* $Id$ */
+
+/** @file direction_type.h Different types to 'show' directions. */
+
+#ifndef DIRECTION_TYPE_H
+#define DIRECTION_TYPE_H
+
+#include "core/enum_type.hpp"
+
+/**
+ * Defines the 8 directions on the map.
+ *
+ * This enum defines 8 possible directions which are used for
+ * the vehicles in the game. The directions are aligned straight
+ * to the viewport, not to the map. So north points to the top of
+ * your viewport and not rotated by 45 degrees left or right to get
+ * a "north" used in you games.
+ */
+enum Direction {
+	DIR_BEGIN = 0,          ///< Used to iterate
+	DIR_N   = 0,            ///< North
+	DIR_NE  = 1,            ///< Northeast
+	DIR_E   = 2,            ///< East
+	DIR_SE  = 3,            ///< Southeast
+	DIR_S   = 4,            ///< South
+	DIR_SW  = 5,            ///< Southwest
+	DIR_W   = 6,            ///< West
+	DIR_NW  = 7,            ///< Northwest
+	DIR_END,                ///< Used to iterate
+	INVALID_DIR = 0xFF,     ///< Flag for an invalid direction
+};
+
+/** Define basic enum properties */
+template <> struct EnumPropsT<Direction> : MakeEnumPropsT<Direction, byte, DIR_BEGIN, DIR_END, INVALID_DIR> {};
+typedef TinyEnumT<Direction> DirectionByte; //typedefing-enumification of Direction
+
+
+/**
+ * Enumeration for the difference between two directions.
+ *
+ * This enumeration is used to mark differences between
+ * two directions. If you get one direction you can align
+ * a second direction in 8 different ways. This enumeration
+ * only contains 6 of these 8 differences, but the remaining
+ * two can be calculated by adding to differences together.
+ * This also means you can add two differences together and
+ * get the difference you really want to get. The difference
+ * of 45 degrees left + the difference of 45 degrees right results in the
+ * difference of 0 degrees.
+ *
+ * @note To get this mentioned addition of direction you must use
+ *       modulo DIR_END or use the #ChangeDirDiff(DirDiff, DirDiff) function.
+ * @see ChangeDirDiff(DirDiff, DirDiff)
+ */
+enum DirDiff {
+	DIRDIFF_SAME    = 0,    ///< Both directions faces to the same direction
+	DIRDIFF_45RIGHT = 1,    ///< Angle of 45 degrees right
+	DIRDIFF_90RIGHT = 2,    ///< Angle of 90 degrees right
+	DIRDIFF_REVERSE = 4,    ///< One direction is the opposit of the other one
+	DIRDIFF_90LEFT  = 6,    ///< Angle of 90 degrees left
+	DIRDIFF_45LEFT  = 7     ///< Angle of 45 degrees left
+};
+
+
+/**
+ * Enumeration for diagonal directions.
+ *
+ * This enumeration is used for the 4 direction of the tile-edges.
+ */
+enum DiagDirection {
+	DIAGDIR_BEGIN = 0,      ///< Used for iterations
+	DIAGDIR_NE  = 0,        ///< Northeast, upper right on your monitor
+	DIAGDIR_SE  = 1,        ///< Southeast
+	DIAGDIR_SW  = 2,        ///< Southwest
+	DIAGDIR_NW  = 3,        ///< Northwest
+	DIAGDIR_END,            ///< Used for iterations
+	INVALID_DIAGDIR = 0xFF, ///< Flag for an invalid DiagDirection
+};
+
+DECLARE_POSTFIX_INCREMENT(DiagDirection);
+
+/** Define basic enum properties */
+template <> struct EnumPropsT<DiagDirection> : MakeEnumPropsT<DiagDirection, byte, DIAGDIR_BEGIN, DIAGDIR_END, INVALID_DIAGDIR> {};
+typedef TinyEnumT<DiagDirection> DiagDirectionByte; //typedefing-enumification of DiagDirection
+
+
+/**
+ * Enumeration for the difference between to DiagDirection.
+ *
+ * As the DiagDirection only contains 4 possible directions the
+ * difference between two of these directions can only be in 4 ways.
+ * As the DirDiff enumeration the values can be added together and
+ * you will get the resulting difference (use modulo DIAGDIR_END).
+ *
+ * @see DirDiff
+ */
+enum DiagDirDiff {
+	DIAGDIRDIFF_SAME    = 0,        ///< Same directions
+	DIAGDIRDIFF_90RIGHT = 1,        ///< 90 degrees right
+	DIAGDIRDIFF_REVERSE = 2,        ///< Reverse directions
+	DIAGDIRDIFF_90LEFT  = 3         ///< 90 degrees left
+};
+
+/** Allow incrementing of DiagDirDiff variables */
+DECLARE_POSTFIX_INCREMENT(DiagDirDiff);
+
+
+/**
+ * Enumeration for the two axis X and Y
+ *
+ * This enumeration represente the two axis X and Y in the game.
+ * The X axis is the one which goes align the north-west edge
+ * (and south-east edge). The Y axis must be so the one which goes
+ * align the north-east edge (and south-west) edge.
+ */
+enum Axis {
+	AXIS_X = 0,     ///< The X axis
+	AXIS_Y = 1,     ///< The y axis
+	AXIS_END        ///< Used for iterations
+};
+
+#endif /* DIRECTION_TYPE_H */
diff --git a/src/helpers.hpp b/src/helpers.hpp
index 651cb0f3c..d7bedae55 100644
--- a/src/helpers.hpp
+++ b/src/helpers.hpp
@@ -6,6 +6,7 @@
 #define HELPERS_HPP
 
 #include "macros.h"
+#include "core/enum_type.hpp"
 
 /** When allocating using malloc/calloc in C++ it is usually needed to cast the return value
 *  from void* to the proper pointer type. Another alternative would be MallocT<> as follows */
@@ -42,113 +43,6 @@ template<typename T> void Swap(T& a, T& b)
 }
 
 
-/** Some enums need to have allowed incrementing (i.e. StationClassID) */
-#define DECLARE_POSTFIX_INCREMENT(type) \
-	FORCEINLINE type operator ++(type& e, int) \
-	{ \
-		type e_org = e; \
-		e = (type)((int)e + 1); \
-		return e_org; \
-	} \
-	FORCEINLINE type operator --(type& e, int) \
-	{ \
-		type e_org = e; \
-		e = (type)((int)e - 1); \
-		return e_org; \
-	}
-
-
-
-/** Operators to allow to work with enum as with type safe bit set in C++ */
-# define DECLARE_ENUM_AS_BIT_SET(mask_t) \
-	FORCEINLINE mask_t operator | (mask_t m1, mask_t m2) {return (mask_t)((int)m1 | m2);} \
-	FORCEINLINE mask_t operator & (mask_t m1, mask_t m2) {return (mask_t)((int)m1 & m2);} \
-	FORCEINLINE mask_t operator ^ (mask_t m1, mask_t m2) {return (mask_t)((int)m1 ^ m2);} \
-	FORCEINLINE mask_t& operator |= (mask_t& m1, mask_t m2) {m1 = m1 | m2; return m1;} \
-	FORCEINLINE mask_t& operator &= (mask_t& m1, mask_t m2) {m1 = m1 & m2; return m1;} \
-	FORCEINLINE mask_t& operator ^= (mask_t& m1, mask_t m2) {m1 = m1 ^ m2; return m1;} \
-	FORCEINLINE mask_t operator ~(mask_t m) {return (mask_t)(~(int)m);}
-
-
-/** Informative template class exposing basic enumeration properties used by several
- *  other templates below. Here we have only forward declaration. For each enum type
- *  we will create specialization derived from MakeEnumPropsT<>.
- *  i.e.:
- *    template <> struct EnumPropsT<Track> : MakeEnumPropsT<Track, byte, TRACK_BEGIN, TRACK_END, INVALID_TRACK> {};
- *  followed by:
- *    typedef TinyEnumT<Track> TrackByte;
- */
-template <typename Tenum_t> struct EnumPropsT;
-
-/** Helper template class that makes basic properties of given enumeration type visible
- *  from outsize. It is used as base class of several EnumPropsT specializations each
- *  dedicated to one of commonly used enumeration types.
- *  @param Tenum_t enumeration type that you want to describe
- *  @param Tstorage_t what storage type would be sufficient (i.e. byte)
- *  @param Tbegin first valid value from the contiguous range (i.e. TRACK_BEGIN)
- *  @param Tend one past the last valid value from the contiguous range (i.e. TRACK_END)
- *  @param Tinvalid value used as invalid value marker (i.e. INVALID_TRACK)
- */
-template <typename Tenum_t, typename Tstorage_t, Tenum_t Tbegin, Tenum_t Tend, Tenum_t Tinvalid>
-struct MakeEnumPropsT {
-	typedef Tenum_t type;                     ///< enum type (i.e. Trackdir)
-	typedef Tstorage_t storage;               ///< storage type (i.e. byte)
-	static const Tenum_t begin = Tbegin;      ///< lowest valid value (i.e. TRACKDIR_BEGIN)
-	static const Tenum_t end = Tend;          ///< one after the last valid value (i.e. TRACKDIR_END)
-	static const Tenum_t invalid = Tinvalid;  ///< what value is used as invalid value (i.e. INVALID_TRACKDIR)
-};
-
-
-
-/** In some cases we use byte or uint16 to store values that are defined as enum. It is
-	*  necessary in order to control the sizeof() such values. Some compilers make enum
-	*  the same size as int (4 or 8 bytes instead of 1 or 2). As a consequence the strict
-	*  compiler type-checking causes errors like:
-	*     'HasPowerOnRail' : cannot convert parameter 1 from 'byte' to 'RailType' when
-	*  u->u.rail.railtype is passed as argument or type RailType. In such cases it is better
-	*  to teach the compiler that u->u.rail.railtype is to be treated as RailType. */
-template <typename Tenum_t> struct TinyEnumT;
-
-/** The general declaration of TinyEnumT<> (above) */
-template <typename Tenum_t> struct TinyEnumT
-{
-	typedef Tenum_t enum_type;                      ///< expose our enumeration type (i.e. Trackdir) to outside
-	typedef EnumPropsT<Tenum_t> Props;              ///< make easier access to our enumeration propeties
-	typedef typename Props::storage storage_type;   ///< small storage type
-	static const enum_type begin = Props::begin;    ///< enum beginning (i.e. TRACKDIR_BEGIN)
-	static const enum_type end = Props::end;        ///< enum end (i.e. TRACKDIR_END)
-	static const enum_type invalid = Props::invalid;///< invalid value (i.e. INVALID_TRACKDIR)
-
-	storage_type m_val;  ///< here we hold the actual value in small (i.e. byte) form
-
-	/** Cast operator - invoked then the value is assigned to the Tenum_t type */
-	FORCEINLINE operator enum_type () const
-	{
-		return (enum_type)m_val;
-	}
-
-	/** Assignment operator (from Tenum_t type) */
-	FORCEINLINE TinyEnumT& operator = (enum_type e)
-	{
-		m_val = (storage_type)e; return *this;
-	}
-
-	/** postfix ++ operator on tiny type */
-	FORCEINLINE TinyEnumT operator ++ (int)
-	{
-		TinyEnumT org = *this;
-		if (++m_val >= end) m_val -= (storage_type)(end - begin);
-		return org;
-	}
-
-	/** prefix ++ operator on tiny type */
-	FORCEINLINE TinyEnumT& operator ++ ()
-	{
-		if (++m_val >= end) m_val -= (storage_type)(end - begin);
-		return *this;
-	}
-};
-
 /**
  * Overflow safe template for integers, i.e. integers that will never overflow
  * you multiply the maximum value with 2, or add 2, or substract somethng from
diff --git a/src/map.cpp b/src/map.cpp
index a54760652..60cad92b0 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -8,7 +8,7 @@
 #include "functions.h"
 #include "macros.h"
 #include "map.h"
-#include "direction.h"
+#include "direction_func.h"
 #include "helpers.hpp"
 
 #if defined(_MSC_VER) && _MSC_VER >= 1400 /* VStudio 2005 is stupid! */
diff --git a/src/map.h b/src/map.h
index 064e595c1..aac084193 100644
--- a/src/map.h
+++ b/src/map.h
@@ -6,7 +6,7 @@
 #define MAP_H
 
 #include "stdafx.h"
-#include "direction.h"
+#include "direction_func.h"
 
 extern uint _map_tile_mask;
 
diff --git a/src/misc/dbg_helpers.cpp b/src/misc/dbg_helpers.cpp
index 561de50f3..2e95ee1b8 100644
--- a/src/misc/dbg_helpers.cpp
+++ b/src/misc/dbg_helpers.cpp
@@ -2,7 +2,7 @@
 
 /** @file dbg_helpers.cpp */
 #include "../stdafx.h"
-#include "../direction.h"
+#include "../direction_type.h"
 #include "../rail.h"
 #include "../rail_map.h"
 #include "dbg_helpers.h"
diff --git a/src/newgrf_engine.h b/src/newgrf_engine.h
index bb86661e2..c94bff9b6 100644
--- a/src/newgrf_engine.h
+++ b/src/newgrf_engine.h
@@ -6,7 +6,7 @@
 #define NEWGRF_ENGINE_H
 
 #include "newgrf.h"
-#include "direction.h"
+#include "direction_type.h"
 #include "newgrf_cargo.h"
 
 extern int _traininfo_vehicle_pitch;
diff --git a/src/pathfind.h b/src/pathfind.h
index 2bafe97f3..91dd7be6f 100644
--- a/src/pathfind.h
+++ b/src/pathfind.h
@@ -5,7 +5,7 @@
 #ifndef PATHFIND_H
 #define PATHFIND_H
 
-#include "direction.h"
+#include "direction_type.h"
 #include "openttd.h"
 
 enum {
diff --git a/src/rail.h b/src/rail.h
index 8f965aa7b..30d7e7e4e 100644
--- a/src/rail.h
+++ b/src/rail.h
@@ -6,7 +6,7 @@
 #define RAIL_H
 
 #include "gfx.h"
-#include "direction.h"
+#include "direction_func.h"
 #include "tile.h"
 #include "variables.h"
 
diff --git a/src/rail_map.h b/src/rail_map.h
index 2b20e9598..3c89b8f78 100644
--- a/src/rail_map.h
+++ b/src/rail_map.h
@@ -5,7 +5,7 @@
 #ifndef RAIL_MAP_H
 #define RAIL_MAP_H
 
-#include "direction.h"
+#include "direction_func.h"
 #include "rail.h"
 #include "tile.h"
 
diff --git a/src/road_cmd.h b/src/road_cmd.h
index 66ea2f652..c5d98daf2 100644
--- a/src/road_cmd.h
+++ b/src/road_cmd.h
@@ -5,7 +5,7 @@
 #ifndef ROAD_CMD_H
 #define ROAD_CMD_H
 
-#include "direction.h"
+#include "direction_type.h"
 
 void DrawRoadDepotSprite(int x, int y, DiagDirection dir, RoadType rt);
 
diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp
index 2b32faff3..5d56be133 100644
--- a/src/train_cmd.cpp
+++ b/src/train_cmd.cpp
@@ -36,7 +36,7 @@
 #include "newgrf_engine.h"
 #include "newgrf_sound.h"
 #include "newgrf_text.h"
-#include "direction.h"
+#include "direction_func.h"
 #include "yapf/yapf.h"
 #include "date.h"
 #include "cargotype.h"
diff --git a/src/tunnel_map.h b/src/tunnel_map.h
index 921137a6e..5226c1f90 100644
--- a/src/tunnel_map.h
+++ b/src/tunnel_map.h
@@ -5,7 +5,7 @@
 #ifndef TUNNEL_MAP_H
 #define TUNNEL_MAP_H
 
-#include "direction.h"
+#include "direction_func.h"
 #include "macros.h"
 #include "map.h"
 #include "rail.h"
diff --git a/src/tunnelbridge_map.h b/src/tunnelbridge_map.h
index dda1cc258..892d4ed58 100644
--- a/src/tunnelbridge_map.h
+++ b/src/tunnelbridge_map.h
@@ -5,7 +5,7 @@
 #ifndef TUNNELBRIDGE_MAP_H
 #define TUNNELBRIDGE_MAP_H
 
-#include "direction.h"            /* DiagDirection */
+#include "direction_func.h"
 #include "core/bitmath_func.hpp"  /* GB, HasBit, SB */
 #include "map.h"                  /* Tile, TileIndex */
 #include "tile.h"                 /* TileType, IsTileType */