TMBoostLA Class Reference

#include <TMBoostLA.h>

Inheritance diagram for TMBoostLA:

List of all members.

Public Member Functions
	TMBoostLA ()
virtual	~TMBoostLA ()
virtual void	handleUpdate (TMPacket *pkt)
virtual void	write2gml (string fname)
virtual void	handleLinkStateUpdate (LSMPacket *pkt)
virtual void	handleMetaDataUpdate (MetaDataPacket *pkt)
virtual void	calcFIDsFromTM_2_Nodes ()
Protected Member Functions
virtual void	initialize (int stage)
virtual int	numInitStages () const
virtual void	finish ()
virtual void	initializeGraph ()
virtual Vertex	getVertex (string nodeid)
virtual bool	vertexExists (string nodeid)
virtual Edge	getEdge (string lid, bool &found)
virtual bool	setEdgeWeights (string IIID)
virtual string	getFIDFromBoostResult_rec (Vertex src, Vertex dst, vector< Vertex > pre)
virtual vector< string >	getPathFromBoostResult_rec (Vertex src, Vertex dst, vector< Vertex > pre)
virtual string	getFIDFromPath (vector< string > path)
virtual double	getWeightFromBoostResult_rec (Vertex src, Vertex dst, vector< Vertex > pre)
Protected Attributes
GraphWrapper< VertexProp, EdgeProp >	g
	The graph representation.
weightMap	weightmap
	I don't think it is used in this version.
Private Types
typedef GraphWrapper < VertexProp, EdgeProp > ::Vertex	Vertex
typedef GraphWrapper < VertexProp, EdgeProp >::Edge	Edge
typedef GraphWrapper < VertexProp, EdgeProp > ::EdgePair	EdgePair
typedef GraphWrapper < VertexProp, EdgeProp > ::Graph	Graph
typedef property_map< Graph, edge_weight_t >::type	weightMap
typedef std::vector< Vertex >	predecessormap
typedef std::vector< double >	distancemap

---

Detailed Description

Extended Boost Topology Manager Application. Performs a traditional shortest path calculation and assigned each Subscriber to the closest Publisher.

---

Member Typedef Documentation

typedef std::vector<double> TMBoostLA::distancemap [private]

typedef GraphWrapper<VertexProp,EdgeProp>::Edge TMBoostLA::Edge [private]

typedef GraphWrapper<VertexProp,EdgeProp>::EdgePair TMBoostLA::EdgePair [private]

typedef GraphWrapper<VertexProp,EdgeProp>::Graph TMBoostLA::Graph [private]

typedef std::vector<Vertex> TMBoostLA::predecessormap [private]

typedef GraphWrapper<VertexProp,EdgeProp>::Vertex TMBoostLA::Vertex [private]

typedef property_map<Graph, edge_weight_t>::type TMBoostLA::weightMap [private]

---

Constructor & Destructor Documentation

TMBoostLA::TMBoostLA

(

)

Boost Topology Manager Interface class constructor.

{

}

TMBoostLA::~TMBoostLA

(

)

[virtual]

Boost Topology Manager Interface class destructor.

{

}

---

Member Function Documentation

void TMBoostLA::calcFIDsFromTM_2_Nodes

(

)

[virtual]

Calculates the FID from the Topology Manager to every node of the network according to the shortest path.

                                      {
  // predecessor_map
  std::vector<Vertex> p(g.getVertexCount());
  // distance_map
  std::vector<double> d(g.getVertexCount());

  Vertex src = getVertex(myNodeId);

  //XXX::The Topology manager is not path of the network in the simulation! Be carefull!!!
  dijkstra_shortest_paths(g.getGraph(), src, predecessor_map(&p[0]).distance_map(&d[0]));
  // For all nodes - update!
  for (TMtoNodes::iterator it = tm2nodes.begin(); it!=tm2nodes.end(); ++it){
    
    Vertex dst = getVertex(it->first);
    it->second = lidOR(getFIDFromBoostResult_rec(src, dst, p), getNodeInternalLID(it->first));
  }
  // WoW Easier than it sounds!
}

void TMBoostLA::finish

(

)

[protected, virtual]

The finish function of the Boost Topology Manager.

Reimplemented from TMInterface.

{
        TMInterface::finish();

        //Clear Graph
        g.clear();
}

TMBoostLA::Edge TMBoostLA::getEdge	(	string	lid,
		bool &	found
	)			[protected, virtual]

Get an edge based on the LID...

                                                        {
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {
                if (g.properties(*ei).lid.compare(lid)==0) {
                        found=true;
                        return *ei;
                }
        }
        found=false;
        // ?
        return Edge();
}

string TMBoostLA::getFIDFromBoostResult_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre
	)			[protected, virtual]

Visit the predecessor map and calculate FID for a single destination/sub. RECURSIVE

                                                                                     {
 
        Vertex pre_v = pre[dst];

        // Terminal Condition! Add node it
        if (dst == src) return "";

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(pre_v,dst);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
        return "";
        }

        Edge e = edge_res.first;

        // Get all the previous recursively
        string newfid=getFIDFromBoostResult_rec(src,pre_v,pre);

        newfid=lidOR(newfid,g.properties(e).lid);

        return newfid;
}

string TMBoostLA::getFIDFromPath

(

vector< string >

path

)

[protected, virtual]

                                                    {
        //The variable to OR the various lids
        string newfid="";

        //For all elements of the path, calculate the FID
        for(uint i=0;i<path.size();i++) {
                newfid=lidOR(newfid,path[i]);
        }

        return newfid;
}

vector< string > TMBoostLA::getPathFromBoostResult_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre
	)			[protected, virtual]

Visit the predecessor map and find out all the path lids. RECURSIVE

                                                                                               {
        //Find the next hop
        Vertex pre_v = pre[dst];
        //The variable to preserve the path lid so far found
        vector<string> path;

        // Terminal Condition! Add node it
        if (dst == src) return path;

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(pre_v,dst);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
                return path;
        }

        Edge e = edge_res.first;

        // Get all the previous recursively
        path=getPathFromBoostResult_rec(src,pre_v,pre);

        path.push_back(g.properties(e).lid);

        return path;
}

TMBoostLA::Vertex TMBoostLA::getVertex

(

string

nodeid

)

[protected, virtual]

Get a vertex by nodeid, it returns UINT_MAX in case that the vertex is not found!

                                                 {

        GraphWrapper<VertexProp,EdgeProp>::vertex_iterator vi, vend;
        for (tie(vi, vend) = g.getVertices(); vi != vend; ++vi) {
          if (g.properties(*vi).nodeid.compare(nodeid)==0) return *vi;
        }

        return UINT_MAX;

}

double TMBoostLA::getWeightFromBoostResult_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre
	)			[protected, virtual]

Visit the predecessor map and calculate path weight for a single destination/sub. RECURSIVE

                                                                                        {

        Vertex pre_v = pre[dst];

        // Terminal Condition! Add node it
        if (dst == src) return(0);

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(pre_v,dst);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
        return(0);
        }

        Edge e = edge_res.first;

        // Get all the previous recursively
        double weight=getWeightFromBoostResult_rec(src,pre_v,pre);

        weight+=g.properties(e).weight;

        return weight;
}

void TMBoostLA::handleLinkStateUpdate

(

LSMPacket *

pkt

)

[virtual]

Handles the packets carrying link state status information. -- DUMMY

Implements TMInterface.

                                                   {
  ev << " - TMBoostLA::handleLinkStateUpdate" << endl;
  
  int replen = pkt->getRepLen();
  bool found=false;
  for (int i=0; i<replen; i++){
    Edge e = getEdge(pkt->getLid(i),found);
    if (!found){
      cerr<<"TMBoostLA: LID NOT FOUND!: "<<pkt->getLid(i)<<endl;
      continue;
    }
    g.properties(e).status = pkt->getLinkStatus(i);
  }
  
  //write2gml("/tmp/top.graphml");
}

void TMBoostLA::handleMetaDataUpdate

(

MetaDataPacket *

pkt

)

[virtual]

Handles the MetaData packets received directly from the publishers.

Implements TMInterface.

                                                        {
        updateInformationItemMetaData(pkt);
}

void TMBoostLA::handleUpdate

(

TMPacket *

pkt

)

[virtual]

Handle packet function for Click Modular Router. Called by the handleMessage() function of the Omnet++ module.

Implements TMInterface.

                                            {
  
  ev << " - TMBoostLA::handleUpdate" << endl;
  
  //Update the Information Items in the Topology Manager and return the Information Item ID in a hex form
  string hex_id = updateInformationItems(tmpkt);

  //Re-initialize weights
  //Setting the weights map
  weightmap = get(edge_weight, g.getGraph());

  //Set the weight-map weight for the Dijkstra operation
  if(!setEdgeWeights(hex_id))
          return;

  // Search all the IItems and run algorithm for the changed
  for (InfoItems::iterator it = ii.begin(); it!=ii.end(); ++it){
    
    ev << "   - Checking: " << it->first << " status: " << it->second.ii_updated << endl;
    // Not changed... continue
    if (!it->second.ii_updated) continue;

    IIDetails  *itd = &it->second;
    // Check that we have publishers
    if (itd->pubs.size() == 0){
      ev << "   - SHIT: No Publishers for item " << it->first << "???" << endl;
      ev << "    - What should i do??? " << endl;
      itd->ii_updated = false;
      //itd->fid_updated = false;
      continue;
    }
    
    // Check that we have subscribers
    if (itd->subs.size() == 0){
      ev << "   - No Subscribers for item " << it->first << endl;
      // Cancel the transmission
      itd->ii_updated = false;
      //itd->fid_updated = true;
      // Clear fids for all publishers of the Information Item
          for(uint i=0;i<itd->pubs.size();i++) {
                  itd->pubs[i].fid = "";
                  itd->pubs[i].fid_updated = true;
          }
      continue;
    }
    
    // Clear fids and paths for all publishers of the Information Item
    for(uint i=0;i<itd->pubs.size();i++) {
        //Clear fids
        itd->pubs[i].fid = "";
        //Clear the link paths
        itd->pubs[i].paths.empty();
        //Update the fid_update flag for the selected publisher
        itd->pubs[i].fid_updated = true;
    }

    /*
         * The weight vector collects the link weight of every path from every publisher to
         * every subscriber. Therefore for it has the following format:
         *
         *                                         Number of Subs
         *              |-----------------------------------------|
         *      N       |P1-S1|P1-S2|P1-S3|P1-S4| ... | ... | ... |
         *      u       |-----+-----+-----+-----+-----+-----+-----|
         *      m       |P2-S1|P2-S2| ... | ... | ... | ... | ... |
         *      b       |-----+-----+-----+-----+-----+-----+-----|
         *      e       |P3-S1|P3-S2| ... | ... | ... | ... | ... |
         *      r       |-----+-----+-----+-----+-----+-----+-----|
         *              |P4-S1| ... | ... | ... | ... | ... | ... |
         *      o       |-----+-----+-----+-----+-----+-----+-----|
         *      f       | ... | ... | ... | ... | ... | ... | ... |
         *              |-----+-----+-----+-----+-----+-----+-----|
         *      P       | ... | ... | ... | ... | ... | ... | ... |
         *      u       |-----+-----+-----+-----+-----+-----+-----|
         *      b       | ... | ... | ... | ... | ... | ... | ... |
         *      s       |-----+-----+-----+-----+-----+-----+-----|
         *              | ... | ... | ... | ... | ... | ... | ... |
         *              |-----------------------------------------|
         *
         * For the path weight calculation, each line is divided and the minimum cell is
         *  chosen. This cell will reveal the publisher selected for this subscriber.
         */

    //Vector for counting the weight of the path for each publisher source
    std::vector< vector<double> > weight_vector( itd->subs.size(), vector<double>(itd->pubs.size(),0.0) );


    // Vector of predecessor_maps
    std::vector<predecessormap> pre_maps(itd->pubs.size());

        // Vector of distance_maps
        std::vector<distancemap> dis_maps(itd->pubs.size());

        // ------------------------------------------------------------------------------ //
    // -------- Find path from every publisher and check who is the best one -------- //
    // ------------------------------------------------------------------------------ //
    for(uint pindex=0;pindex<itd->pubs.size();pindex++) {
    
                // Here we take the 1st publisher! Optimization could be done!
                Vertex tempsrc = getVertex(itd->pubs[pindex].pub);

                // Sanity Check
                if (tempsrc == UINT_MAX){
                  opp_error("*** What THE HELL: Check your topology parser, NO VERTEX FOR PUBLISHER ??? ");
                  continue;
                }

                // Yay... Do the job...
                // predecessor_map
                std::vector<Vertex> p(g.getVertexCount());
                // distance_map
                std::vector<double> d(g.getVertexCount());

                ev << "   - Going for item " << it->first << " published from vertex " << tempsrc << endl;

                dijkstra_shortest_paths(g.getGraph(), tempsrc, predecessor_map(&p[0]).distance_map(&d[0]));

                //Save results of predecessor and distance maps
                pre_maps[pindex]=p;
                dis_maps[pindex]=d;

                for (uint i=0; i<itd->subs.size(); ++i){
                        Vertex dst = getVertex(itd->subs[i]);
                        weight_vector[i][pindex]=getWeightFromBoostResult_rec(tempsrc, dst, p);
                }
    }
    // ------------------------------------------------------------------------------ //

    // ------------------------------------------------------------------------------ //
    // -- For each subscriber find the best publisher and add the fid of the route -- //
    // ------------------------------------------------------------------------------ //
    for(uint sindex=0; sindex<itd->subs.size(); sindex++) {
        //Access the 1D vector of weights (for this subscriber)
        std::vector<double> sub_weight=weight_vector[sindex];

                //Find the position of the publisher with the minimum weight spanning tree
                int minPos=std::min_element(sub_weight.begin(),sub_weight.end())-sub_weight.begin();

                ev << "Source selected: " << itd->pubs[minPos].pub << " for subscriber " << itd->subs[sindex] << endl;

                //Select as src the found publisher
                Vertex src = getVertex(itd->pubs[minPos].pub);

                // predecessor_map
                std::vector<Vertex> p(g.getVertexCount());
                p=pre_maps[minPos];
                // distance_map
                std::vector<double> d(g.getVertexCount());
                d=dis_maps[minPos];

                // Make the fid and path for the selected subscriber
                Vertex dst = getVertex(itd->subs[sindex]);
                //Get the path lids from the specified source to the specified destination
                vector<string> boostPath=getPathFromBoostResult_rec(src, dst, p);
                itd->pubs[minPos].paths.insert(itd->pubs[minPos].paths.end(),boostPath.begin(),boostPath.end());
                // Get FID src to dst
                itd->pubs[minPos].fid = lidOR(itd->pubs[minPos].fid, getFIDFromPath(itd->pubs[minPos].paths));
                // Add the dst node internal LID! is needed
                itd->pubs[minPos].fid = lidOR(itd->pubs[minPos].fid, getNodeInternalLID(itd->subs[sindex]));

                ev << "   - FID Found " << src << ": " << itd->pubs[minPos].fid << endl;
    }
    // ------------------------------------------------------------------------------ //
    // Update Flags
        //itd->fid_updated = true; // NEWFID
        itd->ii_updated = false; // UNMODIFIED SINCE LAST RUN
  }
  
  // Here we should be done! Update all the publishers with new FIDs
  updateAllThePublishers();
  
}

void TMBoostLA::initialize

(

int

stage

)

[protected, virtual]

Initialization function

Reimplemented from TMInterface.

                                    {

        TMInterface::initialize(stage);

        //The TMInterace Initialized at stage 2. To be safe
        //let's initialize on stage later.
        if(stage==3) {
                // At this stage the Topology Manager configuration is fed to Boost++
                initializeGraph();
                //write2gml("InitialGraph.gml");
        }
}

void TMBoostLA::initializeGraph

(

)

[protected, virtual]

Initialize BGraph from topology

                               {
  
        for (uint i=0; i<topology.size(); ++i){
                // Check n Add source
                Vertex src = getVertex(topology[i].src);
                if (src == UINT_MAX){
                        VertexProp vp;
                        vp.nodeid=topology[i].src;
                        src=g.addVertex(vp);
                }

                // Check n Add destination
                Vertex dst = getVertex(topology[i].dst);
                if (dst == UINT_MAX){
                        VertexProp vp;
                        vp.nodeid=topology[i].dst;
                        dst=g.addVertex(vp);
                }

                // NOTE: Avoid LOOPs !!
                if (dst==src) continue;

                // Add edge
                EdgeProp ep;
                ep.weight = 1; // FIXME:TODO Initial weight!
                ep.lid = topology[i].lid;
                g.addEdge(src,dst,ep);
        }

        //Setting the weights map
        weightmap = get(edge_weight, g.getGraph());
}

virtual int TMBoostLA::numInitStages

(

)

const [inline, protected, virtual]

Returns the number of initialization stages.

Reimplemented from TMInterface.

{return 5;};

bool TMBoostLA::setEdgeWeights

(

string

IIID

)

[protected, virtual]

Set the weight for the specified edge, according to the report sent by the network modules.

                                          {

        //Find the Information Item, in the list of all the known ones
        InfoItems::iterator it=ii.find(IIID);

        if(it==ii.end()) {
                ev << "Unknown Information Item requested in TM, " << endl;
                return(false);
        }

        //For all edges, compute their weights according to the QoS requirements of the Information Item
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {
                QoSList param=g.properties(*ei).status;

                //Make sure we have all the necessary QoS parameters for the weight computation
                if(param.find(QoS_USEDRATE)!=param.end() && param.find(QoS_CAPACITY_M)!=param.end() &&  param.find(QoS_COST)!=param.end() &&
                   it->second.metadata.find(QoS_BW_M)!=it->second.metadata.end() && it->second.metadata.find(QoS_FLOW)!=it->second.metadata.end()) {

                        //If the link is empty
                        if(param.find(QoS_USEDRATE)->second==0) {
                                g.properties(*ei).weight = 1;
                                weightmap[*ei]=g.properties(*ei).weight;
                        }
                        //If there are any links that have space for the new stream calculate with a weight given by the selected formula
                        else if( (param.find(QoS_CAPACITY_M)->second - param.find(QoS_USEDRATE)->second) > it->second.metadata.find(QoS_BW_M)->second) {
                                g.properties(*ei).weight = (double)pow((double)(param.find(QoS_CAPACITY_M)->second - param.find(QoS_USEDRATE)->second)/param.find(QoS_CAPACITY_M)->second,3);
                                weightmap[*ei]=g.properties(*ei).weight;
                        }
                        //If the link is full...
                        else {
                                //Check if the Information Item is currently passing through the examined link
                                bool pass=false;
                                for(uint i=0;i<it->second.pubs.size();i++) {
                                        if(find(it->second.pubs[i].paths.begin(),it->second.pubs[i].paths.end(),g.properties(*ei).lid) != it->second.pubs[i].paths.end())
                                                pass=true;
                                }

                                //If it is passing calculate with a weight given by the selected formula
                                if(pass) {
                                        g.properties(*ei).weight = (double)pow((double)(param.find(QoS_CAPACITY_M)->second - param.find(QoS_USEDRATE)->second)/param.find(QoS_CAPACITY_M)->second,3);
                                        weightmap[*ei]=g.properties(*ei).weight;
                                }
                                //Other wise give it a big weight
                                else {
                                        g.properties(*ei).weight = 10;
                                        weightmap[*ei]=g.properties(*ei).weight;
                                }
                        }
                }
                //Else set the standard weight equal to 2 - the maximum
                else {
                        g.properties(*ei).weight = 10;
                        weightmap[*ei]=g.properties(*ei).weight;
                }
        }
        return(true);
}

bool TMBoostLA::vertexExists

(

string

nodeid

)

[protected, virtual]

Check that a vertex exists by nodeid

                                         {
        return (!getVertex(nodeid) == UINT_MAX);
}

void TMBoostLA::write2gml

(

string

fname

)

[virtual]

Extracts the network graph in a xml format, proving the ability of monitoring the network on runtime.

                                     {
        // Chinese Language with mixed Greek follows!
        std::ofstream fout(fname.c_str());
        if (!fout) return;

        string top="<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?> \n\
        <graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:y=\"http://www.yworks.com/xml/graphml\" xmlns:yed=\"http://www.yworks.com/xml/yed/3\" xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd\"> \n\
        <key id=\"key0\" for=\"node\" attr.name=\"id\" attr.type=\"string\" />\n\
        <key id=\"key1\" for=\"edge\" attr.name=\"weight\" attr.type=\"int\" /> \n\
        <key id=\"key2\" for=\"edge\" attr.name=\"lid\" attr.type=\"string\" />\n\
        <key for=\"edge\" id=\"d12\" yfiles.type=\"edgegraphics\"/> \n\
        <key for=\"node\" id=\"d7\" yfiles.type=\"nodegraphics\"/>\n\
        <graph id=\"G\" edgedefault=\"directed\" parse.nodeids=\"canonical\" parse.edgeids=\"canonical\" parse.order=\"nodesfirst\">\n";

        fout.write(top.c_str(), top.length());

        GraphWrapper<VertexProp,EdgeProp>::vertex_iterator vi, vend;
        for (tie(vi, vend) = g.getVertices(); vi != vend; ++vi) {
                VertexProp p = g.properties(*vi);
                string nodestr="<node id=\""+p.nodeid+"\">\n";
                nodestr+=" <data key=\"key0\">"+p.nodeid+"</data>\n";
                nodestr+=" <data key=\"d7\">\n\
                  <y:GenericNode configuration=\"ShinyPlateNode\">\n\
                   <y:NodeLabel alignment=\"center\" autoSizePolicy=\"content\" fontFamily=\"Dialog\" fontSize=\"12\" fontStyle=\"plain\" hasBackgroundColor=\"false\" hasLineColor=\"false\" height=\"4.0\" modelName=\"internal\" modelPosition=\"s\" textColor=\"#000000\" visible=\"true\" width=\"4.0\" >"+p.nodeid+"</y:NodeLabel>\n\
                  </y:GenericNode>\n\
                 </data>\n";
                nodestr+="</node>\n";

                fout.write(nodestr.c_str(), nodestr.length());
        }

        int count=0;
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {
                EdgeProp p = g.properties(*ei);
                stringstream ss;
                ss<<"e"<<count;
                count++;
                string lid=chararray_to_bin(p.lid);

                string edgestr = "<edge id=\""+ss.str()+"\" source=\""+g.getSourceProp(*ei).nodeid+
                                  "\" target=\""+g.getTargetProp(*ei).nodeid+"\">\n";
                ss.clear();
                ss.str(std::string());
                ss<<p.weight;
                edgestr += " <data key=\"key1\">"+ss.str()+"</data>\n";
                edgestr += " <data key=\"key2\">"+lid+"</data>\n";
                edgestr+=" <data key=\"d12\">\n\
                  <y:PolyLineEdge>\n\
                        <y:Arrows source=\"none\" target=\"delta\"/>\n\
                  </y:PolyLineEdge>\n\
                 </data>\n";
                edgestr += "</edge>\n";
                fout.write(edgestr.c_str(), edgestr.length());
        }

        string bottom=" </graph>\n</graphml>";
        fout.write(bottom.c_str(), bottom.length());
        fout.close();
}

---

Member Data Documentation

GraphWrapper<VertexProp, EdgeProp> TMBoostLA::g [protected]

The graph representation.

weightMap TMBoostLA::weightmap [protected]

I don't think it is used in this version.

---

The documentation for this class was generated from the following files:

• TMBoostLA.h
• TMBoostLA.cc