Handles.hpp

Go to the documentation of this file.

/*
 * Handles.hpp
 *
 *  @date 15.06.2017
 *  @author Lukas Kalbertodt <lukas.kalbertodt@gmail.com>
 */

#ifndef LVR2_GEOMETRY_HANDLES_H_
#define LVR2_GEOMETRY_HANDLES_H_

#include <cstdint>
#include <functional>

#include "lvr2/util/BaseHandle.hpp"

namespace lvr2
{

using Index = uint32_t;

// Note on strongly typed handles:
//
// You might ask: Why do we need that many classes for handles? Wouldn't one
// be enough? Or you go even further: if every handle is just a simple integer,
// why not store the integer directly. Well, it all comes down to "strong
// typing".
//
// Type systems are the main way for compilers to notice that a program is
// faulty. While compiler errors are just annoying in the first few years of
// learning how to program, they become very useful later on. When writing
// software, humans will make mistakes -- that's just a fact. The question is
// WHEN we want to notice those mistakes. There are a few possibilities here:
//
// - while compiling
// - while executing unit tests
// - in production
//
// No one wants to notice bugs when already running software in production. Thus
// we want to notice our mistakes earlier. Since this whole library clearly
// doesn't care about unit tests, mistakes can only be noticed either at
// compile time or when the developer executes the program.
//
// Well, now the fun parts. When you use a language with a sufficiently
// powerful type system (as C++) and if you are correctly using this type
// system, you can avoid many huge classes of bugs! The compiler will tell you
// right away, when you made a mistake.
//
// So with these strongly typed handles, you cannot falsely assign an EdgeHandle
// to a FaceHandle -- it will result in a compiler error. If you were using
// simple integers, the compiler wouldn't notice and you would have to track
// down the bug manually. Not so great.
//
// Apart from that: it makes reading code so much easier, as you know exactly
// what a specific parameter is for.

class EdgeHandle : public BaseHandle<Index>
{
    using BaseHandle<Index>::BaseHandle;
};

class FaceHandle : public BaseHandle<Index>
{
    using BaseHandle<Index>::BaseHandle;
};

class VertexHandle : public BaseHandle<Index>
{
    using BaseHandle<Index>::BaseHandle;
};

class ClusterHandle : public BaseHandle<Index>
{
    using BaseHandle<Index>::BaseHandle;
};

class TextureHandle : public BaseHandle<Index>
{
    using BaseHandle<Index>::BaseHandle;
};

class OptionalEdgeHandle : public BaseOptionalHandle<Index, EdgeHandle>
{
    using BaseOptionalHandle<Index, EdgeHandle>::BaseOptionalHandle;
};

class OptionalFaceHandle : public BaseOptionalHandle<Index, FaceHandle>
{
    using BaseOptionalHandle<Index, FaceHandle>::BaseOptionalHandle;
};

class OptionalVertexHandle : public BaseOptionalHandle<Index, VertexHandle>
{
    using BaseOptionalHandle<Index, VertexHandle>::BaseOptionalHandle;
};

class OptionalClusterHandle : public BaseOptionalHandle<Index, ClusterHandle>
{
    using BaseOptionalHandle<Index, ClusterHandle>::BaseOptionalHandle;
};

inline std::ostream& operator<<(std::ostream& os, const EdgeHandle& h)
{
    os << "E" << h.idx();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const FaceHandle& h)
{
    os << "F" << h.idx();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const VertexHandle& h)
{
    os << "V" << h.idx();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const ClusterHandle& h)
{
    os << "C" << h.idx();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const OptionalEdgeHandle& h)
{
    if (h)
    {
        os << "E" << h.unwrap().idx();
    }
    else
    {
        os << "E⊥";
    }
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const OptionalFaceHandle& h)
{
    if (h)
    {
        os << "F" << h.unwrap().idx();
    }
    else
    {
        os << "F⊥";
    }
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const OptionalVertexHandle& h)
{
    if (h)
    {
        os << "V" << h.unwrap().idx();
    }
    else
    {
        os << "V⊥";
    }
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const OptionalClusterHandle& h)
{
    if (h)
    {
        os << "C" << h.unwrap().idx();
    }
    else
    {
        os << "C⊥";
    }
    return os;
}

} // namespace lvr2

namespace std
{

template<>
struct hash<lvr2::EdgeHandle> {
    size_t operator()(const lvr2::EdgeHandle& h) const
    {
        return std::hash<lvr2::Index>()(h.idx());
    }
};

template<>
struct hash<lvr2::FaceHandle> {
    size_t operator()(const lvr2::FaceHandle& h) const
    {
        return std::hash<lvr2::Index>()(h.idx());
    }
};

template<>
struct hash<lvr2::VertexHandle> {
    size_t operator()(const lvr2::VertexHandle& h) const
    {
        return std::hash<lvr2::Index>()(h.idx());
    }
};

template<>
struct less<lvr2::VertexHandle> {
    bool operator()(const lvr2::VertexHandle& l, const lvr2::VertexHandle& r) const
    {
        return std::less<lvr2::Index>()(l.idx(), r.idx());
    }
};

template<>
struct hash<lvr2::ClusterHandle> {
    size_t operator()(const lvr2::ClusterHandle& h) const
    {
        return std::hash<lvr2::Index>()(h.idx());
    }
};

template<>
struct hash<lvr2::TextureHandle> {
    size_t operator()(const lvr2::TextureHandle& h) const
    {
        return std::hash<lvr2::Index>()(h.idx());
    }
};

} // namespace std

#endif /* LVR2_GEOMETRY_HANDLES_H_ */