binary_writer_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_WRITER_POLICY_HPP
#define PLYWOOT_BINARY_WRITER_POLICY_HPP
 
 
#include "buffered_ostream.hpp"
#include "endian.hpp"
 
#include <ostream>
 
namespace plywoot::detail {
 
template<typename Endianness>
class BinaryWriterPolicy
{
public:
  BinaryWriterPolicy(std::ostream &os) : os_{os} {}
 
  template<typename T, typename EndiannessDependent = Endianness>
  void writeNumber(T t) const
  {
    if constexpr (std::is_same_v<EndiannessDependent, HostEndian>)
    {
      os_.write(reinterpret_cast<const char *>(&t), sizeof(T));
    }
    else
    {
      const auto bs = byte_swap(t);
      os_.write(reinterpret_cast<const char *>(&bs), sizeof(T));
    }
  }
 
  template<typename PlySizeT, typename PlyT, typename SrcT, typename EndiannessDependent = Endianness>
  void writeList(const SrcT *t, std::size_t n) const
  {
    writeNumber<PlySizeT>(n);
    writeNumbers<PlyT, SrcT>(t, n);
  }
 
  template<typename PlyT, typename SrcT, typename EndiannessDependent = Endianness>
  void writeNumbers(const SrcT *t, std::size_t n) const
  {
    if constexpr (std::is_same_v<PlyT, SrcT> && std::is_same_v<EndiannessDependent, HostEndian>)
    {
      os_.write(reinterpret_cast<const char *>(t), sizeof(SrcT) * n);
    }
    else
    {
      for (std::size_t i = 0; i < n; ++i) { writeNumber<PlyT>(*t++); }
    }
  }
 
  void writeMissingProperties(PlyPropertyConstIterator first, PlyPropertyConstIterator last) const
  {
    while (first != last)
    {
      switch (first->isList() ? first->sizeType() : first->type())
      {
        case PlyDataType::Char:
          writeNumber<char>(0);
          break;
        case PlyDataType::UChar:
          writeNumber<unsigned char>(0);
          break;
        case PlyDataType::Short:
          writeNumber<short>(0);
          break;
        case PlyDataType::UShort:
          writeNumber<unsigned short>(0);
          break;
        case PlyDataType::Int:
          writeNumber<int>(0);
          break;
        case PlyDataType::UInt:
          writeNumber<unsigned int>(0);
          break;
        case PlyDataType::Float:
          writeNumber<float>(0);
          break;
        case PlyDataType::Double:
          writeNumber<double>(0);
          break;
      }
      ++first;
    }
  }
 
  void writeNewline() const {}
  void writeTokenSeparator() const {}
 
private:
  mutable detail::BufferedOStream os_;
};
 
using BinaryLittleEndianWriterPolicy = BinaryWriterPolicy<LittleEndian>;
using BinaryBigEndianWriterPolicy = BinaryWriterPolicy<BigEndian>;
 
}
 
#endif