Changeset 79018


Ignore:
Timestamp:
Jun 20, 2012, 5:21:01 PM (6 years ago)
Author:
Joachim Faulhaber
Message:

Refactoring data access layer.

Location:
sandbox/icl/libs/xplore/br1/sqlbrowser
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • sandbox/icl/libs/xplore/br1/sqlbrowser/Dag.h

    r78476 r79018  
    1212
    1313#include "dagitem.h"
    14 #include "Dag/DbType.h"
     14#include "Dag.h"
    1515
    1616//JODO CL ..
  • sandbox/icl/libs/xplore/br1/sqlbrowser/Dag/DbType.h

    r79009 r79018  
    113113
    114114    tKey key()const { return m_iKey; }
     115    tString name()const { return m_aName; }
    115116
    116117    int depth()const { return m_depth; }
    117     int setDepth(int depth) { m_depth = depth; }
     118    void setDepth(int depth) { m_depth = depth; }
    118119
    119120private:
  • sandbox/icl/libs/xplore/br1/sqlbrowser/Dag/DecoratedGraph.h

    r78912 r79018  
    1919struct DecoratedGraph
    2020{
     21    typedef VertexDeco tVertexDeco;
     22    typedef EdgeDeco   tEdgeDeco;
     23
    2124    // The kind of vertex_attr_tag is a vertex_property_tag
    2225    struct vertex_attr_tag  { typedef boost::vertex_property_tag kind; };
     
    3134
    3235    typedef boost::adjacency_list
    33     < boost::setS  //Edges:    Sequence or AssociativeContainer
    34     , boost::listS //Vertexes: Sequence or RandomAccessContainer
     36    < boost::vecS  //Edges:    Sequence or AssociativeContainer
     37    , boost::vecS //Vertexes: Sequence or RandomAccessContainer
    3538    , Directed
    36     , tVertexAttrTag
    37     , tEdgeAttrTag
     39    , VertexDeco
     40    , EdgeDeco
    3841    > tGraph;
    3942
     
    4245    typedef typename tGraph::edge_descriptor   edge_descriptor;
    4346
    44     typedef typename boost::property_map<type, vertex_attr_tag>::type tVertexDecoMap;
    45     typedef typename boost::property_map<type, edge_attr_tag>::type   tEdgeDecoMap;
     47    typedef std::map<vertex_descriptor, int>   tVertex2Depth;
    4648
    4749};
  • sandbox/icl/libs/xplore/br1/sqlbrowser/Dag/TypeGraph.cpp

    r79009 r79018  
    33#include <boost/graph/depth_first_search.hpp>
    44#include <boost/graph/graph_utility.hpp>
     5
     6#include <boost/property_map/property_map.hpp>
    57
    68#include "StringVisitor2.h"
     
    911
    1012//using namespace dag::db;
     13struct VertexProps { //CL...
     14  boost::default_color_type color;
     15  std::size_t discover_time;
     16};
     17
     18template<class Key, class Val>
     19struct proper
     20{
     21    typedef Key key_type;
     22    typedef Val value_type;
     23    typedef boost::lvalue_property_map_tag category;
     24};
     25
     26namespace boost
     27{
     28
     29template<class Key, class Val>
     30struct property_traits< proper<Key,Val> >
     31{
     32    typedef Key key_type;
     33    typedef Val value_type;
     34};
     35
     36}
     37
     38template<class Key, class Val>
     39typename proper<Key,Val>::value_type get(const proper<Key,Val>& pro, typename proper<Key,Val>::key_type key)
     40{
     41    typedef typename proper<Key,Val>::key_type KeyType;
     42    return KeyType();
     43}
     44
     45template<class Key, class Val>
     46void put(const proper<Key,Val>& pro, typename proper<Key,Val>::key_type key, typename proper<Key,Val>::value_type val)
     47{
     48    ;
     49}
     50
    1151
    1252dag::db::tString dag::db::TypeGraph::depthFirstString()
    1353{
     54    typedef dag::db::TypeGraph::vertex_descriptor vertex_descriptor;
     55    typedef dag::db::TypeGraph::tVertex2Depth     tVertex2Depth;
     56
     57    tVertex2Depth vertexDepth;
    1458    QString tygraAsString;
     59
     60    typedef  std::map<vertex_descriptor, boost::default_color_type> tColorMap;
     61    std::map<vertex_descriptor, boost::default_color_type> colorMap0;
     62    //boost::associative_property_map< tColorMap > colorMap( colorMap0 );
     63
     64    typedef  std::map<vertex_descriptor, int> tColorMapV;
     65    std::vector<boost::default_color_type> colorMapV( boost::num_vertices(m_aGraph) );
     66
     67    //boost::property_map<dag::db::TypeGraph, boost::default_color_type>::type colorMap2 = get(&VertexProps::color, m_aGraph);
     68    proper<vertex_descriptor, boost::default_color_type> colorMap;
    1569
    1670    boost::depth_first_search(
    1771        m_aGraph
    1872      , boost::visitor(make_dfs_visitor(boost::make_list(
    19                                               StringVisitor2::OnDiscoverVertex(&tygraAsString, m_aVertexDecoMap)
    20                                             , StringVisitor2::OnExamineEdge   (&tygraAsString, m_aVertexDecoMap)
    21                                             , StringVisitor2::OnFinishVertex  (&tygraAsString, m_aVertexDecoMap)
     73                                              StringVisitor2::OnDiscoverVertex(&tygraAsString, vertexDepth)
     74                                            , StringVisitor2::OnExamineEdge   (&tygraAsString, vertexDepth)
     75                                            , StringVisitor2::OnFinishVertex  (&tygraAsString, vertexDepth)
    2276                                            )
    2377                      ))
     78      , colorMap
    2479    );
    2580
  • sandbox/icl/libs/xplore/br1/sqlbrowser/Dag/TypeGraph.h

    r79009 r79018  
    3030    typedef tTypeGraph::vertex_descriptor vertex_descriptor;
    3131    typedef tTypeGraph::edge_descriptor   edge_descriptor;
     32    typedef tTypeGraph::tVertex2Depth     tVertex2Depth;
    3233
    3334    typedef std::map<tKey, vertex_descriptor> tKey2Vertex;
    3435    typedef tKey2Vertex::iterator tKey2Vertex_iterator;
    3536    typedef boost::iterator_range<tKey2Vertex_iterator> tKeyVertexRange;
    36 
    37     typedef tTypeGraph::tVertexDecoMap tVertexDecoMap;
    38     typedef tTypeGraph::tEdgeDecoMap   tEdgeDecoMap;
    3937
    4038    vertex_descriptor add_vertex(tKey key)
     
    6462
    6563        if(edge_added)
    66             m_aEdgeDecoMap[edge] = aEdge;
    67 
    68         //CL m_aVertexDecoMap[srcVertex] = tTypeVertexDeco(srcVertexKey, tString("JODO srcT name"));
    69         //CL m_aVertexDecoMap[trgVertex] = tTypeVertexDeco(trgVertexKey, tString("JODO trgT name"));
     64            m_aGraph[edge] = aEdge;
    7065
    7166    }
     
    7469    {
    7570        Q_ASSERT( m_aKey2Vertex.find(objType.key()) != m_aKey2Vertex.end() );
    76         m_aVertexDecoMap[m_aKey2Vertex[objType.key()]] = objType;
    77     }
    78 
    79 
    80     void resize(std::size_t edgeCount)
    81     {
    82         m_aGraph = tTypeGraph::type(edgeCount);
     71        m_aGraph[m_aKey2Vertex[objType.key()]] = objType;
    8372    }
    8473
     
    10089            vertex_descriptor targetVertex = target(edge, m_aGraph);
    10190
    102             edgesRep += (m_aEdgeDecoMap[*edge_].toString() + " "   );
    103             edgesRep += (m_aVertexDecoMap[sourceVertex].toString()+ " ");
    104             edgesRep += (m_aVertexDecoMap[targetVertex].toString());
     91            edgesRep += (m_aGraph[*edge_].toString() + " "   );
     92            edgesRep += (m_aGraph[sourceVertex].toString()+ " ");
     93            edgesRep += (m_aGraph[targetVertex].toString());
    10594            edgesRep += "\n";
    10695        }
     
    115104    //= boost::graph
    116105    tTypeGraph::type m_aGraph;
    117     tVertexDecoMap   m_aVertexDecoMap;
    118     tEdgeDecoMap     m_aEdgeDecoMap;
    119106
    120107    tKey2Vertex      m_aKey2Vertex;
  • sandbox/icl/libs/xplore/br1/sqlbrowser/StringVisitor.h

    r77476 r79018  
    3535                *p_result += "\n";
    3636            }
    37         }
    38 
    39         //CL Example for iterating over edges.
    40         template<class Vertex, class Graph>
    41         int edge_count(Vertex node, Graph& dag)
    42         {
    43             typedef graph_traits<Graph> GraphTraits;
    44             typename GraphTraits::out_edge_iterator out_i, out_end;
    45             typename GraphTraits::edge_descriptor ed;
    46 
    47             int edge_cnt = 0;
    48             for(boost::tie(out_i, out_end) = boost::out_edges(node, dag); out_i != out_end; ++out_i)
    49                 ++edge_cnt;
    50 
    51             return edge_cnt;
    5237        }
    5338
     
    10792    };
    10893
    109     /*CL
    110     struct OnTreeEdge : public boost::base_visitor<OnTreeEdge>
    111     {
    112         OnTreeEdge(QString* result, Dag::tAttributesMap& names)
    113             : p_result(result), r_attrs(names){}
    114 
    115         typedef boost::on_tree_edge event_filter;
    116 
    117         template<class Edge, class Graph>
    118         void operator()(Edge edge, Graph& dag)
    119         {
    120             int source_depth = r_attrs[source(edge, dag)].depth();
    121             int target_depth = source_depth + 1;
    122             r_attrs[target(edge, dag)].setDepth(target_depth);
    123 
    124             *p_result += ".";
    125         }
    126 
    127         QString*             p_result;
    128         Dag::tAttributesMap& r_attrs;
    129     };
    130     */
    13194
    13295}; // StringVisitor
  • sandbox/icl/libs/xplore/br1/sqlbrowser/StringVisitor2.h

    r79009 r79018  
    1212
    1313#include "Dag/TypeGraph.h"
     14#include "Dag.h" //CL move indentation
    1415
    1516
     
    1718struct StringVisitor2
    1819{
    19     typedef dag::db::TypeGraph::tVertexDecoMap tVertex2Attr;
     20    typedef dag::db::TypeGraph::vertex_descriptor vertex_descriptor;
     21    typedef dag::db::TypeGraph::tVertex2Depth tVertex2Depth;
    2022
    2123    //--------------------------------------------------------------------------
     
    2325    struct OnDiscoverVertex : public boost::base_visitor<OnDiscoverVertex>
    2426    {
    25         OnDiscoverVertex(QString* result, tVertex2Attr& names)
    26             : p_result(result), r_attrs(names){}
     27        OnDiscoverVertex(QString* result, tVertex2Depth& vertexDepth)
     28            : p_result(result), r_vertexDepth(vertexDepth){}
    2729
    2830        typedef boost::on_discover_vertex event_filter;
    2931
    3032        template<class Vertex, class Graph>
    31         void operator()(Vertex node, Graph& dag)
     33        void operator()(Vertex node, Graph& graph)
    3234        {
    33             if(boost::out_degree(node, dag) > 0)
     35            if(boost::out_degree(node, graph) > 0)
    3436            {
    35                 dag::db::TypeObject tob = r_attrs[node]; //CL
    36 
    37                 *p_result += indentation(r_attrs[node].depth()) + "(";
    38                 *p_result += r_attrs[node].name();
     37                *p_result += indentation(depth(node)) + "(";
     38                *p_result += graph[node].name();
    3939                *p_result += "\n";
    4040            }
    4141        }
    4242
    43         //CL Example for iterating over edges.
    44         template<class Vertex, class Graph>
    45         int edge_count(Vertex node, Graph& dag)
     43        template<class Vertex>
     44        int depth(Vertex& node)
    4645        {
    47             typedef graph_traits<Graph> GraphTraits;
    48             typename GraphTraits::out_edge_iterator out_i, out_end;
    49             typename GraphTraits::edge_descriptor ed;
    50 
    51             int edge_cnt = 0;
    52             for(boost::tie(out_i, out_end) = boost::out_edges(node, dag); out_i != out_end; ++out_i)
    53                 ++edge_cnt;
    54 
    55             return edge_cnt;
     46            tVertex2Depth::iterator node_ = r_vertexDepth.find(node);
     47            return node_ == r_vertexDepth.end() ? 0 : (*node_).second;
    5648        }
    5749
    58         QString*      p_result;
    59         tVertex2Attr& r_attrs;
     50
     51        QString* p_result;
     52        tVertex2Depth& r_vertexDepth;
    6053    };
    6154
    6255    struct OnExamineEdge : public boost::base_visitor<OnExamineEdge>
    6356    {
    64         OnExamineEdge(QString* result, tVertex2Attr& names)
    65             : p_result(result), r_attrs(names){}
     57        OnExamineEdge(QString* result, tVertex2Depth& vertexDepth)
     58            : p_result(result), r_vertexDepth(vertexDepth){}
    6659
    6760        typedef boost::on_examine_edge event_filter;
    6861
    6962        template<class Edge, class Graph>
    70         void operator()(Edge edge, Graph& dag)
     63        void operator()(Edge edge, Graph& graph)
    7164        {
    72             int source_depth = r_attrs[source(edge, dag)].depth();
     65            //int source_depth = graph[source(edge, graph)].depth();
     66            vertex_descriptor sourceVertex = source(edge, graph);
     67            tVertex2Depth::iterator sourceVertex_ = r_vertexDepth.find(sourceVertex);
     68            int source_depth = sourceVertex_ == r_vertexDepth.end() ? 0 : (*sourceVertex_).second ;
     69
     70            //CL int source_depth = vertexDepth[source(edge, graph)];
    7371            int target_depth = source_depth + 1;
    74             r_attrs[target(edge, dag)].setDepth(target_depth);
    7572
    76             if(boost::out_degree(target(edge, dag), dag)==0)
     73            //CL graph[target(edge, graph)].setDepth(target_depth);
     74            r_vertexDepth[target(edge, graph)] = target_depth;
     75
     76            if(boost::out_degree(target(edge, graph), graph)==0)
    7777            {
    78                 *p_result += indentation(target_depth) + r_attrs[target(edge, dag)].name();
     78                *p_result += indentation(target_depth) + graph[target(edge, graph)].name();
    7979                *p_result += "\n";
    8080            }
    8181        }
    8282
    83         QString*      p_result;
    84         tVertex2Attr& r_attrs;
     83        template<class Vertex>
     84        int depth(Vertex& node)
     85        {
     86            tVertex2Depth::iterator node_ = r_vertexDepth.find(node);
     87            return node_ == r_vertexDepth.end() ? 0 : (*node_).second;
     88        }
     89
     90        QString* p_result;
     91        tVertex2Depth& r_vertexDepth;
    8592    };
    8693
    8794    struct OnFinishVertex : public boost::base_visitor<OnFinishVertex>
    8895    {
    89         OnFinishVertex(QString* result, tVertex2Attr& names)
    90             : p_result(result), r_attrs(names){}
     96        OnFinishVertex(QString* result, tVertex2Depth& vertexDepth)
     97            : p_result(result), r_vertexDepth(vertexDepth){}
    9198
    9299        typedef boost::on_finish_vertex event_filter;
    93100
    94101        template<class Vertex, class Graph>
    95         void operator()(Vertex node, Graph& dag)
     102        void operator()(Vertex node, Graph& graph)
    96103        {
    97             if(boost::out_degree(node, dag) > 0)
     104            if(boost::out_degree(node, graph) > 0)
    98105            {
    99                 *p_result += indentation(r_attrs[node].depth()) + ")";
     106                *p_result += indentation(depth(node)) + ")";
    100107                *p_result += "\n";
    101108            }
    102109        }
    103110
    104         QString*             p_result;
    105         tVertex2Attr& r_attrs;
     111        template<class Vertex>
     112        int depth(Vertex& node)
     113        {
     114            tVertex2Depth::iterator node_ = r_vertexDepth.find(node);
     115            return node_ == r_vertexDepth.end() ? 0 : (*node_).second;
     116        }
     117
     118        QString* p_result;
     119        tVertex2Depth& r_vertexDepth;
    106120    };
    107121
     122    template<class Vertex, class Graph>
     123    void initialize_vertex(Vertex& node, Graph& gra)
     124    {
     125
     126    }
    108127
    109128}; // StringVisitor
  • sandbox/icl/libs/xplore/br1/sqlbrowser/browser.cpp

    r79009 r79018  
    225225    util::launchMsgBox(tygra.toString());
    226226    util::launchMsgBox(tygra.depthFirstString());
    227                            //depthFirstString
    228227
    229228    if(success)
Note: See TracChangeset for help on using the changeset viewer.