Edge.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
 
#include <AtomsUtils/Globals.h>
#include <AtomsUtils/AtomsMath.h>
#include <vector>
 
 
namespace AtomsUtils
{
 
    template <class T> class Edge
    {
        public:
            Edge();
 
 
            Edge(const T & v0, const T & v1, unsigned int id = 0);
 
            Edge(const T& v0, const T& v1, const unsigned int p0Id, const unsigned int p1Id);
 
            ~Edge();
 
            bool operator==(const Edge<T> & other) const;
 
        public:
            T p0;
 
            T p1;
 
            unsigned int id;
 
            unsigned int p0Id;
 
            unsigned int p1Id;
 
        };
 
    //--------------------
    // Convenient typedefs
    //--------------------
    typedef Edge<AtomsMath::Vector2f> Edge2;
    typedef Edge<AtomsMath::Vector3f> Edge3;
 
    //---------------
    // Implementation
    //---------------
 
    template <class T> Edge<T>::Edge() :
    p0(T(0.0, 0.0, 0.0)),
    p1(T(0.0, 0.0, 0.0)),
    id(0),
    p0Id(0),
    p1Id(0)
    {}
 
    template <class T> Edge<T>::Edge(const T & p0, const T & p1, unsigned int id) :
    p0(p0),
    p1(p1),
    id(id),
    p0Id(0),
    p1Id(0)
    {}
 
    template <class T> Edge<T>::Edge(const T& p0, const T& p1, const unsigned int p0Id, const unsigned int p1Id) :
        Edge(p0, p1)
    {
        this->p0Id = p0Id;
        this->p1Id = p1Id;
    }
 
    template <class T>  Edge<T>::~Edge() {}
 
    template <class T> bool Edge<T>::operator==(const Edge<T> & other) const
    {
        return ((other.p0 == p0 && other.p1 == p1) || (other.p0 == p1 && other.p1 == p0));
    }
 
    
    template <class T>  std::ostream & operator<<(std::ostream & os, const Edge<T> & e)
    {
        os << "p0: [" << e.p0 << " ] p1: [" << e.p1 << "]";
        return os;
    }
 
}