src/saveload/saveload_filter.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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 <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file saveload_filter.h Declaration of filters used for saving and loading savegames. */
   9
  10 #ifndef SAVELOAD_FILTER_H
  11 #define SAVELOAD_FILTER_H
  12
  13 /** Interface for filtering a savegame till it is loaded. */
  14 struct LoadFilter {
  15         /** Chained to the (savegame) filters. */
  16         std::shared_ptr<LoadFilter> chain;
  17
  18         /**
  19          * Initialise this filter.
  20          * @param chain The next filter in this chain.
  21          */
  22         LoadFilter(std::shared_ptr<LoadFilter> chain) : chain(chain)
  23         {
  24         }
  25
  26         /** Make sure the writers are properly closed. */
  27         virtual ~LoadFilter()
  28         {
  29         }
  30
  31         /**
  32          * Read a given number of bytes from the savegame.
  33          * @param buf The bytes to read.
  34          * @param len The number of bytes to read.
  35          * @return The number of actually read bytes.
  36          */
  37         virtual size_t Read(uint8_t *buf, size_t len) = 0;
  38
  39         /**
  40          * Reset this filter to read from the beginning of the file.
  41          */
  42         virtual void Reset()
  43         {
  44                 this->chain->Reset();
  45         }
  46 };
  47
  48 /**
  49  * Instantiator for a load filter.
  50  * @param chain The next filter in this chain.
  51  * @tparam T    The type of load filter to create.
  52  */
  53 template <typename T> std::shared_ptr<LoadFilter> CreateLoadFilter(std::shared_ptr<LoadFilter> chain)
  54 {
  55         return std::make_shared<T>(chain);
  56 }
  57
  58 /** Interface for filtering a savegame till it is written. */
  59 struct SaveFilter {
  60         /** Chained to the (savegame) filters. */
  61         std::shared_ptr<SaveFilter> chain;
  62
  63         /**
  64          * Initialise this filter.
  65          * @param chain The next filter in this chain.
  66          */
  67         SaveFilter(std::shared_ptr<SaveFilter> chain) : chain(chain)
  68         {
  69         }
  70
  71         /** Make sure the writers are properly closed. */
  72         virtual ~SaveFilter()
  73         {
  74         }
  75
  76         /**
  77          * Write a given number of bytes into the savegame.
  78          * @param buf The bytes to write.
  79          * @param len The number of bytes to write.
  80          */
  81         virtual void Write(uint8_t *buf, size_t len) = 0;
  82
  83         /**
  84          * Prepare everything to finish writing the savegame.
  85          */
  86         virtual void Finish()
  87         {
  88                 if (this->chain != nullptr) this->chain->Finish();
  89         }
  90 };
  91
  92 /**
  93  * Instantiator for a save filter.
  94  * @param chain             The next filter in this chain.
  95  * @param compression_level The requested level of compression.
  96  * @tparam T                The type of save filter to create.
  97  */
  98 template <typename T> std::shared_ptr<SaveFilter> CreateSaveFilter(std::shared_ptr<SaveFilter> chain, uint8_t compression_level)
  99 {
 100         return std::make_shared<T>(chain, compression_level);
 101 }
 102
 103 #endif /* SAVELOAD_FILTER_H */