.. _program_listing_file_libtcod_zip.hpp:

Program Listing for File zip.hpp
================================

|exhale_lsh| :ref:`Return to documentation for file <file_libtcod_zip.hpp>` (``libtcod/zip.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /* BSD 3-Clause License
    *
    * Copyright © 2008-2025, Jice and the libtcod contributors.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    *
    * 2. Redistributions in binary form must reproduce the above copyright notice,
    *    this list of conditions and the following disclaimer in the documentation
    *    and/or other materials provided with the distribution.
    *
    * 3. Neither the name of the copyright holder nor the names of its
    *    contributors may be used to endorse or promote products derived from
    *    this software without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    * POSSIBILITY OF SUCH DAMAGE.
    */
   #pragma once
   #ifndef TCOD_ZIP_HPP_
   #define TCOD_ZIP_HPP_
   #ifndef TCOD_NO_ZLIB
   
   #include <filesystem>
   #include <optional>
   #include <string>
   
   #include "color.hpp"
   #include "config.h"
   #include "console.hpp"
   #include "image.hpp"
   #include "mersenne.hpp"
   #include "zip.h"
   
   // clang-format off
   class TCODLIB_API TCODZip {
   public :
   
     [[deprecated("This method of serialization is not cross-platform.  An alternative such as C++ Cereal should be used instead.")]]
     TCODZip();
   
     ~TCODZip();
   
     void putChar(char val);
   
     void putInt(int val);
   
     void putFloat(float val);
   
     void putString(const char *val);
   
     void putColor(const TCODColor *val);
   
     void putImage(const TCODImage *val);
   
     [[deprecated("This function will corrupt console characters greater than 255.")]]
     void putConsole(const TCODConsole *val);
   
     void putRandom(const TCODRandom *val);
   
     void putData(int nbBytes, const void *data);
   
     uint32_t getCurrentBytes() const;
   
     int saveToFile(const char *filename);
   
   
     void saveToFile(const std::filesystem::path& path) { saveToFile(path.string().c_str()); }
   
     int loadFromFile(const char *filename);
   
   
     void loadFromFile(const std::filesystem::path& path) {
       if (loadFromFile(path.string().c_str()) == 0) {
         throw std::runtime_error{"Failed to load file: " + path.string()};
       }
     }
   
     char getChar();
   
     int getInt();
   
     float getFloat();
   
     const char *getString();
   
     TCODColor getColor();
   
     TCODImage *getImage();
   
     TCODConsole *getConsole();
   
     TCODRandom *getRandom();
   
     int getData(int nbBytes, void *data);
   
     uint32_t getRemainingBytes() const;
   
     void skipBytes(uint32_t nbBytes);
     // clang-format on
   
   
     void put(char value) { TCOD_zip_put_char(data, value); }
   
     void put(int value) { TCOD_zip_put_int(data, value); }
   
     void put(float value) { TCOD_zip_put_float(data, value); }
   
     void put(const char* value) { TCOD_zip_put_string(data, value); }
   
     void put(const std::string& value) { TCOD_zip_put_string(data, value.c_str()); }
   
     void put(const std::optional<std::string>& value) {
       if (value) return put(value.value());
       TCOD_zip_put_string(data, nullptr);
     }
   
     void put(const tcod::ColorRGB& value) { TCOD_zip_put_color(data, value); }
   
     void put(const TCODColor& value) { put(tcod::ColorRGB{value}); }
   
     void put(const TCODImage& value) { TCOD_zip_put_image(data, value.get_data()); }
     TCODLIB_BEGIN_IGNORE_DEPRECATIONS
   
     [[deprecated("This function will corrupt console characters greater than 255.")]] void put(const TCODConsole& value) {
       TCOD_zip_put_console(data, value.get_data());
     }
   
     [[deprecated("This function will corrupt console characters greater than 255.")]] void put(
         const tcod::Console& value) {
       TCOD_zip_put_console(data, value.get());
     }
     TCODLIB_END_IGNORE_DEPRECATIONS
   
     void put(const TCODRandom& value) { TCOD_zip_put_random(data, value.get_data()); }
   
   
     template <typename T>
     T get() {
       T out{};
       get(out);
       return out;
     }
   
   
     void get(char& out) { out = TCOD_zip_get_char(data); }
   
     void get(int& out) { out = TCOD_zip_get_int(data); }
   
     void get(float& out) { out = TCOD_zip_get_float(data); }
   
     void get(std::optional<std::string>& out) {
       out = {};
       const char* string = TCOD_zip_get_string(data);
       if (string) out = string;
     }
   
     void get(std::string& out) { out = get<std::optional<std::string>>().value(); }
   
     void get(tcod::ColorRGB& out) { out = tcod::ColorRGB{TCOD_zip_get_color(data)}; }
   
     void get(TCODColor& out) { out = TCODColor{TCOD_zip_get_color(data)}; }
   
     void get(tcod::ImagePtr& out) { out = tcod::ImagePtr{TCOD_zip_get_image(data)}; }
   
     void get(TCODImage& out) { out = TCODImage{get<tcod::ImagePtr>()}; }
   
     void get(tcod::ConsolePtr& out) { out = tcod::ConsolePtr{TCOD_zip_get_console(data)}; }
   
     void get(tcod::Console& out) { out = tcod::Console{get<tcod::ConsolePtr>()}; }
   
     void get(TCODConsole& out) { out = TCODConsole{get<tcod::ConsolePtr>()}; }
   
     void get(TCODRandom& out) { out = TCODRandom{TCOD_zip_get_random(data)}; }
   
    protected:
     TCOD_zip_t data{};
   };
   
   #endif  // TCOD_NO_ZLIB
   #endif  // TCOD_ZIP_HPP_