std.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_STD_HPP
#define PLYWOOT_STD_HPP
 
 
#ifdef PLYWOOT_USE_FAST_FLOAT
#include <fast_float/fast_float.h>
#endif
 
#ifdef PLYWOOT_USE_FAST_INT
#include <fast_int/fast_int.hpp>
#endif
 
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iterator>
#include <sstream>
#include <string>
 
namespace plywoot::detail {
 
template<typename Ptr>
constexpr Ptr align(Ptr ptr, std::size_t alignment)
{
  // Some explanation on the code below; -x is x in two's complement, which
  // means that an alignment value x of power two is converted to (~x + 1).
  // For example, for an alignment value of 4, this turns 0b000100 into
  // 0b111100. The factor (uintptr + alignment - 1u) guarantees that the
  // alignment bit is set unless (uintptr % alignment == 0).
  const auto uintptr = reinterpret_cast<uintptr_t>(ptr);
  return reinterpret_cast<Ptr>((uintptr + alignment - 1u) & -alignment);
}
 
template<>
constexpr std::size_t align(std::size_t ptr, std::size_t alignment)
{
  // Some explanation on the code below; -x is x in two's complement, which
  // means that an alignment value x of power two is converted to (~x + 1).
  // For example, for an alignment value of 4, this turns 0b000100 into
  // 0b111100. The factor (ptr + alignment - 1u) guarantees that the
  // alignment bit is set unless (ptr % alignment == 0).
  return (ptr + alignment - 1u) & -alignment;
}
 
template<typename Number>
inline Number to_number(const char *first, const char *last, const char **end)
{
#ifdef PLYWOOT_USE_FAST_INT
  Number n{};
  *end = fast_int::from_chars(first, last, n).ptr;
  return n;
#else
  return std::strtoll(first, const_cast<char **>(end), 10);
#endif
}
 
template<>
inline float to_number<>(const char *first, const char *last, const char **end)
{
#ifdef PLYWOOT_USE_FAST_FLOAT
  float x;
  *end = fast_float::from_chars(first, last, x).ptr;
  return x;
#else
  return std::strtof(first, const_cast<char **>(end));
#endif
}
 
template<>
inline double to_number<double>(const char *first, const char *last, const char **end)
{
#ifdef PLYWOOT_USE_FAST_FLOAT
  double x;
  *end = fast_float::from_chars(first, last, x).ptr;
  return x;
#else
  return std::strtof(first, const_cast<char **>(end));
#endif
}
 
inline bool starts_with(const std::string &s, const char *prefix) { return s.rfind(prefix, 0) == 0; }
 
template<typename T>
std::string to_string(const T &t)
{
  std::stringstream oss;
  oss << t;
  return oss.str();
}
 
}
 
#endif