c++ - compartir - open graph example

Impulsar las propiedades de acceso a Graph mediante vertex_descriptor

Question

Tengo mis propiedades de vértice y borde personalizadas

namespace boost { 
    enum vertex_diagonal_t{vertex_diagonal = 999};
    BOOST_INSTALL_PROPERTY(vertex, diagonal);
}
namespace boost { 
    enum edge_dominance_t{edge_dominance = 998};
    BOOST_INSTALL_PROPERTY(edge, dominance);
}

Creé mi lista de adyacencia con boost::property

typedef boost::adjacency_list<
      boost::listS, 
      boost::vecS,
      boost::bidirectionalS,
      boost::property<boost::vertex_diagonal_t, const khut::diagonal*>,
      boost::property<boost::edge_dominance_t,  float>
    > diagonal_dominance_graph;
typedef boost::property_map<diagonal_dominance_graph, boost::vertex_diagonal_t>::type diagonal_map_type;
typedef boost::property_map<diagonal_dominance_graph, boost::edge_dominance_t>::type  dominance_map_type;

Ahora quiero recorrer mis propios contenedores y agregar un vértice

diagonal_dominance_graph graph;
  for(storage_type::const_iterator i = repo_begining.begin(); i != repo_begining.end(); ++i){
    diagonal_dominance_graph::vertex_descriptor dia_vertex = boost::add_vertex(graph);

    //>> ?? HOW CAN I write Properties to dia_vertex HERE ?

    //boost::property<boost::vertex_diagonal_t, const khut::diagonal*> p;
    //boost::put(p, dia_vertex);

  }

Lo que no entiendo es cómo puedo establecer las propiedades de un vértice a través de vertex_descriptor . puede ser que me falta una función simple.

Por favor, no necesito nada que haga que BGL sea aún más complejo, o algo que limpie y reestructure los tipos en mi ejemplo. Solo necesito saber cómo leer / escribir propiedades a través de un vertex_descriptor o edge_descriptor

Answer 1

Está utilizando listas de propiedades: están documentadas aquí .

Entonces en tu ejemplo, usarías

diagonal_map_type  vp = get(boost::vertex_diagonal, graph);

using storage_type = std::vector<int>;
storage_type repo_begining(10);

for(storage_type::const_iterator i = repo_begining.begin(); i != repo_begining.end(); ++i) {
    diagonal_dominance_graph::vertex_descriptor dia_vertex = boost::add_vertex(graph);


    khut::diagonal* v = nullptr;
    boost::put(vp, dia_vertex, v);
}

// likewise for edges
dominance_map_type ep = get(boost::edge_dominance, graph);

Véalo en vivo en Coliru

Propiedades incluidas

La misma página de documentación dice:

NOTA : Boost Graph Library admite dos métodos intercambiables para especificar propiedades interiores: propiedades agrupadas y listas de propiedades. El primero es más fácil de usar y requiere menos esfuerzo, mientras que el último es compatible con compiladores rotos y antiguos, y es compatible con versiones anteriores de Boost anteriores a 1.32.0. Si necesita absolutamente estas características de compatibilidad, siga leyendo para obtener información sobre las listas de propiedades. De lo contrario, le sugerimos encarecidamente que lea sobre el mecanismo de propiedades incluidas.

Boost 1.32 fechas hace más de 10 años! Entonces, sugeriría propiedades agrupadas:

Live On Coliru

#include <boost/graph/adjacency_list.hpp>

namespace khut {
    struct diagonal { };

    struct MyVertexProperties {
        diagonal const* diag_ptr;
    };

    struct MyEdgeProperties {
        float dominance;
    };
}

typedef boost::adjacency_list<
      boost::listS, 
      boost::vecS,
      boost::bidirectionalS,
      khut::MyVertexProperties,
      khut::MyEdgeProperties
    > diagonal_dominance_graph;

#include <iostream>


int main() {
    using namespace boost;

    diagonal_dominance_graph g;

    khut::diagonal d1, d2;
    {
        auto v1 = add_vertex(khut::MyVertexProperties { &d1 }, g);
        auto v2 = add_vertex(khut::MyVertexProperties { &d2 }, g);

        /*auto e1 = */add_edge(v1, v2, khut::MyEdgeProperties { 42.31415926 }, g);
    }

    for(diagonal_dominance_graph::vertex_descriptor vd : make_iterator_range(vertices(g)))
        std::cout << "Is diagonal d1? " << std::boolalpha << (&d1 == g[vd].diag_ptr) << "/n";
    for(diagonal_dominance_graph::edge_descriptor ed : make_iterator_range(edges(g)))
        std::cout << "Edge dominance: " << g[ed].dominance << "/n";
}

Huellas dactilares

Is diagonal d1? true
Is diagonal d1? false
Edge dominance: 42.3142