embedding.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file embedding.h

/* This software is distributed under the GNU Lesser General Public License */
//==========================================================================
//
//   embedding.h
//
//==========================================================================
// $Id: embedding.h,v 1.20 2003/06/11 11:28:21 raitner Exp $

#ifndef __EMBEDDING__H
#define __EMBEDDING__H

#include <GTL/GTL.h>
#include <GTL/graph.h>
#include <GTL/st_number.h>
#include <GTL/symlist.h>

__GTL_BEGIN_NAMESPACE

class GTL_EXTERN planar_embedding 
{
public:
    typedef symlist<edge> adj_list;

    typedef symlist<edge>::iterator iterator;
private:
    planar_embedding() : G(0)
    {
    }
public:
    planar_embedding(const planar_embedding& em);

    virtual ~planar_embedding()
    {
    }

    planar_embedding& operator=(const planar_embedding& em); 
private:
    void init(graph& G);

    void turn(node n);

    iterator push_back(node n, edge e);

    iterator push_front(node n, edge e);

    void insert_selfloop (edge e);

    iterator& pos (node, edge);
public:
    adj_list& adjacency(node n)
    {
        return adj[n];
    }

    const adj_list& adjacency(node n) const
    {
        return adj[n];
    }

    iterator adj_edges_begin(node n)
    {
        return adj[n].begin();
    } 

    iterator adj_edges_end(node n)
    {
        return adj[n].end();
    }

    edge cyclic_next(node n, edge e);

    edge cyclic_prev(node n, edge e);


    void write_st(ostream& os, st_number& st);

    list<edge>& selfloops()
    {
        return self;
    }

    const list<edge>& selfloops() const
    {
        return self;
    }

    list<edge>& multiple_edges()
    {
        return multi;
    }

    const list<edge>& multiple_edges() const
    {
        return multi;
    }

    bool check();

    friend class planarity;

    friend class pq_tree;

    GTL_EXTERN friend ostream& operator<< (ostream&, planar_embedding&);
private:
    graph* G;

    node_map<adj_list> adj;

    edge_map<adj_list::iterator> s_pos;

    edge_map<adj_list::iterator> t_pos;

    list<edge> self;

    list<edge> multi;
};


// class face
// {    
// public:
//     face (planar_embedding& em, node n, edge e) : embed (em),
//      start (n), first (e) { }
//     virtual ~face () { }

// private:    
//     planar_embedding& embed;
//     node start;
//     edge first;

//     friend class planar_embedding;
// };

// struct _face_iterator
// {


//     face& _face;
// };

__GTL_END_NAMESPACE

#endif

//--------------------------------------------------------------------------
//   end of file
//--------------------------------------------------------------------------