binary_parser_policy.hpp

Go to the documentation of this file.

/*
   This file is part of PLYwoot, a header-only PLY parser.
 
   Copyright (C) 2023-2025, Ton van den Heuvel
 
   PLYwoot 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, either version 3 of the License, or
   (at your option) any later version.
 
   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef PLYWOOT_BINARY_PARSER_POLICY_HPP
#define PLYWOOT_BINARY_PARSER_POLICY_HPP
 
 
#include "buffered_istream.hpp"
#include "endian.hpp"
#include "type_traits.hpp"
 
#include <cstdint>
#include <numeric>
 
namespace plywoot::detail {
 
template<typename Endianness>
class BinaryParserPolicy
{
public:
  BinaryParserPolicy(std::istream &is) : is_{is} {}
 
  void skipElement(const PlyElement &e) const
  {
    // In case all element properties are non-list properties, we can calculate
    // the element size in one go.
    const std::vector<PlyProperty> &properties = e.properties();
    if (std::all_of(properties.begin(), properties.end(), [](const PlyProperty &p) { return !p.isList(); }))
    {
      is_.skip(
          e.size() * std::accumulate(
                         properties.begin(), properties.end(), static_cast<std::size_t>(0),
                         [](std::size_t acc, const PlyProperty &p) { return acc + sizeOf(p.type()); }));
    }
    else
    {
      for (std::size_t i = 0; i < e.size(); ++i)
      {
        for (const PlyProperty &p : e.properties()) { skipProperty(p); }
      }
    }
  }
 
  void skipProperty(const PlyProperty &p) const
  {
    if (!p.isList()) { is_.skip(sizeOf(p.type())); }
    else
    {
      std::size_t size = 0;
      switch (p.sizeType())
      {
        case PlyDataType::Char:
          size = readNumber<char>();
          break;
        case PlyDataType::UChar:
          size = readNumber<unsigned char>();
          break;
        case PlyDataType::Short:
          size = readNumber<short>();
          break;
        case PlyDataType::UShort:
          size = readNumber<unsigned short>();
          break;
        case PlyDataType::Int:
          size = readNumber<int>();
          break;
        case PlyDataType::UInt:
          size = readNumber<unsigned int>();
          break;
        case PlyDataType::Float:
          size = readNumber<float>();
          break;
        case PlyDataType::Double:
          size = readNumber<double>();
          break;
      }
 
      is_.skip(size * sizeOf(p.type()));
    }
  }
 
  template<typename T, typename EndiannessDependent = Endianness>
  T readNumber() const
  {
    if constexpr (std::is_same_v<EndiannessDependent, HostEndian>) { return is_.read<T>(); }
    else { return byte_swap(is_.read<T>()); }
  }
 
  template<typename PlyT, typename DestT, std::size_t N, typename EndiannessDependent = Endianness>
  std::uint8_t *readNumbers(std::uint8_t *dest) const
  {
    if constexpr (std::is_same_v<EndiannessDependent, HostEndian>) { return is_.read<PlyT, DestT, N>(dest); }
    else
    {
      std::uint8_t *result = is_.read<PlyT, DestT, N>(dest);
 
      // Perform endianess conversion.
      DestT *to = reinterpret_cast<DestT *>(dest);
      for (std::size_t i = 0; i < N; ++i, ++to) { *to = byte_swap(static_cast<PlyT>(*to)); }
 
      return result;
    }
  }
 
  template<typename T>
  void skipNumber() const
  {
    is_.skip(sizeof(T));
  }
 
  void skipProperties(std::size_t n) const { is_.skip(n); }
 
  template<typename... Ts, typename EndiannessDependent = Endianness>
  void memcpy(std::uint8_t *dest, const PlyElement &element) const
  {
    is_.memcpy(dest, element.size() * detail::sizeOf<Ts...>());
 
    if constexpr (!std::is_same_v<EndiannessDependent, HostEndian>)
    {
      for (std::size_t i = 0; i < element.size(); ++i) { dest = byteSwap<Ts...>(dest); }
    }
  }
 
private:
  template<typename T>
  std::uint8_t *byteSwap(std::uint8_t *dest) const
  {
    if constexpr (!detail::IsPack<T>::value)
    {
      auto ptr = reinterpret_cast<T *>(dest);
      *ptr = byte_swap(*ptr);
 
      return dest + sizeof(T);
    }
    else
    {
      auto ptr = reinterpret_cast<typename T::DestT *>(dest);
      for (std::size_t i = 0; i < T::size; ++i, ++ptr) { *ptr = byte_swap(*ptr); }
 
      return dest + detail::sizeOf<T>();
    }
  }
 
  template<typename T, typename U, typename... Ts>
  std::uint8_t *byteSwap(std::uint8_t *dest) const
  {
    static_assert(
        detail::isPacked<T, U, Ts...>(),
        "converting endianness of possibly padded range of objects not implemented yet");
 
    return byteSwap<U, Ts...>(byteSwap<T>(dest));
  }
 
  mutable detail::BufferedIStream is_;
};
 
using BinaryLittleEndianParserPolicy = BinaryParserPolicy<LittleEndian>;
using BinaryBigEndianParserPolicy = BinaryParserPolicy<BigEndian>;
 
}
 
#endif