saveload.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef SAVELOAD_H
#define SAVELOAD_H
 
#include "saveload_type.h"
#include "saveload_error.hpp"
#include "saveload_func.h"
#include "../core/label_type.hpp"
#include "../fileio_type.h"
#include "../fios.h"

enum class SaveLoadVersion : uint16_t {
  MinVersion, 
 
  BigCurrency, 
  VehicleCurrencyStationChanges, 
  BiggerStationVariables, 
  TownTolerancePauseMode, 
 
  BigMap, 
  MultipleRoadStops, 
  LargerCargoSource, 
  LargerUnitNumber, 
  LargerTownCargoStatistics, 
 
  LargerTownCounter, 
  LargerTownIterator, 
  LinkWaypointToTown, 
  LargerAIStateCounter, 
  TransferOrder, 
 
  MoveSemaphoreBits, 
  EngineRenew, 
  StoreWaypointIdInMap, 
  RemoveMinorVersion, 
  EngineRenewPool, 
 
  NoMultiheadReference, 
  RemoveOldPbs, 
  SavePatches, 
  RemoveAutosaveInterval, 
  Elrail, 
 
  ImproveMultistop, 
  LastVehicleType, 
  NewGRFStations, 
  Yapf, 
  MoreUnderBridges, 
 
  Tgp, 
  BigDates, 
  LinkFarmFieldToIndustry, 
  SaveYapfSettings, 
  Liveries, 
 
  LiveryRefit, 
  RefitOrders, 
  Utf8, 
  DisableElrailSetting, 
  FreightWeight, 
 
  GradualLoading, 
  NewGRFSettings, 
  BridgeWormhole, 
  UnifyAnimationState, 
  CargoSourceTile, 
 
  CountPaidForCargo, 
  MoreAirportBlocks, 
  DriveThroughRoadStops, 
  RailTrackTypeUnification, 
  SimplifyPlayerFace, 
 
  AircraftSpeedHolding, 
  FeederShare, 
  StatueOwner, 
  NewGRFHouses, 
  TownGrowthControl, 
 
  NewGRFCargo, 
  Cities, 
  FifoLoading, 
  VeryLowTownIndustryNumber, 
  TownLayout, 
 
  VehicleGroups, 
  MultipleRoadTypes, 
  AdjacentStations, 
  TramLivery, 
  MultipleSignalTypes, 
 
  UnifyCurrency, 
  NewGRFTownNames, 
  Timetables, 
  CargoPackets, 
  MoreCargoPackets, 
 
  CargoPaymentOverflow, 
  UngroupedVehicles, 
  SplitStationTypeFromGfxid, 
  NewGRFIndustryLayout, 
  FixStationPickupAccounting, 
 
  Autoslope, 
  NewGRFPersistentStorage, 
  CleanupUnconnectedRoads, 
  StoreIndustryCargo, 
  FairPlaySettings, 
 
  NewGRFMoreAnimation, 
  FixTreeGround, 
  NewGRFIndustryRandomTriggers, 
  DepotWaterOwners, 
  ReplaceCustomNameArray, 
 
  MaglevMonorailPaxWagonLivery, 
  WaterClass, 
  SimplifyPathfinderSettings, 
  FractionProfitRunningTicks, 
  MoreWaypointsPerTown, 
 
  PlaneSpeedFactor, 
  MoreHouseAnimationFrames, 
  RemoveHouseCount, 
  ImprovedOrders, 
  FixCompanyCargoTypes, 
 
  MoreEngineTypes, 
  AirportNoise, 
  MergeOptsPats, 
  Gamelog, 
  IndustryTileWaterClass, 
 
  Yapp, 
  NewGRFPalette, 
  SpreadIndustryProductionChanges, 
  NewGRFSuppliedStationName, 
  MoreCompanies, 
 
  OrderList, 
  DistantStationJoining, 
  NoAI, 
  StoreAIVersion, 
  NextCompetitorStartOverflow, 
 
  RemoveOldAISettings, 
  FreeformEdges, 
  SplitHQ, 
  RoadLayoutPerTown, 
  SeparateRoadOwners, 
 
  CustomTownNumber, 
  GamelogEmergency, 
  PlatformStopLocation, 
  DigitGroupSeparator, 
  PauseModes, 
 
  CompanyServiceIntervals, 
  CargoPayments, 
  WaypointMoreLikeStation, 
  UnifyWaypointAndStation, 
  MultiTileWaypoints, 
 
  RemoveSubsidyStationBinding, 
  CumulatedInflation, 
  TownAcceptance, 
  FoundTown, 
  TimetableStart, 
 
  RoadStopOccupancyPenalty, 
  MaximumDepotPenalty, 
  DisallowTreeBuilding, 
  TrainSlopeSteepness, 
  VirtualFeederSharePayment, 
 
  RocksStayUnderSnow, 
  SplitLoadWaitCounters, 
  AirportAnimationFrames, 
  ReducePlaneCrashes, 
  RvRealisticAcceleration, 
 
  StoreAirportSize, 
  UniqueDepotNames, 
  NewGRFDepotBuildDate, 
  DisableTownLevelCrossing, 
  ReorderUnmovableRemoveReserved, 
 
  NewGRFAirportSmoke, 
  UnifyWaterClass, 
  UnifyAnimationFrame, 
  IndustryPlatform, 
  CustomSeaLevel, 
 
  FractionalCargoDelivery, 
  StoreNewGRFVersion, 
  IndustryManagement, 
  LeaveRoadStopSeparately, 
  PauseLevel, 
 
  NewGRFObjectView, 
  TerraformLimits, 
  UnifyGroundVehicles, 
  TrackRealAndAutoOrders, 
  MaxLengthAndReverseSignals, 
 
  DisallowRoadReconstruction, 
  PersistentStoragePool, 
  NewGRFCustomCargoAging, 
  Rivers, 
  VehicleCentreAndZPos, 
 
  ScriptTownGrowth, 
  InfrastructureMaintenanceCosts, 
  NewGRFAircraftRange, 
  ScriptTownText, 
  MoveSccEncoded, 
 
  CountIndividualCargoes, 
  ScenarioDeitySigns, 
  OrderMaxSpeed, 
  FixRoadOwnership, 
  CurrentOrderMaxSpeed, 
 
  AutoreplaceWhenOldTreeLimit, 
  BackupOrderState, 
  MonthlyBankruptcyCheck, 
  ScriptSettingsProfile, 
  RobustEnginePreview, 
 
  ServiceIntervalPercent, 
  CargoReservation, 
  GoalProgressPlaneAcceleration, 
  Cargodist, 
  SeparateLocaleUnits, 
 
  Storybooks, 
  ObjectTypeToPool, 
  LinkgraphRestrictedFlow, 
  UnifyRvTravelTime, 
  GroupHierarchy, 
 
  SeparateOrderTravelWaitTime, 
  LinkgraphLocationDisasterStore, 
  FixOrderBackup, 
  HideEnginesForCompany, 
  MaxBridgeMapHeight, 
 
  Distinguish16, 
  Distinguish17, 
  StoreMapVariety, 
  TownGrowthInGameTicks, 
  ExtendCargotypes, 
 
  ExtendRailtypes, 
  ExtendPersistentStorage, 
  ExtendIndustryCargoSlots, 
  ShipPathCache, 
  ShipRotation, 
 
  GroupLiveries, 
  ShipsStopInLocks, 
  FixCargoMonitor, 
  TownCargogen, 
  ShipCurvePenalty, 
 
  ServeNeutralIndustries, 
  RoadvehPathCache, 
  RemoveOldPathfinder, 
  TreesWaterClass, 
  RoadTypes, 
 
  ScriptMemlimit, 
  MultitileDocks, 
  TradingAge, 
  EndingYear, 
  RemoveTownCargoCache, 
 
  /* Patchpacks for a while considered it a good idea to jump a few versions
   * above our version for their savegames. But as time continued, this gap
   * has been closing, up to the point we would start to reuse versions from
   * their patchpacks. This is not a problem from our perspective: the
   * savegame will simply fail to load because they all contain chunks we
   * cannot digest. But, this gives for ugly errors. As we have plenty of
   * versions anyway, we simply skip the versions we know belong to
   * patchpacks. This way we can present the user with a clean error
   * indicate they are loading a savegame from a patchpack.
   * For future patchpack creators: please follow a system like JGRPP, where
   * the version is masked with 0x8000, and the true version is stored in
   * its own chunk with feature toggles.
   */
  StartPatchpacks, 
  EndPatchpacks = 286, 
 
  GSIndustryControl, 
  VehMotionCounter, 
  IndustryText, 
 
  MapgenSettingsRevamp, 
  GroupReplaceWagonRemoval, 
  CustomSubsidyDuration, 
  SaveloadListLength, 
  RiffToArray, 
 
  TableChunks, 
  ScriptInt64, 
  LinkgraphTravelTime, 
  DockDockingtiles, 
  RepairObjectDockingTiles, 
 
  U64TickCounter, 
  LastLoadingTick, 
  MultitrackLevelCrossings, 
  NewGRFRoadStops, 
  LinkgraphEdges, 
 
  VelocityNautical, 
  ConsistentPartialZ, 
  MoreCargoAge, 
  LinkgraphSeconds, 
  AIStartDate, 
 
  ExtendVehicleRandom, 
  ExtendEntityMapping, 
  DisasterVehState, 
  SavegameId, 
  StringGamelog, 
 
  IndustryCargoReorganise, 
  PeriodsInTransitRename, 
  NewGRFLastService, 
  RemoveLoadedAtXY, 
  CargoTravelled, 
 
  StationRatingCheat, 
  TimetableStartTicks, 
  TimetableStartTicksFix, 
  TimetableTicksType, 
  WaterRegions, 
 
  WaterRegionEvalSimplified, 
  EconomyDate, 
  EconomyModeTimekeepingUnits, 
  CalendarSubDateFract, 
  ShipAcceleration, 
 
  MaxLoanForCompany, 
  DepotUnbunching, 
  AILocalConfig, 
  ScriptRandomizer, 
  VehicleEconomyAge, 
 
  CompanyAllowList, 
  GroupNumbers, 
  IncreaseStationTypeFieldSize, 
  RoadWaypoints, 
  CompanyInauguratedPeriod, 
 
  RoadStopTileData, 
  CompanyAllowListV2, 
  WaterTileType, 
  ProductionHistory, 
  RoadTypeLabelMap, 
 
  NonfloodingWaterTiles, 
  PathCacheFormat, 
  AnimatedTileStateInMap, 
  IncreaseHouseLimit, 
  CompanyInauguratedPeriodV2, 
 
  EncodedStringFormat, 
  ProtectPlacedHouses, 
  ScriptSaveInstances, 
  FixSccEncodedNegative, 
  OrdersOwnedByOrderlist, 
 
  FaceStyles, 
  IndustryNumValidHistory, 
  IndustryAcceptedHistory, 
  TownSupplyHistory, 
  StationsUnderBridges, 
 
  DocksUnderBridges, 
  LocksUnderBridges, 
  EngineMultiRailtype, 
  SignTextColours, 
  BuoysAt0_0, 
 
  DriveBackwards, 
  DepotsUnderBridges, 
 
  MaxVersion, 
};

enum SavegameType : uint8_t {
  TTD, 
  TTDP1, 
  TTDP2, 
  OTTD, 
  TTO, 
  Invalid = 0xFF, 
};
void SetSaveLoadError(StringID str);
 
typedef void AutolengthProc(int);

enum class ChunkType : uint8_t {
  Riff = 0, 
  Array = 1, 
  SparseArray = 2, 
  Table = 3, 
  SparseTable = 4, 
 
  FileTypeMask = 0xf, 
  ReadOnly, 
};

using ChunkId = Label<struct ChunkIdTag>;;

struct ChunkHandler {
  ChunkId id; 
  ChunkType type; 

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

  virtual ~ChunkHandler() = default;

  virtual void Save() const { NOT_REACHED(); }

  virtual void Load() const = 0;

  virtual void FixPointers() const {}

  virtual void LoadCheck(size_t len = 0) const;

  std::string GetName() const
  {
    return this->id.AsString();
  }
};

using ChunkHandlerRef = std::reference_wrapper<const ChunkHandler>;

using ChunkHandlerTable = std::span<const ChunkHandlerRef>;

using SaveLoadCompatTable = std::span<const struct SaveLoadCompat>;

class SaveLoadHandler {
public:
  std::optional<std::vector<SaveLoad>> load_description; 

  virtual ~SaveLoadHandler() = default;

  virtual void Save([[maybe_unused]] void *object) const {}

  virtual void Load([[maybe_unused]] void *object) const {}

  virtual void LoadCheck([[maybe_unused]] void *object) const {}

  virtual void FixPointers([[maybe_unused]] void *object) const {}

  virtual SaveLoadTable GetDescription() const = 0;

  virtual SaveLoadCompatTable GetCompatDescription() const = 0;

  SaveLoadTable GetLoadDescription() const;
};

template <class TImpl, class TObject>
class DefaultSaveLoadHandler : public SaveLoadHandler {
public:
  SaveLoadTable GetDescription() const override { return static_cast<const TImpl *>(this)->description; }
 
  SaveLoadCompatTable GetCompatDescription() const override { return static_cast<const TImpl *>(this)->compat_description; }

  virtual void Save([[maybe_unused]] TObject *object) const {}
  void Save(void *object) const override { this->Save(static_cast<TObject *>(object)); }

  virtual void Load([[maybe_unused]] TObject *object) const {}
  void Load(void *object) const override { this->Load(static_cast<TObject *>(object)); }

  virtual void LoadCheck([[maybe_unused]] TObject *object) const {}
  void LoadCheck(void *object) const override { this->LoadCheck(static_cast<TObject *>(object)); }

  virtual void FixPointers([[maybe_unused]] TObject *object) const {}
  void FixPointers(void *object) const override { this->FixPointers(static_cast<TObject *>(object)); }
};

enum class SLRefType : uint8_t {
  Vehicle = 1, 
  Station = 2, 
  Town = 3, 
  OldVehicle = 4, 
  RoadStop = 5, 
  EngineRenew = 6, 
  CargoPacket = 7, 
  OrderList = 8, 
  Storage = 9, 
  LinkGraph = 10, 
  LinkGraphJob = 11, 
};

enum class VarFileType : uint8_t {
  /* 4 bits allocated a maximum of 16 types for NumberType.
   * NOTE: the SLE_FILE_NNN values are stored in the savegame! */
  /* Value 0 is used to mark end-of-header in tables. Do not use here! */
  I8 = 1, 
  U8 = 2, 
  I16 = 3, 
  U16 = 4, 
  I32 = 5, 
  U32 = 6, 
  I64 = 7, 
  U64 = 8, 
  StringID = 9, 
  String = 10, 
  Struct = 11, 
  /* 4 more possible file-primitives */
};

enum class VarMemType : uint8_t {
  Bool = 0, 
  I8 = 1, 
  U8 = 2, 
  I16 = 3, 
  U16 = 4, 
  I32 = 5, 
  U32 = 6, 
  I64 = 7, 
  U64 = 8, 
  Null = 9, 
  Str = 12, 
  StrQ = 13, 
  Name = 14, 
  LabelReverse = 15, 
  LabelForward = 16, 
};

struct VarType {
  VarFileType file{}; 
  VarMemType mem{}; 
  StringValidationSettings string_validation_settings{}; 
  SLRefType ref{}; 

  constexpr VarType() {}

  constexpr VarType(VarFileType file, VarMemType mem) : file(file), mem(mem) {}

  constexpr VarType(SLRefType ref) : ref(ref) {}

  constexpr bool operator==(const VarType &other) const = default;

  constexpr VarType operator|(StringValidationSetting string_validation_setting) const
  {
    VarType copy = *this;
    copy.string_validation_settings.Set(string_validation_setting);
    return copy;
  }
};

constexpr VarType operator|(VarFileType file, VarMemType mem)
{
  return {file, mem};
}

struct VarTypes {
  static constexpr VarType BOOL{ VarFileType::I8, VarMemType::Bool }; 
  static constexpr VarType I8{ VarFileType::I8, VarMemType::I8 }; 
  static constexpr VarType U8{ VarFileType::U8, VarMemType::U8 }; 
  static constexpr VarType I16{ VarFileType::I16, VarMemType::I16 }; 
  static constexpr VarType U16{ VarFileType::U16, VarMemType::U16 }; 
  static constexpr VarType I32{ VarFileType::I32, VarMemType::I32 }; 
  static constexpr VarType U32{ VarFileType::U32, VarMemType::U32 }; 
  static constexpr VarType I64{ VarFileType::I64, VarMemType::I64 }; 
  static constexpr VarType U64{ VarFileType::U64, VarMemType::U64 }; 
  static constexpr VarType STRINGID{ VarFileType::StringID, VarMemType::U32 }; 
  static constexpr VarType STR{ VarFileType::String, VarMemType::Str }; 
  static constexpr VarType STRQ{ VarFileType::String, VarMemType::StrQ }; 
  static constexpr VarType NAME{ VarFileType::StringID, VarMemType::Name }; 
  static constexpr VarType LABEL_REVERSE{ VarFileType::U32, VarMemType::LabelReverse }; 
  static constexpr VarType LABEL_FORWARD{ VarFileType::U32, VarMemType::LabelForward }; 
};

enum class SaveLoadType : uint8_t {
  Variable = 0, 
  Reference = 1, 
  Struct = 2, 
 
  String = 4, 
 
  Array = 5, 
  Vector = 7, 
  ReferenceList = 8, 
  StructList = 9, 
 
  SaveByte = 10, 
  Null = 11, 
 
  ReferenceVector = 12, 
};
 
typedef void *SaveLoadAddrProc(void *base, size_t extra);

struct SaveLoad {
  std::string name;    
  SaveLoadType cmd;    
  VarType conv;        
  uint16_t length;       
  SaveLoadVersion version_from;   
  SaveLoadVersion version_to;     
  SaveLoadAddrProc *address_proc; 
  size_t extra_data;              
  std::shared_ptr<SaveLoadHandler> handler; 
};

struct SaveLoadCompat {
  std::string_view name; 
  uint16_t null_length; 
  SaveLoadVersion version_from; 
  SaveLoadVersion version_to; 
};

inline constexpr size_t SlVarSize(VarMemType type)
{
  switch (type) {
    case VarMemType::Bool: return sizeof(bool);
    case VarMemType::I8: return sizeof(int8_t);
    case VarMemType::U8: return sizeof(uint8_t);
    case VarMemType::I16: return sizeof(int16_t);
    case VarMemType::U16: return sizeof(uint16_t);
    case VarMemType::I32: return sizeof(int32_t);
    case VarMemType::U32: return sizeof(uint32_t);
    case VarMemType::I64: return sizeof(int64_t);
    case VarMemType::U64: return sizeof(uint64_t);
    case VarMemType::Null: return sizeof(void *);
    case VarMemType::Str: return sizeof(std::string);
    case VarMemType::StrQ: return sizeof(std::string);
    case VarMemType::Name: return sizeof(std::string);
    case VarMemType::LabelReverse: return sizeof(BaseLabel);
    case VarMemType::LabelForward: return sizeof(BaseLabel);
    default: NOT_REACHED();
  }
}

inline constexpr bool SlCheckVarSize(SaveLoadType cmd, VarType type, size_t length, size_t size)
{
  switch (cmd) {
    case SaveLoadType::Variable: return SlVarSize(type.mem) == size;
    case SaveLoadType::Reference: return sizeof(void *) == size;
    case SaveLoadType::String: return SlVarSize(type.mem) == size;
    case SaveLoadType::Array: return SlVarSize(type.mem) * length <= size; // Partial load of array is permitted.
    case SaveLoadType::Vector: return sizeof(std::vector<void *>) == size;
    case SaveLoadType::ReferenceList: return sizeof(std::list<void *>) == size;
    case SaveLoadType::ReferenceVector: return sizeof(std::vector<void *>) == size;
    case SaveLoadType::SaveByte: return true;
    default: NOT_REACHED();
  }
}

#define SLE_GENERAL_NAME(cmd, name, base, variable, type, length, from, to, extra) \
  SaveLoad {name, cmd, type, length, from, to, [] (void *b, size_t) -> void * { \
    static_assert(SlCheckVarSize(cmd, type, length, sizeof(static_cast<base *>(b)->variable))); \
    static_assert((VarType{type}.mem != VarMemType::LabelReverse && VarType{type}.mem != VarMemType::LabelForward) || std::is_base_of_v<BaseLabel, decltype(base::variable)>); \
    assert(b != nullptr); \
    return const_cast<void *>(static_cast<const void *>(std::addressof(static_cast<base *>(b)->variable))); \
  }, extra, nullptr}

#define SLE_GENERAL(cmd, base, variable, type, length, from, to, extra) SLE_GENERAL_NAME(cmd, #variable, base, variable, type, length, from, to, extra)

#define SLE_CONDVAR(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::Variable, base, variable, type, 0, from, to, 0)

#define SLE_CONDVARNAME(base, variable, name, type, from, to) SLE_GENERAL_NAME(SaveLoadType::Variable, name, base, variable, type, 0, from, to, 0)

#define SLE_CONDREF(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::Reference, base, variable, type, 0, from, to, 0)

#define SLE_CONDARR(base, variable, type, length, from, to) SLE_GENERAL(SaveLoadType::Array, base, variable, type, length, from, to, 0)

#define SLE_CONDARRNAME(base, variable, name, type, length, from, to) SLE_GENERAL_NAME(SaveLoadType::Array, name, base, variable, type, length, from, to, 0)

#define SLE_CONDSSTR(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::String, base, variable, type, 0, from, to, 0)

#define SLE_CONDSSTRNAME(base, variable, name, type, from, to) SLE_GENERAL_NAME(SaveLoadType::String, name, base, variable, type, 0, from, to, 0)

#define SLE_CONDREFLIST(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::ReferenceList, base, variable, type, 0, from, to, 0)

#define SLE_CONDREFVECTOR(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::ReferenceVector, base, variable, type, 0, from, to, 0)

#define SLE_CONDVECTOR(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::Vector, base, variable, type, 0, from, to, 0)

#define SLE_CONDVECTOR(base, variable, type, from, to) SLE_GENERAL(SaveLoadType::Vector, base, variable, type, 0, from, to, 0)

#define SLE_VAR(base, variable, type) SLE_CONDVAR(base, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_VARNAME(base, variable, name, type) SLE_CONDVARNAME(base, variable, name, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_REF(base, variable, type) SLE_CONDREF(base, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_ARR(base, variable, type, length) SLE_CONDARR(base, variable, type, length, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_ARRNAME(base, variable, name, type, length) SLE_CONDARRNAME(base, variable, name, type, length, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_SSTR(base, variable, type) SLE_CONDSSTR(base, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_SSTRNAME(base, variable, name, type) SLE_CONDSSTRNAME(base, variable, name, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_REFLIST(base, variable, type) SLE_CONDREFLIST(base, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_REFVECTOR(base, variable, type) SLE_CONDREFVECTOR(base, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLE_SAVEBYTE(base, variable) SLE_GENERAL(SaveLoadType::SaveByte, base, variable, {}, 0, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion, 0)

#define SLEG_GENERAL(name, cmd, variable, type, length, from, to, extra) \
  SaveLoad {name, cmd, type, length, from, to, [] (void *, size_t) -> void * { \
    static_assert(SlCheckVarSize(cmd, type, length, sizeof(variable))); \
    return static_cast<void *>(std::addressof(variable)); }, extra, nullptr}

#define SLEG_CONDVAR(name, variable, type, from, to) SLEG_GENERAL(name, SaveLoadType::Variable, variable, type, 0, from, to, 0)

#define SLEG_CONDREF(name, variable, type, from, to) SLEG_GENERAL(name, SaveLoadType::Reference, variable, type, 0, from, to, 0)

#define SLEG_CONDARR(name, variable, type, length, from, to) SLEG_GENERAL(name, SaveLoadType::Array, variable, type, length, from, to, 0)

#define SLEG_CONDSSTR(name, variable, type, from, to) SLEG_GENERAL(name, SaveLoadType::String, variable, type, 0, from, to, 0)

#define SLEG_CONDSTRUCT(name, handler, from, to) SaveLoad {name, SaveLoadType::Struct, {}, 0, from, to, nullptr, 0, std::make_shared<handler>()}

#define SLEG_CONDREFLIST(name, variable, type, from, to) SLEG_GENERAL(name, SaveLoadType::ReferenceList, variable, type, 0, from, to, 0)

#define SLEG_CONDVECTOR(name, variable, type, from, to) SLEG_GENERAL(name, SaveLoadType::Vector, variable, type, 0, from, to, 0)

#define SLEG_CONDSTRUCTLIST(name, handler, from, to) SaveLoad {name, SaveLoadType::StructList, {}, 0, from, to, nullptr, 0, std::make_shared<handler>()}

#define SLEG_VAR(name, variable, type) SLEG_CONDVAR(name, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_REF(name, variable, type) SLEG_CONDREF(name, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_ARR(name, variable, type, length) SLEG_CONDARR(name, variable, type, length, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_SSTR(name, variable, type) SLEG_CONDSSTR(name, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_STRUCT(name, handler) SLEG_CONDSTRUCT(name, handler, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_REFLIST(name, variable, type) SLEG_CONDREFLIST(name, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_VECTOR(name, variable, type) SLEG_CONDVECTOR(name, variable, type, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLEG_STRUCTLIST(name, handler) SLEG_CONDSTRUCTLIST(name, handler, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion)

#define SLC_VAR(name) {name, 0, SaveLoadVersion::MinVersion, SaveLoadVersion::MaxVersion}

#define SLC_NULL(length, from, to) {{}, length, from, to}

inline bool IsSavegameVersionBefore(SaveLoadVersion major, uint8_t minor = 0)
{
  extern SaveLoadVersion _sl_version;
  extern uint8_t            _sl_minor_version;
  return _sl_version < major || (minor > 0 && _sl_version == major && _sl_minor_version < minor);
}

inline bool IsSavegameVersionBeforeOrAt(SaveLoadVersion major)
{
  extern SaveLoadVersion _sl_version;
  return _sl_version <= major;
}

inline bool SlIsObjectCurrentlyValid(SaveLoadVersion version_from, SaveLoadVersion version_to)
{
  extern const SaveLoadVersion SAVEGAME_VERSION;
  return version_from <= SAVEGAME_VERSION && SAVEGAME_VERSION < version_to;
}

inline void *GetVariableAddress(const void *object, const SaveLoad &sld)
{
  /* Entry is a null-variable, mostly used to read old savegames etc. */
  if (sld.conv.mem == VarMemType::Null) {
    assert(sld.address_proc == nullptr);
    return nullptr;
  }
 
  /* Everything else should be a non-null pointer. */
  assert(sld.address_proc != nullptr);
  return sld.address_proc(const_cast<void *>(object), sld.extra_data);
}
 
int64_t ReadValue(const void *ptr, VarMemType conv);
void WriteValue(void *ptr, VarMemType conv, int64_t val);
 
void SlSetArrayIndex(uint index);
static void SlSetArrayIndex(const ConvertibleThroughBase auto &index) { SlSetArrayIndex(index.base()); }
int SlIterateArray();
 
void SlSetStructListLength(size_t length);
size_t SlGetStructListLength(size_t limit);
 
void SlAutolength(AutolengthProc *proc, int arg);
size_t SlGetFieldLength();
void SlSetLength(size_t length);
size_t SlCalcObjMemberLength(const void *object, const SaveLoad &sld);
size_t SlCalcObjLength(const void *object, const SaveLoadTable &slt);
 
uint8_t SlReadByte();
void SlReadString(std::string &str, size_t length);
void SlWriteByte(uint8_t b);
 
void SlGlobList(const SaveLoadTable &slt);
void SlCopy(void *object, size_t length, VarType conv);
std::vector<SaveLoad> SlTableHeader(const SaveLoadTable &slt);
std::vector<SaveLoad> SlCompatTableHeader(const SaveLoadTable &slt, const SaveLoadCompatTable &slct);
void SlObject(void *object, const SaveLoadTable &slt);

inline void SlSkipBytes(size_t length)
{
  for (; length != 0; length--) SlReadByte();
}

template <class TImpl, class TObject, class TElementType, size_t MAX_LENGTH = UINT32_MAX>
class VectorSaveLoadHandler : public DefaultSaveLoadHandler<TImpl, TObject> {
public:
  virtual std::vector<TElementType> &GetVector(TObject *object) const = 0;

  virtual size_t GetLength() const { return SlGetStructListLength(MAX_LENGTH); }
 
  void Save(TObject *object) const override
  {
    auto &vector = this->GetVector(object);
    SlSetStructListLength(vector.size());
 
    for (auto &item : vector) {
      SlObject(&item, this->GetDescription());
    }
  }
 
  void Load(TObject *object) const override
  {
    auto &vector = this->GetVector(object);
    size_t count = this->GetLength();
 
    vector.reserve(count);
    while (count-- > 0) {
      auto &item = vector.emplace_back();
      SlObject(&item, this->GetLoadDescription());
    }
  }
};
 
#endif /* SAVELOAD_H */