|
@@ -130,125 +130,125 @@ struct BaseStation : StationPool::PoolIt
|
|
|
* the given tile.
|
|
|
* @param tile the tile from which to start searching. Must be a rail station tile
|
|
|
* @param dir The direction in which to search.
|
|
|
* @return The platform length
|
|
|
*/
|
|
|
virtual uint GetPlatformLength(TileIndex tile, DiagDirection dir) const = 0;
|
|
|
|
|
|
/**
|
|
|
* Get the base station belonging to a specific tile.
|
|
|
* @param tile The tile to get the base station from.
|
|
|
* @return the station associated with that tile.
|
|
|
*/
|
|
|
static FORCEINLINE BaseStation *GetByTile(TileIndex tile)
|
|
|
static inline BaseStation *GetByTile(TileIndex tile)
|
|
|
{
|
|
|
return BaseStation::Get(GetStationIndex(tile));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Check whether the base station currently is in use; in use means
|
|
|
* that it is not scheduled for deletion and that it still has some
|
|
|
* facilities left.
|
|
|
* @return true if still in use
|
|
|
*/
|
|
|
FORCEINLINE bool IsInUse() const
|
|
|
inline bool IsInUse() const
|
|
|
{
|
|
|
return (this->facilities & ~FACIL_WAYPOINT) != 0;
|
|
|
}
|
|
|
|
|
|
static void PostDestructor(size_t index);
|
|
|
};
|
|
|
|
|
|
#define FOR_ALL_BASE_STATIONS(var) FOR_ALL_ITEMS_FROM(BaseStation, station_index, var, 0)
|
|
|
|
|
|
/**
|
|
|
* Class defining several overloaded accessors so we don't
|
|
|
* have to cast base stations that often
|
|
|
*/
|
|
|
template <class T, bool Tis_waypoint>
|
|
|
struct SpecializedStation : public BaseStation {
|
|
|
static const StationFacility EXPECTED_FACIL = Tis_waypoint ? FACIL_WAYPOINT : FACIL_NONE; ///< Specialized type
|
|
|
|
|
|
/**
|
|
|
* Set station type correctly
|
|
|
* @param tile The base tile of the station.
|
|
|
*/
|
|
|
FORCEINLINE SpecializedStation<T, Tis_waypoint>(TileIndex tile) :
|
|
|
inline SpecializedStation<T, Tis_waypoint>(TileIndex tile) :
|
|
|
BaseStation(tile)
|
|
|
{
|
|
|
this->facilities = EXPECTED_FACIL;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Helper for checking whether the given station is of this type.
|
|
|
* @param st the station to check.
|
|
|
* @return true if the station is the type we expect it to be.
|
|
|
*/
|
|
|
static FORCEINLINE bool IsExpected(const BaseStation *st)
|
|
|
static inline bool IsExpected(const BaseStation *st)
|
|
|
{
|
|
|
return (st->facilities & FACIL_WAYPOINT) == EXPECTED_FACIL;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Tests whether given index is a valid index for station of this type
|
|
|
* @param index tested index
|
|
|
* @return is this index valid index of T?
|
|
|
*/
|
|
|
static FORCEINLINE bool IsValidID(size_t index)
|
|
|
static inline bool IsValidID(size_t index)
|
|
|
{
|
|
|
return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Gets station with given index
|
|
|
* @return pointer to station with given index casted to T *
|
|
|
*/
|
|
|
static FORCEINLINE T *Get(size_t index)
|
|
|
static inline T *Get(size_t index)
|
|
|
{
|
|
|
return (T *)BaseStation::Get(index);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Returns station if the index is a valid index for this station type
|
|
|
* @return pointer to station with given index if it's a station of this type
|
|
|
*/
|
|
|
static FORCEINLINE T *GetIfValid(size_t index)
|
|
|
static inline T *GetIfValid(size_t index)
|
|
|
{
|
|
|
return IsValidID(index) ? Get(index) : NULL;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Get the station belonging to a specific tile.
|
|
|
* @param tile The tile to get the station from.
|
|
|
* @return the station associated with that tile.
|
|
|
*/
|
|
|
static FORCEINLINE T *GetByTile(TileIndex tile)
|
|
|
static inline T *GetByTile(TileIndex tile)
|
|
|
{
|
|
|
return GetIfValid(GetStationIndex(tile));
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a BaseStation to SpecializedStation with type checking.
|
|
|
* @param st BaseStation pointer
|
|
|
* @return pointer to SpecializedStation
|
|
|
*/
|
|
|
static FORCEINLINE T *From(BaseStation *st)
|
|
|
static inline T *From(BaseStation *st)
|
|
|
{
|
|
|
assert(IsExpected(st));
|
|
|
return (T *)st;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Converts a const BaseStation to const SpecializedStation with type checking.
|
|
|
* @param st BaseStation pointer
|
|
|
* @return pointer to SpecializedStation
|
|
|
*/
|
|
|
static FORCEINLINE const T *From(const BaseStation *st)
|
|
|
static inline const T *From(const BaseStation *st)
|
|
|
{
|
|
|
assert(IsExpected(st));
|
|
|
return (const T *)st;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
#define FOR_ALL_BASE_STATIONS_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, station_index, var, 0) if (name::IsExpected(var))
|
|
|
|
|
|
#endif /* BASE_STATION_BASE_H */
|