| 
|   | LC_CSR_Graph (LC_CSR_Graph &&rhs)=default | 
|   | 
|   | LC_CSR_Graph ()=default | 
|   | 
| LC_CSR_Graph &  | operator= (LC_CSR_Graph &&)=default | 
|   | 
| void  | serializeNodeData (boost::archive::binary_oarchive &ar) const  | 
|   | Serializes node data using Boost.  More...
  | 
|   | 
| void  | deSerializeNodeData (boost::archive::binary_iarchive &ar) | 
|   | Deserializes a Boost archive containing node data to the local node data variable.  More...
  | 
|   | 
| void  | serializeGraph (boost::archive::binary_oarchive &ar) const  | 
|   | Serializes graph using Boost.  More...
  | 
|   | 
| void  | deSerializeGraph (boost::archive::binary_iarchive &ar) | 
|   | Deserializes a Boost archive to the local graph.  More...
  | 
|   | 
| uint64_t  | operator[] (uint64_t n) | 
|   | Accesses the "prefix sum" of this graph; takes advantage of the fact that edge_end(n) is basically prefix_sum[n] (if a prefix sum existed + if prefix_sum[0] = number of edges in node 0).  More...
  | 
|   | 
| template<typename EdgeNumFnTy , typename EdgeDstFnTy , typename EdgeDataFnTy >  | 
|   | LC_CSR_Graph (uint32_t _numNodes, uint64_t _numEdges, EdgeNumFnTy edgeNum, EdgeDstFnTy _edgeDst, EdgeDataFnTy _edgeData) | 
|   | 
| node_data_reference  | getData (GraphNode N, MethodFlag mflag=MethodFlag::WRITE) | 
|   | 
| edge_data_reference  | getEdgeData (edge_iterator ni, MethodFlag GALOIS_UNUSED(mflag)=MethodFlag::UNPROTECTED) | 
|   | 
| GraphNode  | getEdgeDst (edge_iterator ni) | 
|   | 
| size_t  | size () const  | 
|   | 
| size_t  | sizeEdges () const  | 
|   | 
| iterator  | begin () const  | 
|   | 
| iterator  | end () const  | 
|   | 
| const_local_iterator  | local_begin () const  | 
|   | 
| const_local_iterator  | local_end () const  | 
|   | 
| local_iterator  | local_begin () | 
|   | 
| local_iterator  | local_end () | 
|   | 
| edge_iterator  | edge_begin (GraphNode N, MethodFlag mflag=MethodFlag::WRITE) | 
|   | 
| edge_iterator  | edge_end (GraphNode N, MethodFlag mflag=MethodFlag::WRITE) | 
|   | 
| edge_iterator  | findEdge (GraphNode N1, GraphNode N2) | 
|   | 
| edge_iterator  | findEdgeSortedByDst (GraphNode N1, GraphNode N2) | 
|   | 
runtime::iterable 
< NoDerefIterator 
< edge_iterator > >  | edges (GraphNode N, MethodFlag mflag=MethodFlag::WRITE) | 
|   | 
runtime::iterable 
< NoDerefIterator 
< edge_iterator > >  | out_edges (GraphNode N, MethodFlag mflag=MethodFlag::WRITE) | 
|   | 
| template<typename CompTy >  | 
| void  | sortEdgesByEdgeData (GraphNode N, const CompTy &comp=std::less< EdgeTy >(), MethodFlag mflag=MethodFlag::WRITE) | 
|   | Sorts outgoing edges of a node.  More...
  | 
|   | 
| template<typename CompTy >  | 
| void  | sortEdges (GraphNode N, const CompTy &comp, MethodFlag mflag=MethodFlag::WRITE) | 
|   | Sorts outgoing edges of a node.  More...
  | 
|   | 
| void  | sortEdgesByDst (GraphNode N, MethodFlag mflag=MethodFlag::WRITE) | 
|   | Sorts outgoing edges of a node.  More...
  | 
|   | 
| void  | sortAllEdgesByDst (MethodFlag mflag=MethodFlag::WRITE) | 
|   | Sorts all outgoing edges of all nodes in parallel.  More...
  | 
|   | 
| void  | allocateFrom (const FileGraph &graph) | 
|   | 
| void  | allocateFrom (uint32_t nNodes, uint64_t nEdges) | 
|   | 
| void  | destroyAndAllocateFrom (uint32_t nNodes, uint64_t nEdges) | 
|   | 
| void  | constructNodes () | 
|   | 
| void  | deallocate () | 
|   | 
| void  | constructEdge (uint64_t e, uint32_t dst, const typename EdgeData::value_type &val) | 
|   | 
| void  | constructEdge (uint64_t e, uint32_t dst) | 
|   | 
| void  | fixEndEdge (uint32_t n, uint64_t e) | 
|   | 
| void  | transpose (const char *regionName=NULL) | 
|   | Perform an in-memory transpose of the graph, replacing the original CSR to CSC.  More...
  | 
|   | 
| template<bool is_non_void = EdgeData::has_value>  | 
| void  | edgeDataCopy (EdgeData &edgeData_new, EdgeData &edgeData, uint64_t e_new, uint64_t e, typename std::enable_if< is_non_void >::type *=0) | 
|   | 
| template<bool is_non_void = EdgeData::has_value>  | 
| void  | edgeDataCopy (EdgeData &, EdgeData &, uint64_t, uint64_t, typename std::enable_if<!is_non_void >::type *=0) | 
|   | 
| template<typename E  = EdgeTy, std::enable_if_t<!std::is_same< E, void >::value, int > *  = nullptr>  | 
| void  | constructFrom (FileGraph &graph, unsigned tid, unsigned total, const bool readUnweighted=false) | 
|   | 
| template<typename E  = EdgeTy, std::enable_if_t< std::is_same< E, void >::value, int > *  = nullptr>  | 
| void  | constructFrom (FileGraph &graph, unsigned tid, unsigned total, const bool GALOIS_UNUSED(readUnweighted)=false) | 
|   | 
| const EdgeIndData &  | getEdgePrefixSum () const  | 
|   | Returns the reference to the edgeIndData LargeArray (a prefix sum of edges)  More...
  | 
|   | 
| auto  | divideByNode (size_t nodeSize, size_t edgeSize, size_t id, size_t total) | 
|   | 
| void  | constructFrom (uint32_t numNodes, uint64_t numEdges, std::vector< uint64_t > &prefix_sum, std::vector< std::vector< uint32_t >> &edges_id, std::vector< std::vector< EdgeTy >> &edges_data) | 
|   | custom allocator for vector<vector<>> Adding for Louvain clustering TODO: Find better way to do this  More...
  | 
|   | 
| void  | constructFrom (uint32_t numNodes, uint64_t numEdges, std::vector< uint64_t > &prefix_sum, galois::gstl::Vector< galois::PODResizeableArray< uint32_t >> &edges_id, std::vector< std::vector< EdgeTy >> &edges_data) | 
|   | 
| template<typename U  = void, typename std::enable_if<!std::is_void< EdgeTy >::value, U >::type *  = nullptr>  | 
| void  | readGraphFromGRFile (const std::string &filename) | 
|   | Reads the GR files directly into in-memory data-structures of LC_CSR graphs using freads.  More...
  | 
|   | 
| template<typename U  = void, typename std::enable_if< std::is_void< EdgeTy >::value, U >::type *  = nullptr>  | 
| void  | readGraphFromGRFile (const std::string &filename) | 
|   | Reads the GR files directly into in-memory data-structures of LC_CSR graphs using freads.  More...
  | 
|   | 
| void  | initializeLocalRanges () | 
|   | Given a manually created graph, initialize the local ranges on this graph so that threads can iterate over a balanced number of vertices.  More...
  | 
|   | 
 | 
| edge_iterator  | raw_begin (GraphNode N) const  | 
|   | 
| edge_iterator  | raw_end (GraphNode N) const  | 
|   | 
| edge_sort_iterator  | edge_sort_begin (GraphNode N) | 
|   | 
| edge_sort_iterator  | edge_sort_end (GraphNode N) | 
|   | 
| template<bool _A1 = HasNoLockable, bool _A2 = HasOutOfLineLockable>  | 
| void  | acquireNode (GraphNode N, MethodFlag mflag, typename std::enable_if<!_A1 &&!_A2 >::type *=0) | 
|   | 
| template<bool _A1 = HasOutOfLineLockable, bool _A2 = HasNoLockable>  | 
| void  | acquireNode (GraphNode N, MethodFlag mflag, typename std::enable_if< _A1 &&!_A2 >::type *=0) | 
|   | 
| template<bool _A1 = HasOutOfLineLockable, bool _A2 = HasNoLockable>  | 
| void  | acquireNode (GraphNode, MethodFlag, typename std::enable_if< _A2 >::type *=0) | 
|   | 
| template<bool _A1 = EdgeData::has_value, bool _A2 = LargeArray<FileEdgeTy>::has_value>  | 
| void  | constructEdgeValue (FileGraph &graph, typename FileGraph::edge_iterator nn, typename std::enable_if<!_A1||_A2 >::type *=0) | 
|   | 
| template<bool _A1 = EdgeData::has_value, bool _A2 = LargeArray<FileEdgeTy>::has_value>  | 
| void  | constructEdgeValue (FileGraph &, typename FileGraph::edge_iterator nn, typename std::enable_if< _A1 &&!_A2 >::type *=0) | 
|   | 
| size_t  | getId (GraphNode N) | 
|   | 
| GraphNode  | getNode (size_t n) | 
|   | 
template<typename NodeTy, typename EdgeTy, bool HasNoLockable = false, bool UseNumaAlloc = false, bool HasOutOfLineLockable = false, typename FileEdgeTy = EdgeTy>
class galois::graphs::LC_CSR_Graph< NodeTy, EdgeTy, HasNoLockable, UseNumaAlloc, HasOutOfLineLockable, FileEdgeTy >
Local computation graph (i.e., graph structure does not change). 
The data representation is the traditional compressed-sparse-row (CSR) format.
The position of template parameters may change between Galois releases; the most robust way to specify them is through the with_XXX nested templates.
An example of use:
  
  Graph g;
  int sum = 0;
  
  for (Graph::iterator ii = g.begin(), ei = g.end(); ii != ei; ++ii) {
    Graph::GraphNode src = *ii;
    for (Graph::edge_iterator jj = g.edge_begin(src), ej = g.edge_end(src);
         jj != ej; ++jj) {
      Graph::GraphNode dst = g.getEdgeDst(jj);
    }
  }
  And in C++11:
  
  Graph g;
  int sum = 0;
  
  for (Graph::GraphNode src : g) {
    for (Graph::edge_iterator edge : g.out_edges(src)) {
      Graph::GraphNode dst = g.getEdgeDst(edge);
      int edgeData         = g.getEdgeData(edge);
    }
  }
  - Template Parameters
 - 
  
    | NodeTy | data on nodes  | 
    | EdgeTy | data on out edges[doxygennuma]  | 
  
   
- Examples: 
 - lonestar/tutorial_examples/GraphTraversalPullOperator.cpp, lonestar/tutorial_examples/GraphTraversalPushOperator.cpp, and lonestar/tutorial_examples/GraphTraversalSerial.cpp.