types.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_TYPES_HPP
#define PLYWOOT_TYPES_HPP
 
 
#include <algorithm>
#include <cstdint>
#include <optional>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
 
namespace plywoot {
 
enum class PlyDataType { Char, UChar, Short, UShort, Int, UInt, Float, Double };
 
inline std::ostream &operator<<(std::ostream &os, PlyDataType type)
{
  switch (type)
  {
    case PlyDataType::Char:
      return os << "char";
    case PlyDataType::UChar:
      return os << "uchar";
    case PlyDataType::Short:
      return os << "short";
    case PlyDataType::UShort:
      return os << "ushort";
    case PlyDataType::Int:
      return os << "int";
    case PlyDataType::UInt:
      return os << "uint";
    case PlyDataType::Float:
      return os << "float";
    case PlyDataType::Double:
      return os << "double";
  }
 
  return os;
}
 
enum class PlyFormat {
  Ascii,
  BinaryBigEndian,
  BinaryLittleEndian,
};
 
struct PlyProperty
{
  PlyProperty() = default;
  PlyProperty(std::string name, PlyDataType type) : name_{std::move(name)}, type_{type} {}
  PlyProperty(std::string name, PlyDataType type, PlyDataType sizeType)
      : name_{std::move(name)}, type_{type}, isList_{true}, sizeType_{sizeType}
  {
  }
 
  const std::string &name() const { return name_; }
  PlyDataType type() const { return type_; }
  bool isList() const { return isList_; }
  PlyDataType sizeType() const { return sizeType_; }
 
  inline friend bool operator==(const PlyProperty &x, const PlyProperty &y)
  {
    return x.type_ == y.type_ && x.isList_ == y.isList_ && x.sizeType_ == y.sizeType_ && x.name_ == y.name_;
  }
 
  inline friend bool operator!=(const PlyProperty &x, const PlyProperty &y) { return !(x == y); }
 
private:
  std::string name_;
  PlyDataType type_;
 
  bool isList_{false};
  PlyDataType sizeType_{PlyDataType::Char};
};
 
using PlyPropertyConstIterator = std::vector<PlyProperty>::const_iterator;
 
struct PlyElement
{
  PlyElement() = default;
  PlyElement(std::string name, std::size_t size) : name_{std::move(name)}, size_{size} {}
  PlyElement(std::string name, std::size_t size, std::vector<PlyProperty> properties)
      : name_{std::move(name)}, size_{size}, properties_{std::move(properties)}
  {
  }
 
  const std::string &name() const { return name_; }
  std::size_t size() const { return size_; }
  const std::vector<PlyProperty> &properties() const { return properties_; }
 
  std::optional<PlyProperty> property(const std::string &propertyName) const
  {
    const auto it = std::find_if(properties_.begin(), properties_.end(), [&](const PlyProperty &p) {
      return p.name() == propertyName;
    });
    return it != properties_.end() ? std::optional(*it) : std::nullopt;
  }
 
  template<typename... Args>
  PlyProperty &addProperty(Args &&...args)
  {
    properties_.emplace_back(std::forward<Args>(args)...);
    return properties_.back();
  }
 
  inline friend bool operator==(const PlyElement &x, const PlyElement &y)
  {
    return x.size_ == y.size_ && x.name_ == y.name_ && x.properties_ == y.properties_;
  }
  inline friend bool operator!=(const PlyElement &x, const PlyElement &y) { return !(x == y); }
 
private:
  std::string name_;
  std::size_t size_;
  std::vector<PlyProperty> properties_;
};
 
struct Comment
{
  std::uint32_t line;
  std::string text;
 
  inline friend bool operator==(const Comment &x, const Comment &y)
  {
    return x.line == y.line && x.text == y.text;
  }
  inline friend bool operator!=(const Comment &x, const Comment &y) { return !(x == y); }
};
 
}
 
#endif