{-# LANGUAGE TypeFamilies, PatternGuards, RankNTypes #-}
-- | This internal module implements code shared between all of the
-- adapter interfaces.  The adapters add support for vertex and edge
-- labels without modifications to the underlying graph.  Any graph
-- implementing the 'MGraph' interface can have labels added with
-- these adapters.
--
-- Analogous adapters will be added for the pure graph interface, too.
module Data.Graph.Haggle.Internal.Adapter (
  -- * Types
  LabeledMGraph(..),
  LabeledGraph(..),
  -- * Mutable graph API
  newLabeledGraph,
  newSizedLabeledGraph,
  -- * Immutable graph API
  mapVertexLabel,
  mapEdgeLabel,
  fromLabeledEdgeList,
  -- * Helpers
  ensureEdgeLabelStorage,
  ensureNodeLabelStorage,
  unsafeGetEdgeLabel
  ) where

import qualified Control.DeepSeq as DS
import Control.Monad ( liftM )
import qualified Control.Monad.Primitive as P
import qualified Control.Monad.Ref as R
import Control.Monad.ST ( ST, runST )
import Data.Vector ( Vector )
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as MV
import qualified Data.Graph.Haggle.Classes as I
import qualified Data.Graph.Haggle.VertexMap as VM
import qualified Data.Graph.Haggle.Internal.Basic as I

-- | An adapter adding support for both vertex and edge labels for mutable
-- graphs.
data LabeledMGraph g nl el m =
  LMG { forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph :: g m
      , forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) nl)
nodeLabelStorage :: R.Ref m (MV.MVector (P.PrimState m) nl)
      , forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) el)
edgeLabelStorage :: R.Ref m (MV.MVector (P.PrimState m) el)
      }

-- | An adapter adding support for both vertex and edge labels for immutable
-- graphs.
data LabeledGraph g nl el =
  LG { forall g nl el. LabeledGraph g nl el -> g
rawGraph :: g
     , forall g nl el. LabeledGraph g nl el -> Vector nl
nodeLabelStore :: Vector nl
     , forall g nl el. LabeledGraph g nl el -> Vector el
edgeLabelStore :: Vector el
     }

instance (DS.NFData g, DS.NFData nl, DS.NFData el) => DS.NFData (LabeledGraph g nl el) where
  rnf :: LabeledGraph g nl el -> ()
rnf LabeledGraph g nl el
gr = forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
gr forall a b. NFData a => a -> b -> b
`DS.deepseq` forall g nl el. LabeledGraph g nl el -> Vector nl
nodeLabelStore LabeledGraph g nl el
gr forall a b. NFData a => a -> b -> b
`DS.deepseq` forall g nl el. LabeledGraph g nl el -> Vector el
edgeLabelStore LabeledGraph g nl el
gr forall a b. NFData a => a -> b -> b
`DS.deepseq` ()

newLabeledGraph :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                => m (g m)
                -> m (LabeledMGraph g nl el m)
newLabeledGraph :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
m (g m) -> m (LabeledMGraph g nl el m)
newLabeledGraph m (g m)
newG = do
  g m
g <- m (g m)
newG
  MVector (PrimState m) nl
nstore <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> m (MVector (PrimState m) a)
MV.new Int
128
  Ref m (MVector (PrimState m) nl)
nref <- forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
R.newRef MVector (PrimState m) nl
nstore
  MVector (PrimState m) el
estore <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> m (MVector (PrimState m) a)
MV.new Int
128
  Ref m (MVector (PrimState m) el)
eref <- forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
R.newRef MVector (PrimState m) el
estore
  forall (m :: * -> *) a. Monad m => a -> m a
return LMG { rawMGraph :: g m
rawMGraph = g m
g
             , nodeLabelStorage :: Ref m (MVector (PrimState m) nl)
nodeLabelStorage = Ref m (MVector (PrimState m) nl)
nref
             , edgeLabelStorage :: Ref m (MVector (PrimState m) el)
edgeLabelStorage = Ref m (MVector (PrimState m) el)
eref
             }

newSizedLabeledGraph :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                     => (Int -> Int -> m (g m))
                     -> Int
                     -> Int
                     -> m (LabeledMGraph g nl el m)
newSizedLabeledGraph :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
(Int -> Int -> m (g m))
-> Int -> Int -> m (LabeledMGraph g nl el m)
newSizedLabeledGraph Int -> Int -> m (g m)
newG Int
szVertices Int
szEdges = do
  g m
g <- Int -> Int -> m (g m)
newG Int
szVertices Int
szEdges
  MVector (PrimState m) nl
nstore <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> m (MVector (PrimState m) a)
MV.new Int
szVertices
  Ref m (MVector (PrimState m) nl)
nref <- forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
R.newRef MVector (PrimState m) nl
nstore
  MVector (PrimState m) el
estore <- forall (m :: * -> *) a.
PrimMonad m =>
Int -> m (MVector (PrimState m) a)
MV.new Int
szEdges
  Ref m (MVector (PrimState m) el)
eref <- forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
R.newRef MVector (PrimState m) el
estore
  forall (m :: * -> *) a. Monad m => a -> m a
return LMG { rawMGraph :: g m
rawMGraph = g m
g
             , nodeLabelStorage :: Ref m (MVector (PrimState m) nl)
nodeLabelStorage = Ref m (MVector (PrimState m) nl)
nref
             , edgeLabelStorage :: Ref m (MVector (PrimState m) el)
edgeLabelStorage = Ref m (MVector (PrimState m) el)
eref
             }

addLabeledVertex :: (I.MGraph g, I.MAddVertex g, P.PrimMonad m, R.MonadRef m)
                 => LabeledMGraph g nl el m
                 -> nl
                 -> m I.Vertex
addLabeledVertex :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> nl -> m Vertex
addLabeledVertex LabeledMGraph g nl el m
lg nl
nl = do
  Vertex
v <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MAddVertex g, PrimMonad m, MonadRef m) =>
g m -> m Vertex
I.addVertex (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m ()
ensureNodeLabelStorage LabeledMGraph g nl el m
lg
  MVector (PrimState m) nl
nlVec <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) nl)
nodeLabelStorage LabeledMGraph g nl el m
lg)
  forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> a -> m ()
MV.write MVector (PrimState m) nl
nlVec (Vertex -> Int
I.vertexId Vertex
v) nl
nl
  forall (m :: * -> *) a. Monad m => a -> m a
return Vertex
v
--
-- getEdgeLabel :: (PrimMonad m, I.MGraph g)
--              => LabeledMGraph g nl el m
--              -> I.Edge
--              -> m (Maybe el)
-- getEdgeLabel lg e = do
--   nEs <- I.countEdges (rawMGraph lg)
--   case I.edgeId e >= nEs of
--     True -> return Nothing
--     False -> do
--       elVec <- readSTRef (edgeLabelStorage lg)
--       Just `liftM` MV.read elVec (I.edgeId e)

-- FIXME: Just implement this one and push the safe version to have the default
-- impl
unsafeGetEdgeLabel :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                   => LabeledMGraph g nl el m
                   -> I.Edge
                   -> m el
unsafeGetEdgeLabel :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Edge -> m el
unsafeGetEdgeLabel (LMG g m
_ Ref m (MVector (PrimState m) nl)
_ Ref m (MVector (PrimState m) el)
stor) (I.E Int
eid Int
_ Int
_) = do
  MVector (PrimState m) el
elVec <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef Ref m (MVector (PrimState m) el)
stor
  forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> m a
MV.unsafeRead MVector (PrimState m) el
elVec Int
eid
{-# INLINE unsafeGetEdgeLabel #-}

getVertexLabel :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
               => LabeledMGraph g nl el m
               -> I.Vertex
               -> m (Maybe nl)
getVertexLabel :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m (Maybe nl)
getVertexLabel LabeledMGraph g nl el m
lg Vertex
v = do
  Int
nNs <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countVertices (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  case Vertex -> Int
I.vertexId Vertex
v forall a. Ord a => a -> a -> Bool
>= Int
nNs of
    Bool
True -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
    Bool
False -> do
      MVector (PrimState m) nl
nlVec <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) nl)
nodeLabelStorage LabeledMGraph g nl el m
lg)
      forall a. a -> Maybe a
Just forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> m a
MV.read MVector (PrimState m) nl
nlVec (Vertex -> Int
I.vertexId Vertex
v)

addLabeledEdge :: (I.MGraph g, I.MAddEdge g, P.PrimMonad m, R.MonadRef m)
               => LabeledMGraph g nl el m
               -> I.Vertex
               -> I.Vertex
               -> el
               -> m (Maybe I.Edge)
addLabeledEdge :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> Vertex -> el -> m (Maybe Edge)
addLabeledEdge LabeledMGraph g nl el m
lg Vertex
src Vertex
dst el
el = do
  Maybe Edge
e <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MAddEdge g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> Vertex -> m (Maybe Edge)
I.addEdge (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg) Vertex
src Vertex
dst
  case Maybe Edge
e of
    Maybe Edge
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Edge
e
    Just Edge
e' -> do
      forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m ()
ensureEdgeLabelStorage LabeledMGraph g nl el m
lg
      MVector (PrimState m) el
elVec <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) el)
edgeLabelStorage LabeledMGraph g nl el m
lg)
      forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> a -> m ()
MV.write MVector (PrimState m) el
elVec (Edge -> Int
I.edgeId Edge
e') el
el
      forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Edge
e

getSuccessors :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
              => LabeledMGraph g nl el m
              -> I.Vertex
              -> m [I.Vertex]
getSuccessors :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Vertex]
getSuccessors LabeledMGraph g nl el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Vertex]
I.getSuccessors (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
{-# INLINE getSuccessors #-}

getOutEdges :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
            => LabeledMGraph g nl el m -> I.Vertex -> m [I.Edge]
getOutEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Edge]
getOutEdges LabeledMGraph g nl el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Edge]
I.getOutEdges (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
{-# INLINE getOutEdges #-}

countVertices :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => LabeledMGraph g nl el m -> m Int
countVertices :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m Int
countVertices = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countVertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph
{-# INLINE countVertices #-}

countEdges :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => LabeledMGraph g nl el m -> m Int
countEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m Int
countEdges = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countEdges forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph
{-# INLINE countEdges #-}

getVertices :: (I.MGraph g, P.PrimMonad m, R.MonadRef m) => LabeledMGraph g nl el m -> m [I.Vertex]
getVertices :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m [Vertex]
getVertices = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m [Vertex]
I.getVertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph
{-# INLINE getVertices #-}

getPredecessors :: (I.MBidirectional g, P.PrimMonad m, R.MonadRef m)
                => LabeledMGraph g nl el m -> I.Vertex -> m [I.Vertex]
getPredecessors :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Vertex]
getPredecessors LabeledMGraph g nl el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MBidirectional g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Vertex]
I.getPredecessors (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
{-# INLINE getPredecessors #-}

getInEdges :: (I.MBidirectional g, P.PrimMonad m, R.MonadRef m)
           => LabeledMGraph g nl el m -> I.Vertex -> m [I.Edge]
getInEdges :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Edge]
getInEdges LabeledMGraph g nl el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MBidirectional g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> m [Edge]
I.getInEdges (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
{-# INLINE getInEdges #-}

checkEdgeExists :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                => LabeledMGraph g nl el m
                -> I.Vertex
                -> I.Vertex
                -> m Bool
checkEdgeExists :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> Vertex -> m Bool
checkEdgeExists LabeledMGraph g nl el m
lg = forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> Vertex -> Vertex -> m Bool
I.checkEdgeExists (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
{-# INLINE checkEdgeExists #-}

freeze :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
       => LabeledMGraph g nl el m
       -> m (LabeledGraph (I.ImmutableGraph g) nl el)
freeze :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> m (LabeledGraph (ImmutableGraph g) nl el)
freeze LabeledMGraph g nl el m
lg = do
  ImmutableGraph g
g' <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m (ImmutableGraph g)
I.freeze (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  Int
nc <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countVertices (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  Int
ec <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countEdges (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  MVector (PrimState m) nl
ns <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) nl)
nodeLabelStorage LabeledMGraph g nl el m
lg)
  MVector (PrimState m) el
es <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) el)
edgeLabelStorage LabeledMGraph g nl el m
lg)
  Vector nl
ns' <- forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> m (Vector a)
V.freeze (forall s a. Int -> MVector s a -> MVector s a
MV.take Int
nc MVector (PrimState m) nl
ns)
  Vector el
es' <- forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> m (Vector a)
V.freeze (forall s a. Int -> MVector s a -> MVector s a
MV.take Int
ec MVector (PrimState m) el
es)
  forall (m :: * -> *) a. Monad m => a -> m a
return LG { rawGraph :: ImmutableGraph g
rawGraph = ImmutableGraph g
g'
            , nodeLabelStore :: Vector nl
nodeLabelStore = Vector nl
ns'
            , edgeLabelStore :: Vector el
edgeLabelStore = Vector el
es'
            }

instance (I.MGraph g) => I.MGraph (LabeledMGraph g nl el) where
  type ImmutableGraph (LabeledMGraph g nl el) = LabeledGraph (I.ImmutableGraph g) nl el
  getVertices :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m [Vertex]
getVertices = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m [Vertex]
getVertices
  getSuccessors :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Vertex]
getSuccessors = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Vertex]
getSuccessors
  getOutEdges :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Edge]
getOutEdges = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Edge]
getOutEdges
  countEdges :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m Int
countEdges = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m Int
countEdges
  countVertices :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m Int
countVertices = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m Int
countVertices
  checkEdgeExists :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> Vertex -> m Bool
checkEdgeExists = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> Vertex -> m Bool
checkEdgeExists
  freeze :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> m (ImmutableGraph (LabeledMGraph g nl el))
freeze = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> m (LabeledGraph (ImmutableGraph g) nl el)
freeze

instance (I.MBidirectional g) => I.MBidirectional (LabeledMGraph g nl el) where
  getPredecessors :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Vertex]
getPredecessors = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Vertex]
getPredecessors
  getInEdges :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Edge]
getInEdges = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MBidirectional g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m [Edge]
getInEdges

instance (I.MAddEdge g) => I.MLabeledEdge (LabeledMGraph g nl el) where
  type MEdgeLabel (LabeledMGraph g nl el) = el
  -- getEdgeLabel = getEdgeLabel
  unsafeGetEdgeLabel :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> Edge -> m (MEdgeLabel (LabeledMGraph g nl el))
unsafeGetEdgeLabel = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Edge -> m el
unsafeGetEdgeLabel
  addLabeledEdge :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> Vertex
-> Vertex
-> MEdgeLabel (LabeledMGraph g nl el)
-> m (Maybe Edge)
addLabeledEdge = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> Vertex -> el -> m (Maybe Edge)
addLabeledEdge

instance (I.MAddVertex g) => I.MLabeledVertex (LabeledMGraph g nl el) where
  type MVertexLabel (LabeledMGraph g nl el) = nl
  getVertexLabel :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> Vertex -> m (Maybe (MVertexLabel (LabeledMGraph g nl el)))
getVertexLabel = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> m (Maybe nl)
getVertexLabel
  addLabeledVertex :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> MVertexLabel (LabeledMGraph g nl el) -> m Vertex
addLabeledVertex = forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, MAddVertex g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> nl -> m Vertex
addLabeledVertex

vertices :: (I.Graph g) => LabeledGraph g nl el -> [I.Vertex]
vertices :: forall g nl el. Graph g => LabeledGraph g nl el -> [Vertex]
vertices = forall g. Graph g => g -> [Vertex]
I.vertices forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl el. LabeledGraph g nl el -> g
rawGraph
{-# INLINE vertices #-}

edges :: (I.Graph g) => LabeledGraph g nl el -> [I.Edge]
edges :: forall g nl el. Graph g => LabeledGraph g nl el -> [Edge]
edges = forall g. Graph g => g -> [Edge]
I.edges forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl el. LabeledGraph g nl el -> g
rawGraph
{-# INLINE edges #-}

successors :: (I.Graph g) => LabeledGraph g nl el -> I.Vertex -> [I.Vertex]
successors :: forall g nl el.
Graph g =>
LabeledGraph g nl el -> Vertex -> [Vertex]
successors LabeledGraph g nl el
lg = forall g. Graph g => g -> Vertex -> [Vertex]
I.successors (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
lg)
{-# INLINE successors #-}

outEdges :: (I.Graph g) => LabeledGraph g nl el -> I.Vertex -> [I.Edge]
outEdges :: forall g nl el. Graph g => LabeledGraph g nl el -> Vertex -> [Edge]
outEdges LabeledGraph g nl el
lg = forall g. Graph g => g -> Vertex -> [Edge]
I.outEdges (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
lg)
{-# INLINE outEdges #-}

edgesBetween :: (I.Graph g) => LabeledGraph g nl el -> I.Vertex -> I.Vertex -> [I.Edge]
edgesBetween :: forall g nl el.
Graph g =>
LabeledGraph g nl el -> Vertex -> Vertex -> [Edge]
edgesBetween LabeledGraph g nl el
lg = forall g. Graph g => g -> Vertex -> Vertex -> [Edge]
I.edgesBetween (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
lg)
{-# INLINE edgesBetween #-}

maxVertexId :: (I.Graph g) => LabeledGraph g nl el -> Int
maxVertexId :: forall g nl el. Graph g => LabeledGraph g nl el -> Int
maxVertexId = forall g. Graph g => g -> Int
I.maxVertexId forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl el. LabeledGraph g nl el -> g
rawGraph
{-# INLINE maxVertexId #-}

isEmpty :: (I.Graph g) => LabeledGraph g nl el -> Bool
isEmpty :: forall g nl el. Graph g => LabeledGraph g nl el -> Bool
isEmpty = forall g. Graph g => g -> Bool
I.isEmpty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall g nl el. LabeledGraph g nl el -> g
rawGraph
{-# INLINE isEmpty #-}

thaw :: (I.Thawable g, P.PrimMonad m, R.MonadRef m)
     => LabeledGraph g nl el
     -> m (LabeledMGraph (I.MutableGraph g) nl el m)
thaw :: forall g (m :: * -> *) nl el.
(Thawable g, PrimMonad m, MonadRef m) =>
LabeledGraph g nl el -> m (LabeledMGraph (MutableGraph g) nl el m)
thaw LabeledGraph g nl el
lg = do
  MutableGraph g m
g' <- forall g (m :: * -> *).
(Thawable g, PrimMonad m, MonadRef m) =>
g -> m (MutableGraph g m)
I.thaw (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
lg)
  MVector (PrimState m) nl
nlVec <- forall (m :: * -> *) a.
PrimMonad m =>
Vector a -> m (MVector (PrimState m) a)
V.thaw (forall g nl el. LabeledGraph g nl el -> Vector nl
nodeLabelStore LabeledGraph g nl el
lg)
  MVector (PrimState m) el
elVec <- forall (m :: * -> *) a.
PrimMonad m =>
Vector a -> m (MVector (PrimState m) a)
V.thaw (forall g nl el. LabeledGraph g nl el -> Vector el
edgeLabelStore LabeledGraph g nl el
lg)
  Ref m (MVector (PrimState m) nl)
nref <- forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
R.newRef MVector (PrimState m) nl
nlVec
  Ref m (MVector (PrimState m) el)
eref <- forall (m :: * -> *) a. MonadRef m => a -> m (Ref m a)
R.newRef MVector (PrimState m) el
elVec
  forall (m :: * -> *) a. Monad m => a -> m a
return LMG { rawMGraph :: MutableGraph g m
rawMGraph = MutableGraph g m
g'
             , nodeLabelStorage :: Ref m (MVector (PrimState m) nl)
nodeLabelStorage = Ref m (MVector (PrimState m) nl)
nref
             , edgeLabelStorage :: Ref m (MVector (PrimState m) el)
edgeLabelStorage = Ref m (MVector (PrimState m) el)
eref
             }

instance (I.Thawable g) => I.Thawable (LabeledGraph g nl el) where
  type MutableGraph (LabeledGraph g nl el) = LabeledMGraph (I.MutableGraph g) nl el
  thaw :: forall (m :: * -> *).
(PrimMonad m, MonadRef m) =>
LabeledGraph g nl el -> m (MutableGraph (LabeledGraph g nl el) m)
thaw = forall g (m :: * -> *) nl el.
(Thawable g, PrimMonad m, MonadRef m) =>
LabeledGraph g nl el -> m (LabeledMGraph (MutableGraph g) nl el m)
thaw

instance (I.Graph g) => I.Graph (LabeledGraph g nl el) where
  vertices :: LabeledGraph g nl el -> [Vertex]
vertices = forall g nl el. Graph g => LabeledGraph g nl el -> [Vertex]
vertices
  edges :: LabeledGraph g nl el -> [Edge]
edges = forall g nl el. Graph g => LabeledGraph g nl el -> [Edge]
edges
  successors :: LabeledGraph g nl el -> Vertex -> [Vertex]
successors = forall g nl el.
Graph g =>
LabeledGraph g nl el -> Vertex -> [Vertex]
successors
  outEdges :: LabeledGraph g nl el -> Vertex -> [Edge]
outEdges = forall g nl el. Graph g => LabeledGraph g nl el -> Vertex -> [Edge]
outEdges
  edgesBetween :: LabeledGraph g nl el -> Vertex -> Vertex -> [Edge]
edgesBetween = forall g nl el.
Graph g =>
LabeledGraph g nl el -> Vertex -> Vertex -> [Edge]
edgesBetween
  maxVertexId :: LabeledGraph g nl el -> Int
maxVertexId = forall g nl el. Graph g => LabeledGraph g nl el -> Int
maxVertexId
  isEmpty :: LabeledGraph g nl el -> Bool
isEmpty = forall g nl el. Graph g => LabeledGraph g nl el -> Bool
isEmpty

predecessors :: (I.Bidirectional g) => LabeledGraph g nl el -> I.Vertex -> [I.Vertex]
predecessors :: forall g nl el.
Bidirectional g =>
LabeledGraph g nl el -> Vertex -> [Vertex]
predecessors LabeledGraph g nl el
lg = forall g. Bidirectional g => g -> Vertex -> [Vertex]
I.predecessors (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
lg)
{-# INLINE predecessors #-}

inEdges :: (I.Bidirectional g) => LabeledGraph g nl el -> I.Vertex -> [I.Edge]
inEdges :: forall g nl el.
Bidirectional g =>
LabeledGraph g nl el -> Vertex -> [Edge]
inEdges LabeledGraph g nl el
lg = forall g. Bidirectional g => g -> Vertex -> [Edge]
I.inEdges (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
lg)
{-# INLINE inEdges #-}

instance (I.Bidirectional g) => I.Bidirectional (LabeledGraph g nl el) where
  predecessors :: LabeledGraph g nl el -> Vertex -> [Vertex]
predecessors = forall g nl el.
Bidirectional g =>
LabeledGraph g nl el -> Vertex -> [Vertex]
predecessors
  inEdges :: LabeledGraph g nl el -> Vertex -> [Edge]
inEdges = forall g nl el.
Bidirectional g =>
LabeledGraph g nl el -> Vertex -> [Edge]
inEdges

instance (I.Bidirectional g) => I.BidirectionalEdgeLabel (LabeledGraph g nl el)

edgeLabel :: LabeledGraph g nl el -> I.Edge -> Maybe el
edgeLabel :: forall g nl el. LabeledGraph g nl el -> Edge -> Maybe el
edgeLabel LabeledGraph g nl el
lg Edge
e = forall g nl el. LabeledGraph g nl el -> Vector el
edgeLabelStore LabeledGraph g nl el
lg forall a. Vector a -> Int -> Maybe a
V.!? Edge -> Int
I.edgeId Edge
e
{-# INLINE edgeLabel #-}

instance (I.Graph g) => I.HasEdgeLabel (LabeledGraph g nl el) where
  type EdgeLabel (LabeledGraph g nl el) = el
  edgeLabel :: LabeledGraph g nl el
-> Edge -> Maybe (EdgeLabel (LabeledGraph g nl el))
edgeLabel = forall g nl el. LabeledGraph g nl el -> Edge -> Maybe el
edgeLabel
  labeledEdges :: LabeledGraph g nl el -> [(Edge, EdgeLabel (LabeledGraph g nl el))]
labeledEdges = forall g nl el. Graph g => LabeledGraph g nl el -> [(Edge, el)]
labeledEdges

vertexLabel :: LabeledGraph g nl el -> I.Vertex -> Maybe nl
vertexLabel :: forall g nl el. LabeledGraph g nl el -> Vertex -> Maybe nl
vertexLabel LabeledGraph g nl el
lg Vertex
v = forall g nl el. LabeledGraph g nl el -> Vector nl
nodeLabelStore LabeledGraph g nl el
lg forall a. Vector a -> Int -> Maybe a
V.!? Vertex -> Int
I.vertexId Vertex
v
{-# INLINE vertexLabel #-}

instance (I.Graph g) => I.HasVertexLabel (LabeledGraph g nl el) where
  type VertexLabel (LabeledGraph g nl el) = nl
  vertexLabel :: LabeledGraph g nl el
-> Vertex -> Maybe (VertexLabel (LabeledGraph g nl el))
vertexLabel = forall g nl el. LabeledGraph g nl el -> Vertex -> Maybe nl
vertexLabel
  labeledVertices :: LabeledGraph g nl el
-> [(Vertex, VertexLabel (LabeledGraph g nl el))]
labeledVertices = forall g nl el. Graph g => LabeledGraph g nl el -> [(Vertex, nl)]
labeledVertices

-- | Note that we are not just using the @nodeLabelStore@ directly.  In
-- graphs that support vertex removal, we do not want to include removed
-- vertices, so we go through the public accessor.  This is slower but easier
-- to see as correct.
labeledVertices :: (I.Graph g) => LabeledGraph g nl el -> [(I.Vertex, nl)]
labeledVertices :: forall g nl el. Graph g => LabeledGraph g nl el -> [(Vertex, nl)]
labeledVertices LabeledGraph g nl el
g = forall a b. (a -> b) -> [a] -> [b]
map Vertex -> (Vertex, nl)
toLabVert forall a b. (a -> b) -> a -> b
$ forall g. Graph g => g -> [Vertex]
I.vertices (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
g)
  where
    toLabVert :: Vertex -> (Vertex, nl)
toLabVert Vertex
v =
      let Just nl
lab = forall g nl el. LabeledGraph g nl el -> Vertex -> Maybe nl
vertexLabel LabeledGraph g nl el
g Vertex
v
      in (Vertex
v, nl
lab)

-- | Likewise, we use 'edges' here instead of directly reading from the edge
-- label storage array.
labeledEdges :: (I.Graph g) => LabeledGraph g nl el -> [(I.Edge, el)]
labeledEdges :: forall g nl el. Graph g => LabeledGraph g nl el -> [(Edge, el)]
labeledEdges LabeledGraph g nl el
g = forall a b. (a -> b) -> [a] -> [b]
map Edge -> (Edge, el)
toLabEdge forall a b. (a -> b) -> a -> b
$ forall g. Graph g => g -> [Edge]
I.edges (forall g nl el. LabeledGraph g nl el -> g
rawGraph LabeledGraph g nl el
g)
  where
    toLabEdge :: Edge -> (Edge, el)
toLabEdge Edge
e =
      let Just el
lab = forall g nl el. LabeledGraph g nl el -> Edge -> Maybe el
edgeLabel LabeledGraph g nl el
g Edge
e
      in (Edge
e, el
lab)

mapEdgeLabel :: LabeledGraph g nl el -> (el -> el') -> LabeledGraph g nl el'
mapEdgeLabel :: forall g nl el el'.
LabeledGraph g nl el -> (el -> el') -> LabeledGraph g nl el'
mapEdgeLabel LabeledGraph g nl el
g el -> el'
f = LabeledGraph g nl el
g { edgeLabelStore :: Vector el'
edgeLabelStore = forall a b. (a -> b) -> Vector a -> Vector b
V.map el -> el'
f (forall g nl el. LabeledGraph g nl el -> Vector el
edgeLabelStore LabeledGraph g nl el
g) }

mapVertexLabel :: LabeledGraph g nl el -> (nl -> nl') -> LabeledGraph g nl' el
mapVertexLabel :: forall g nl el nl'.
LabeledGraph g nl el -> (nl -> nl') -> LabeledGraph g nl' el
mapVertexLabel LabeledGraph g nl el
g nl -> nl'
f = LabeledGraph g nl el
g { nodeLabelStore :: Vector nl'
nodeLabelStore = forall a b. (a -> b) -> Vector a -> Vector b
V.map nl -> nl'
f (forall g nl el. LabeledGraph g nl el -> Vector nl
nodeLabelStore LabeledGraph g nl el
g) }

-- | Construct a graph from a labeled list of edges.  The node endpoint values
-- are used as vertex labels, and the last element of the triple is used as an
-- edge label.
fromLabeledEdgeList :: (Ord nl, I.MGraph g, I.MAddVertex g, I.MAddEdge g)
                    => (forall s . ST s (g (ST s)))
                    -> [(nl, nl, el)]
                    -> (LabeledGraph (I.ImmutableGraph g) nl el, VM.VertexMap nl)
fromLabeledEdgeList :: forall nl (g :: (* -> *) -> *) el.
(Ord nl, MGraph g, MAddVertex g, MAddEdge g) =>
(forall s. ST s (g (ST s)))
-> [(nl, nl, el)]
-> (LabeledGraph (ImmutableGraph g) nl el, VertexMap nl)
fromLabeledEdgeList forall s. ST s (g (ST s))
con [(nl, nl, el)]
es = forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
  LabeledMGraph g nl el (ST s)
g <- forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
m (g m) -> m (LabeledMGraph g nl el m)
newLabeledGraph forall s. ST s (g (ST s))
con
  VertexMapRef nl (ST s)
vm <- forall (m :: * -> *) nl.
(PrimMonad m, MonadRef m) =>
m (VertexMapRef nl m)
VM.newVertexMapRef
  forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall (g :: (* -> *) -> *) nl (m :: * -> *) el.
(MAddVertex g, MAddEdge g, Ord nl, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> VertexMapRef nl m -> (nl, nl, el) -> m ()
fromListAddEdge LabeledMGraph g nl el (ST s)
g VertexMapRef nl (ST s)
vm) [(nl, nl, el)]
es
  LabeledGraph (ImmutableGraph g) nl el
g' <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m (ImmutableGraph g)
I.freeze LabeledMGraph g nl el (ST s)
g
  VertexMap nl
vm' <- forall (m :: * -> *) nl.
(PrimMonad m, MonadRef m) =>
VertexMapRef nl m -> m (VertexMap nl)
VM.vertexMapFromRef VertexMapRef nl (ST s)
vm
  forall (m :: * -> *) a. Monad m => a -> m a
return (LabeledGraph (ImmutableGraph g) nl el
g', VertexMap nl
vm')

fromListAddEdge :: (I.MAddVertex g, I.MAddEdge g, Ord nl, P.PrimMonad m, R.MonadRef m)
                => LabeledMGraph g nl el m
                -> VM.VertexMapRef nl m
                -> (nl, nl, el)
                -> m ()
fromListAddEdge :: forall (g :: (* -> *) -> *) nl (m :: * -> *) el.
(MAddVertex g, MAddEdge g, Ord nl, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m
-> VertexMapRef nl m -> (nl, nl, el) -> m ()
fromListAddEdge LabeledMGraph g nl el m
g VertexMapRef nl m
vm (nl
src, nl
dst, el
lbl) = do
  Vertex
vsrc <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledVertex g, Ord (MVertexLabel g), PrimMonad m,
 MonadRef m) =>
g m
-> VertexMapRef (MVertexLabel g) m -> MVertexLabel g -> m Vertex
VM.vertexForLabelRef LabeledMGraph g nl el m
g VertexMapRef nl m
vm nl
src
  Vertex
vdst <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MLabeledVertex g, Ord (MVertexLabel g), PrimMonad m,
 MonadRef m) =>
g m
-> VertexMapRef (MVertexLabel g) m -> MVertexLabel g -> m Vertex
VM.vertexForLabelRef LabeledMGraph g nl el m
g VertexMapRef nl m
vm nl
dst
  Maybe Edge
_ <- forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, MAddEdge g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> Vertex -> Vertex -> el -> m (Maybe Edge)
addLabeledEdge LabeledMGraph g nl el m
g Vertex
vsrc Vertex
vdst el
lbl
  forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- Helpers

ensureEdgeLabelStorage :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                       => LabeledMGraph g nl el m -> m ()
ensureEdgeLabelStorage :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m ()
ensureEdgeLabelStorage LabeledMGraph g nl el m
lg = do
  MVector (PrimState m) el
elVec <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) el)
edgeLabelStorage LabeledMGraph g nl el m
lg)
  Int
edgeCount <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countEdges (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  let cap :: Int
cap = forall s a. MVector s a -> Int
MV.length MVector (PrimState m) el
elVec
  case Int
cap forall a. Ord a => a -> a -> Bool
> Int
edgeCount of
    Bool
True -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Bool
False -> do
      MVector (PrimState m) el
elVec' <- forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
MV.grow MVector (PrimState m) el
elVec Int
cap
      forall (m :: * -> *) a. MonadRef m => Ref m a -> a -> m ()
R.writeRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) el)
edgeLabelStorage LabeledMGraph g nl el m
lg) MVector (PrimState m) el
elVec'

ensureNodeLabelStorage :: (I.MGraph g, P.PrimMonad m, R.MonadRef m)
                       => LabeledMGraph g nl el m -> m ()
ensureNodeLabelStorage :: forall (g :: (* -> *) -> *) (m :: * -> *) nl el.
(MGraph g, PrimMonad m, MonadRef m) =>
LabeledMGraph g nl el m -> m ()
ensureNodeLabelStorage LabeledMGraph g nl el m
lg = do
  MVector (PrimState m) nl
nlVec <- forall (m :: * -> *) a. MonadRef m => Ref m a -> m a
R.readRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) nl)
nodeLabelStorage LabeledMGraph g nl el m
lg)
  Int
vertCount <- forall (g :: (* -> *) -> *) (m :: * -> *).
(MGraph g, PrimMonad m, MonadRef m) =>
g m -> m Int
I.countVertices (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> g m
rawMGraph LabeledMGraph g nl el m
lg)
  let cap :: Int
cap = forall s a. MVector s a -> Int
MV.length MVector (PrimState m) nl
nlVec
  case Int
cap forall a. Ord a => a -> a -> Bool
> Int
vertCount of
    Bool
True -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Bool
False -> do
      MVector (PrimState m) nl
nlVec' <- forall (m :: * -> *) a.
PrimMonad m =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
MV.grow MVector (PrimState m) nl
nlVec Int
cap
      forall (m :: * -> *) a. MonadRef m => Ref m a -> a -> m ()
R.writeRef (forall (g :: (* -> *) -> *) nl el (m :: * -> *).
LabeledMGraph g nl el m -> Ref m (MVector (PrimState m) nl)
nodeLabelStorage LabeledMGraph g nl el m
lg) MVector (PrimState m) nl
nlVec'