UndirectedEdge.h

Go to the documentation of this file.

//
//  VBOVertex.h
//  GlobeEngine
//
//  Created by Mathias Thöny on 27.12.11.
//  Copyright (c) 2011 University of Zurich. All rights reserved.
//

#ifndef GlobeEngine_UndirectedEdge_h
#define GlobeEngine_UndirectedEdge_h
#include "VBOVertex.h"
#include "OpenGL_Includes.h"
#include <iostream>

namespace geGraph {
    /*
     * undirected edge
     */
    template <class T> class UndirectedEdge
    {
    public:
        UndirectedEdge() {
            create(std::numeric_limits<T>::max(), std::numeric_limits<T>::max(), std::numeric_limits<T>::max());
        }
        
        UndirectedEdge(T _node1, T _node2) {
            create(std::numeric_limits<T>::max(), _node1,_node2);
        }
        
        UndirectedEdge(T _uid, T _node1, T _node2) {
            create(_uid, _node1,_node2);
        }
        
        void create(T _uid, T _node1, T _node2) {
            marked = false;
            uid = _uid;
            setNodes(_node1,_node2);
        }
        
        void setNodes(T _node1, T _node2) {
            nodes[0] = _node1;
            nodes[1] = _node2;
        }
        
        const T* getNodes() const {
            return nodes;
        }
        
        T getOppositeNode(T _nodeID) const {
            if (_nodeID != nodes[0] && _nodeID != nodes[1]) {
                //std::cout << "cannot find this node connected to edge" << std::endl;
                return 0;
            }
            if(_nodeID == nodes[0]) {
                return nodes[1];
            }
            return nodes[0];
        }
        
        bool isIDaNeighborNode(T _nodeID) {
            if(this->nodes[0] == _nodeID || this->nodes[1] == _nodeID){
                return true;
            }
            return false;
        }
        
        void mark(){
            this->marked = true;
        }
        
        void unmark(){
            this->marked = false;
        }
        
        bool isMarked(){
            return this->marked;
        }
        
        friend std::ostream& operator<< (std::ostream &out, const UndirectedEdge< T > &edge) {
            out << "("<< edge.uid << ": " << edge.nodes[0] << ", " << edge.nodes[1] << ", marked: " << edge.marked << ")";
            return out;
        }
        
    protected:
        bool marked;
        T uid;
        T nodes[2];
    };
    
    typedef UndirectedEdge<unsigned int> Edgeui;
    typedef UndirectedEdge<unsigned int> UndirectedEdgeui;
}
#endif