SerializationOps.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2022 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_SERIALIZATION_OPS_H
#define GF_SERIALIZATION_OPS_H
 
#include <cstdint>
#include <cstring>
#include <string>
 
#include <array>
#include <map>
#include <set>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "CoreApi.h"
#include "Flags.h"
#include "Serialization.h"
#include "Span.h"
 
namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif
 
  GF_CORE_API Serializer& operator|(Serializer& ar, bool data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, char data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, uint8_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, uint16_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, uint32_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, uint64_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, int8_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, int16_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, int32_t data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, int64_t data);
 
  template<typename T, typename E = typename std::enable_if<std::is_enum<T>::value, T>::type>
  inline
  Serializer& operator|(Serializer& ar, T data) {
    using U = typename std::underlying_type<T>::type;
    return ar | static_cast<U>(data);
  }
 
  template<typename E>
  inline
  Serializer& operator|(Serializer& ar, Flags<E> data) {
    return ar | data.m_data;
  }
 
  GF_CORE_API Serializer& operator|(Serializer& ar, float data);
 
  GF_CORE_API Serializer& operator|(Serializer& ar, double data);
 
#ifndef _MSC_VER
  Serializer& operator|(Serializer& ar, const char *str) = delete;
#endif
 
  GF_CORE_API Serializer& operator|(Serializer& ar, const std::string& str);
 
  template<typename T, std::size_t N>
  inline
  Serializer& operator|(Serializer& ar, const T (&array)[N]) {
    ar.writeSizeHeader(N);
 
    for (auto& item : array) {
      ar | const_cast<T&>(item);
    }
 
    return ar;
  }
 
  template<typename T>
  inline
  Serializer& operator|(Serializer& ar, const std::vector<T>& array) {
    ar.writeSizeHeader(array.size());
 
    for (auto& item : array) {
      ar | const_cast<T&>(item);
    }
 
    return ar;
  }
 
  template<typename T, std::size_t N>
  inline
  Serializer& operator|(Serializer& ar, const std::array<T, N>& array) {
    ar.writeSizeHeader(array.size());
 
    for (auto& item : array) {
      ar | const_cast<T&>(item);
    }
 
    return ar;
  }
 
  template<typename T>
  inline
  Serializer& operator|(Serializer& ar, const std::set<T>& set) {
    ar.writeSizeHeader(set.size());
 
    for (auto& item : set) {
      ar | const_cast<T&>(item);
    }
 
    return ar;
  }
 
  template<typename T>
  inline
  Serializer& operator|(Serializer& ar, const std::unordered_set<T>& set) {
    ar.writeSizeHeader(set.size());
 
    for (auto& item : set) {
      ar | const_cast<T&>(item);
    }
 
    return ar;
  }
 
  template<typename K, typename V>
  inline
  Serializer& operator|(Serializer& ar, const std::map<K, V>& map) {
    ar.writeSizeHeader(map.size());
 
    for (auto& item : map) {
      ar | const_cast<K&>(item.first) | const_cast<V&>(item.second);
    }
 
    return ar;
  }
 
  template<typename K, typename V>
  inline
  Serializer& operator|(Serializer& ar, const std::unordered_map<K, V>& map) {
    ar.writeSizeHeader(map.size());
 
    for (auto& item : map) {
      ar | const_cast<K&>(item.first) | const_cast<V&>(item.second);
    }
 
    return ar;
  }
 
 
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, bool& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, char& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, uint8_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, uint16_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, uint32_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, uint64_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, int8_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, int16_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, int32_t& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, int64_t& data);
 
  template<typename T, typename E = typename std::enable_if<std::is_enum<T>::value, T>::type>
  inline
  Deserializer& operator|(Deserializer& ar, T& data) {
    using U = typename std::underlying_type<T>::type;
    U underlying;
    ar | underlying;
    data = static_cast<T>(underlying);
    return ar;
  }
 
  template<typename E>
  inline
  Deserializer& operator|(Deserializer& ar, Flags<E>& data) {
    return ar | data.m_data;
  }
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, float& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, double& data);
 
  GF_CORE_API Deserializer& operator|(Deserializer& ar, std::string& str);
 
  template<typename T>
  inline
  Deserializer& operator|(Deserializer& ar, Span<T> array) {
    std::size_t size;
 
    if (!ar.readSizeHeader(size)) {
      return ar;
    }
 
    if (size != array.getSize()) {
      return ar;
    }
 
    for (auto& item : array) {
      ar | item;
    }
 
    return ar;
  }
 
  template<typename T, std::size_t N>
  inline
  Deserializer& operator|(Deserializer& ar, T (&array)[N]) {
    return ar | Span<T>(array);
  }
 
  template<typename T, std::size_t N>
  inline
  Deserializer& operator|(Deserializer& ar, std::array<T, N>& array) {
    return ar | Span<T>(array);
  }
 
  template<typename T>
  inline
  Deserializer& operator|(Deserializer& ar, std::vector<T>& array) {
    std::size_t size;
 
    if (!ar.readSizeHeader(size)) {
      return ar;
    }
 
    array.clear();
 
    for (std::size_t i = 0; i < size; ++i) {
      T item;
      ar | item;
      array.emplace_back(std::move(item));
    }
 
    return ar;
  }
 
  template<typename T>
  inline
  Deserializer& operator|(Deserializer& ar, std::set<T>& set) {
    std::size_t size;
 
    if (!ar.readSizeHeader(size)) {
      return ar;
    }
 
    set.clear();
 
    for (std::size_t i = 0; i < size; ++i) {
      T item;
      ar | item;
      set.emplace(std::move(item));
    }
 
    return ar;
  }
 
  template<typename T>
  inline
  Deserializer& operator|(Deserializer& ar, std::unordered_set<T>& set) {
    std::size_t size;
 
    if (!ar.readSizeHeader(size)) {
      return ar;
    }
 
    set.clear();
 
    for (std::size_t i = 0; i < size; ++i) {
      T item;
      ar | item;
      set.emplace(std::move(item));
    }
 
    return ar;
  }
 
  template<typename K, typename V>
  inline
  Deserializer& operator|(Deserializer& ar, std::map<K,V>& map) {
    std::size_t size;
 
    if (!ar.readSizeHeader(size)) {
      return ar;
    }
 
    map.clear();
 
    for (std::size_t i = 0; i < size; ++i) {
      K key;
      ar | key;
      V value;
      ar | value;
 
      map.emplace(std::move(key), std::move(value));
    }
 
    return ar;
  }
 
  template<typename K, typename V>
  inline
  Deserializer& operator|(Deserializer& ar, std::unordered_map<K,V>& map) {
    std::size_t size;
 
    if (!ar.readSizeHeader(size)) {
      return ar;
    }
 
    map.clear();
 
    for (std::size_t i = 0; i < size; ++i) {
      K key;
      ar | key;
      V value;
      ar | value;
 
      map.emplace(std::move(key), std::move(value));
    }
 
    return ar;
  }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}
 
#endif // GF_SERIALIZATION_OPS_H