{-# LANGUAGE DeriveTraversable          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings          #-}
-- |
-- Module: Data.Greskell.Graph.PropertyMap
-- Description: [Deprecated] PropertyMap class and types
-- Maintainer: Toshio Ito <debug.ito@gmail.com>
--
-- 'PropertyMap' was used in greskell prior than 1.0.0.0, but is now
-- deprecated. Use "Data.Greskell.PMap" instead.
module Data.Greskell.Graph.PropertyMap
    ( -- ** PropertyMap
      PropertyMap (..)
    , PropertyMapSingle
    , PropertyMapList
    , lookupOneValue
    , lookupListValues
    , parseOneValue
    , parseListValues
    , parseNonEmptyValues
    , fromProperties
      -- * Internal use
    , FromGraphSONWithKey
      -- * Re-exports
    , AProperty (..)
    , AVertexProperty (..)
    ) where

import           Control.Applicative           (empty, (<|>))
import           Data.Aeson                    (FromJSON (..))
import qualified Data.Aeson.Key                as Key
import qualified Data.Aeson.KeyMap             as KM
import           Data.Aeson.Types              (Parser)
import           Data.Foldable                 (Foldable (..), foldlM)
import           Data.Greskell.GraphSON        (FromGraphSON (..), GValue, GraphSONTyped (..),
                                                parseJSONViaGValue, (.:))
import           Data.Greskell.GraphSON.GValue (GValueBody (..), gValueBody, gValueType)
import qualified Data.HashMap.Strict           as HM
import           Data.List.NonEmpty            (NonEmpty (..))
import qualified Data.List.NonEmpty            as NL
import           Data.Maybe                    (listToMaybe)
import           Data.Monoid                   (Monoid (..))
import           Data.Semigroup                (Semigroup ((<>)))
import qualified Data.Semigroup                as Semigroup
import           Data.Text                     (Text, unpack)
import           Data.Traversable              (Traversable (..))
import           Data.Vector                   (Vector)

import           Data.Greskell.Graph           (AProperty (..), AVertexProperty (..), Property (..))


{-# DEPRECATED PropertyMap "PropertyMap and its instances are deprecated. Use PMap instead." #-}

-- | Common basic operations supported by maps of properties.
class PropertyMap m where
  lookupOne :: Text -> m p v -> Maybe (p v)
  -- ^ Look up a property associated with the given key.
  lookupOne Text
k m p v
m = [p v] -> Maybe (p v)
forall a. [a] -> Maybe a
listToMaybe ([p v] -> Maybe (p v)) -> [p v] -> Maybe (p v)
forall a b. (a -> b) -> a -> b
$ Text -> m p v -> [p v]
forall (p :: * -> *) v. Text -> m p v -> [p v]
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
PropertyMap m =>
Text -> m p v -> [p v]
lookupList Text
k m p v
m
  lookupList :: Text -> m p v -> [p v]
  -- ^ Look up all properties associated with the given key.
  putProperty :: Property p => p v -> m p v -> m p v
  -- ^ Put a property into the map.
  removeProperty :: Text -> m p v -> m p v
  -- ^ Remove all properties associated with the given key.
  allProperties :: m p v -> [p v]
  -- ^ Return all properties in the map.

-- | Lookup a property value from a 'PropertyMap' by key.
lookupOneValue :: (PropertyMap m, Property p) => Text -> m p v -> Maybe v
lookupOneValue :: forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p) =>
Text -> m p v -> Maybe v
lookupOneValue Text
k = (p v -> v) -> Maybe (p v) -> Maybe v
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap p v -> v
forall v. p v -> v
forall (p :: * -> *) v. Property p => p v -> v
propertyValue (Maybe (p v) -> Maybe v)
-> (m p v -> Maybe (p v)) -> m p v -> Maybe v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> m p v -> Maybe (p v)
forall (p :: * -> *) v. Text -> m p v -> Maybe (p v)
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
PropertyMap m =>
Text -> m p v -> Maybe (p v)
lookupOne Text
k

-- | Lookup a list of property values from a 'PropertyMap' by key.
lookupListValues :: (PropertyMap m, Property p) => Text -> m p v -> [v]
lookupListValues :: forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p) =>
Text -> m p v -> [v]
lookupListValues Text
k = (p v -> v) -> [p v] -> [v]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap p v -> v
forall v. p v -> v
forall (p :: * -> *) v. Property p => p v -> v
propertyValue ([p v] -> [v]) -> (m p v -> [p v]) -> m p v -> [v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> m p v -> [p v]
forall (p :: * -> *) v. Text -> m p v -> [p v]
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
PropertyMap m =>
Text -> m p v -> [p v]
lookupList Text
k

notExistErrorMsg :: Text -> String
notExistErrorMsg :: Text -> [Char]
notExistErrorMsg Text
k = [Char]
"Property '" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
k [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"' does not exist."

-- | Lookup a property 'GValue' by the given key, and parse it.
--
-- In version 0.1.1.0 and before, this function took an argument @m p (GraphSON Value)@.
-- This has changed, because property types for 'AVertex' etc have changed.
parseOneValue :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser v
parseOneValue :: forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p, FromGraphSON v) =>
Text -> m p GValue -> Parser v
parseOneValue Text
k m p GValue
pm = Parser v -> (GValue -> Parser v) -> Maybe GValue -> Parser v
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Parser v
forall a. [Char] -> Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
err_msg) GValue -> Parser v
forall a. FromGraphSON a => GValue -> Parser a
parseGraphSON (Maybe GValue -> Parser v) -> Maybe GValue -> Parser v
forall a b. (a -> b) -> a -> b
$ Text -> m p GValue -> Maybe GValue
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p) =>
Text -> m p v -> Maybe v
lookupOneValue Text
k m p GValue
pm
  where
    err_msg :: [Char]
err_msg = Text -> [Char]
notExistErrorMsg Text
k

-- | Lookup a list of property values from a 'PropertyMap' by the
-- given key, and parse them.
--
-- In version 0.1.1.0 and before, this function took an argument @m p (GraphSON Value)@.
-- This has changed, because property types for 'AVertex' etc have changed.
parseListValues :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser [v]
parseListValues :: forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p, FromGraphSON v) =>
Text -> m p GValue -> Parser [v]
parseListValues Text
k m p GValue
pm = (GValue -> Parser v) -> [GValue] -> Parser [v]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM GValue -> Parser v
forall a. FromGraphSON a => GValue -> Parser a
parseGraphSON ([GValue] -> Parser [v]) -> [GValue] -> Parser [v]
forall a b. (a -> b) -> a -> b
$ Text -> m p GValue -> [GValue]
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p) =>
Text -> m p v -> [v]
lookupListValues Text
k m p GValue
pm

-- | Like 'parseListValues', but this function 'fail's when there is
-- no property with the given key.
--
-- In version 0.1.1.0 and before, this function took an argument @m p (GraphSON Value)@.
-- This has changed, because property types for 'AVertex' etc have changed.
parseNonEmptyValues :: (PropertyMap m, Property p, FromGraphSON v) => Text -> m p GValue -> Parser (NonEmpty v)
parseNonEmptyValues :: forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p, FromGraphSON v) =>
Text -> m p GValue -> Parser (NonEmpty v)
parseNonEmptyValues Text
k m p GValue
pm = [v] -> Parser (NonEmpty v)
forall {m :: * -> *} {a}. MonadFail m => [a] -> m (NonEmpty a)
toNonEmpty ([v] -> Parser (NonEmpty v)) -> Parser [v] -> Parser (NonEmpty v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Text -> m p GValue -> Parser [v]
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p, FromGraphSON v) =>
Text -> m p GValue -> Parser [v]
parseListValues Text
k m p GValue
pm
  where
    toNonEmpty :: [a] -> m (NonEmpty a)
toNonEmpty []         = [Char] -> m (NonEmpty a)
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m (NonEmpty a)) -> [Char] -> m (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ Text -> [Char]
notExistErrorMsg Text
k
    toNonEmpty (a
x : [a]
rest) = NonEmpty a -> m (NonEmpty a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
rest)

-- | Create a 'PropertyMap' from list of 'Property's.
fromProperties :: (PropertyMap m, Property p, Monoid (m p v))
               => [p v]
               -> m p v
fromProperties :: forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p, Monoid (m p v)) =>
[p v] -> m p v
fromProperties = (p v -> m p v -> m p v) -> m p v -> [p v] -> m p v
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr p v -> m p v -> m p v
forall (p :: * -> *) v. Property p => p v -> m p v -> m p v
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p) =>
p v -> m p v -> m p v
putProperty m p v
forall a. Monoid a => a
mempty

-- | Generic implementation of 'PropertyMap'. @t@ is the type of
-- cardinality, @p@ is the type of 'Property' class and @v@ is the
-- type of the property value.
newtype PropertyMapGeneric t p v
  = PropertyMapGeneric (HM.HashMap Text (t (p v)))
  deriving (PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool
(PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool)
-> (PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool)
-> Eq (PropertyMapGeneric t p v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (t :: * -> *) (p :: * -> *) v.
Eq (t (p v)) =>
PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool
$c== :: forall (t :: * -> *) (p :: * -> *) v.
Eq (t (p v)) =>
PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool
== :: PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool
$c/= :: forall (t :: * -> *) (p :: * -> *) v.
Eq (t (p v)) =>
PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool
/= :: PropertyMapGeneric t p v -> PropertyMapGeneric t p v -> Bool
Eq, Int -> PropertyMapGeneric t p v -> [Char] -> [Char]
[PropertyMapGeneric t p v] -> [Char] -> [Char]
PropertyMapGeneric t p v -> [Char]
(Int -> PropertyMapGeneric t p v -> [Char] -> [Char])
-> (PropertyMapGeneric t p v -> [Char])
-> ([PropertyMapGeneric t p v] -> [Char] -> [Char])
-> Show (PropertyMapGeneric t p v)
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
Int -> PropertyMapGeneric t p v -> [Char] -> [Char]
forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
[PropertyMapGeneric t p v] -> [Char] -> [Char]
forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
PropertyMapGeneric t p v -> [Char]
$cshowsPrec :: forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
Int -> PropertyMapGeneric t p v -> [Char] -> [Char]
showsPrec :: Int -> PropertyMapGeneric t p v -> [Char] -> [Char]
$cshow :: forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
PropertyMapGeneric t p v -> [Char]
show :: PropertyMapGeneric t p v -> [Char]
$cshowList :: forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
[PropertyMapGeneric t p v] -> [Char] -> [Char]
showList :: [PropertyMapGeneric t p v] -> [Char] -> [Char]
Show)

instance Semigroup (t (p v)) => Semigroup (PropertyMapGeneric t p v) where
  (PropertyMapGeneric HashMap Text (t (p v))
a) <> :: PropertyMapGeneric t p v
-> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
<> (PropertyMapGeneric HashMap Text (t (p v))
b) = HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall (t :: * -> *) (p :: * -> *) v.
HashMap Text (t (p v)) -> PropertyMapGeneric t p v
PropertyMapGeneric (HashMap Text (t (p v)) -> PropertyMapGeneric t p v)
-> HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall a b. (a -> b) -> a -> b
$ (t (p v) -> t (p v) -> t (p v))
-> HashMap Text (t (p v))
-> HashMap Text (t (p v))
-> HashMap Text (t (p v))
forall k v.
Eq k =>
(v -> v -> v) -> HashMap k v -> HashMap k v -> HashMap k v
HM.unionWith t (p v) -> t (p v) -> t (p v)
forall a. Semigroup a => a -> a -> a
(<>) HashMap Text (t (p v))
a HashMap Text (t (p v))
b

instance Semigroup (t (p v)) => Monoid (PropertyMapGeneric t p v) where
  mempty :: PropertyMapGeneric t p v
mempty = HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall (t :: * -> *) (p :: * -> *) v.
HashMap Text (t (p v)) -> PropertyMapGeneric t p v
PropertyMapGeneric HashMap Text (t (p v))
forall a. Monoid a => a
mempty
  mappend :: PropertyMapGeneric t p v
-> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
mappend = PropertyMapGeneric t p v
-> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
forall a. Semigroup a => a -> a -> a
(<>)

instance (Functor t, Functor p) => Functor (PropertyMapGeneric t p) where
  fmap :: forall a b.
(a -> b) -> PropertyMapGeneric t p a -> PropertyMapGeneric t p b
fmap a -> b
f (PropertyMapGeneric HashMap Text (t (p a))
hm) = HashMap Text (t (p b)) -> PropertyMapGeneric t p b
forall (t :: * -> *) (p :: * -> *) v.
HashMap Text (t (p v)) -> PropertyMapGeneric t p v
PropertyMapGeneric (HashMap Text (t (p b)) -> PropertyMapGeneric t p b)
-> HashMap Text (t (p b)) -> PropertyMapGeneric t p b
forall a b. (a -> b) -> a -> b
$ ((t (p a) -> t (p b))
-> HashMap Text (t (p a)) -> HashMap Text (t (p b))
forall a b. (a -> b) -> HashMap Text a -> HashMap Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((t (p a) -> t (p b))
 -> HashMap Text (t (p a)) -> HashMap Text (t (p b)))
-> ((a -> b) -> t (p a) -> t (p b))
-> (a -> b)
-> HashMap Text (t (p a))
-> HashMap Text (t (p b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (p a -> p b) -> t (p a) -> t (p b)
forall a b. (a -> b) -> t a -> t b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((p a -> p b) -> t (p a) -> t (p b))
-> ((a -> b) -> p a -> p b) -> (a -> b) -> t (p a) -> t (p b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> p a -> p b
forall a b. (a -> b) -> p a -> p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap) a -> b
f HashMap Text (t (p a))
hm

instance (Foldable t, Foldable p) => Foldable (PropertyMapGeneric t p) where
  foldr :: forall a b. (a -> b -> b) -> b -> PropertyMapGeneric t p a -> b
foldr a -> b -> b
f b
start (PropertyMapGeneric HashMap Text (t (p a))
hm) = (t (p a) -> b -> b) -> b -> HashMap Text (t (p a)) -> b
forall a b. (a -> b -> b) -> b -> HashMap Text a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr t (p a) -> b -> b
forall {t :: * -> *} {t :: * -> *}.
(Foldable t, Foldable t) =>
t (t a) -> b -> b
f2 b
start HashMap Text (t (p a))
hm
    where
      f2 :: t (t a) -> b -> b
f2 t (t a)
t b
start2 = (t a -> b -> b) -> b -> t (t a) -> b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr t a -> b -> b
forall {t :: * -> *}. Foldable t => t a -> b -> b
f3 b
start2 t (t a)
t
      f3 :: t a -> b -> b
f3 t a
p b
start3 = (a -> b -> b) -> b -> t a -> b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> b -> b
f b
start3 t a
p

instance (Traversable t, Traversable p) => Traversable (PropertyMapGeneric t p) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b)
-> PropertyMapGeneric t p a -> f (PropertyMapGeneric t p b)
traverse a -> f b
f (PropertyMapGeneric HashMap Text (t (p a))
hm) = (HashMap Text (t (p b)) -> PropertyMapGeneric t p b)
-> f (HashMap Text (t (p b))) -> f (PropertyMapGeneric t p b)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HashMap Text (t (p b)) -> PropertyMapGeneric t p b
forall (t :: * -> *) (p :: * -> *) v.
HashMap Text (t (p v)) -> PropertyMapGeneric t p v
PropertyMapGeneric (f (HashMap Text (t (p b))) -> f (PropertyMapGeneric t p b))
-> f (HashMap Text (t (p b))) -> f (PropertyMapGeneric t p b)
forall a b. (a -> b) -> a -> b
$ ((t (p a) -> f (t (p b)))
-> HashMap Text (t (p a)) -> f (HashMap Text (t (p b)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> HashMap Text a -> f (HashMap Text b)
traverse ((t (p a) -> f (t (p b)))
 -> HashMap Text (t (p a)) -> f (HashMap Text (t (p b))))
-> ((a -> f b) -> t (p a) -> f (t (p b)))
-> (a -> f b)
-> HashMap Text (t (p a))
-> f (HashMap Text (t (p b)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (p a -> f (p b)) -> t (p a) -> f (t (p b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse ((p a -> f (p b)) -> t (p a) -> f (t (p b)))
-> ((a -> f b) -> p a -> f (p b))
-> (a -> f b)
-> t (p a)
-> f (t (p b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b) -> p a -> f (p b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> p a -> f (p b)
traverse) a -> f b
f HashMap Text (t (p a))
hm

putPropertyGeneric :: (Semigroup (t (p v)), Applicative t, Property p) => p v -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
putPropertyGeneric :: forall (t :: * -> *) (p :: * -> *) v.
(Semigroup (t (p v)), Applicative t, Property p) =>
p v -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
putPropertyGeneric p v
prop (PropertyMapGeneric HashMap Text (t (p v))
hm) =
  HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall (t :: * -> *) (p :: * -> *) v.
HashMap Text (t (p v)) -> PropertyMapGeneric t p v
PropertyMapGeneric (HashMap Text (t (p v)) -> PropertyMapGeneric t p v)
-> HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall a b. (a -> b) -> a -> b
$ (t (p v) -> t (p v) -> t (p v))
-> Text
-> t (p v)
-> HashMap Text (t (p v))
-> HashMap Text (t (p v))
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> k -> v -> HashMap k v -> HashMap k v
HM.insertWith t (p v) -> t (p v) -> t (p v)
forall a. Semigroup a => a -> a -> a
(<>) (p v -> Text
forall v. p v -> Text
forall (p :: * -> *) v. Property p => p v -> Text
propertyKey p v
prop) (p v -> t (p v)
forall a. a -> t a
forall (f :: * -> *) a. Applicative f => a -> f a
pure p v
prop) HashMap Text (t (p v))
hm

removePropertyGeneric :: Text -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
removePropertyGeneric :: forall (t :: * -> *) (p :: * -> *) v.
Text -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
removePropertyGeneric Text
k (PropertyMapGeneric HashMap Text (t (p v))
hm) = HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall (t :: * -> *) (p :: * -> *) v.
HashMap Text (t (p v)) -> PropertyMapGeneric t p v
PropertyMapGeneric (HashMap Text (t (p v)) -> PropertyMapGeneric t p v)
-> HashMap Text (t (p v)) -> PropertyMapGeneric t p v
forall a b. (a -> b) -> a -> b
$ Text -> HashMap Text (t (p v)) -> HashMap Text (t (p v))
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
HM.delete Text
k HashMap Text (t (p v))
hm

allPropertiesGeneric :: Foldable t => PropertyMapGeneric t p v -> [p v]
allPropertiesGeneric :: forall (t :: * -> *) (p :: * -> *) v.
Foldable t =>
PropertyMapGeneric t p v -> [p v]
allPropertiesGeneric (PropertyMapGeneric HashMap Text (t (p v))
hm) = [[p v]] -> [p v]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[p v]] -> [p v]) -> [[p v]] -> [p v]
forall a b. (a -> b) -> a -> b
$ (t (p v) -> [p v]) -> [t (p v)] -> [[p v]]
forall a b. (a -> b) -> [a] -> [b]
map t (p v) -> [p v]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList ([t (p v)] -> [[p v]]) -> [t (p v)] -> [[p v]]
forall a b. (a -> b) -> a -> b
$ HashMap Text (t (p v)) -> [t (p v)]
forall k v. HashMap k v -> [v]
HM.elems HashMap Text (t (p v))
hm

parsePropertiesGeneric :: (Property p, PropertyMap m, Monoid (m p v), GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v))
                       => (GValue -> Parser (Vector GValue))
                       -> GValue
                       -> Parser (m p v)
parsePropertiesGeneric :: forall (p :: * -> *) (m :: (* -> *) -> * -> *) v.
(Property p, PropertyMap m, Monoid (m p v), GraphSONTyped (p v),
 FromGraphSON (p v), FromGraphSONWithKey (p v)) =>
(GValue -> Parser (Vector GValue)) -> GValue -> Parser (m p v)
parsePropertiesGeneric GValue -> Parser (Vector GValue)
normalizeCardinality GValue
gv = case GValue -> GValueBody
gValueBody GValue
gv of
  GObject KeyMap GValue
obj -> (m p v -> (Key, GValue) -> Parser (m p v))
-> m p v -> [(Key, GValue)] -> Parser (m p v)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldlM m p v -> (Key, GValue) -> Parser (m p v)
forall {m :: (* -> *) -> * -> *} {p :: * -> *} {v}.
(PropertyMap m, Property p, GraphSONTyped (p v),
 FromGraphSON (p v), FromGraphSONWithKey (p v)) =>
m p v -> (Key, GValue) -> Parser (m p v)
folder m p v
forall a. Monoid a => a
mempty ([(Key, GValue)] -> Parser (m p v))
-> [(Key, GValue)] -> Parser (m p v)
forall a b. (a -> b) -> a -> b
$ KeyMap GValue -> [(Key, GValue)]
forall v. KeyMap v -> [(Key, v)]
KM.toList KeyMap GValue
obj
  GValueBody
_           -> Parser (m p v)
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty
  where
    folder :: m p v -> (Key, GValue) -> Parser (m p v)
folder m p v
pm (Key
k, GValue
value) = (Vector (p v) -> m p v) -> Parser (Vector (p v)) -> Parser (m p v)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((p v -> m p v -> m p v) -> m p v -> Vector (p v) -> m p v
forall a b. (a -> b -> b) -> b -> Vector a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr p v -> m p v -> m p v
forall (p :: * -> *) v. Property p => p v -> m p v -> m p v
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
(PropertyMap m, Property p) =>
p v -> m p v -> m p v
putProperty m p v
pm) (Parser (Vector (p v)) -> Parser (m p v))
-> Parser (Vector (p v)) -> Parser (m p v)
forall a b. (a -> b) -> a -> b
$ (GValue -> Parser (p v)) -> Vector GValue -> Parser (Vector (p v))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector a -> f (Vector b)
traverse (Key -> GValue -> Parser (p v)
forall {a}.
(GraphSONTyped a, FromGraphSON a, FromGraphSONWithKey a) =>
Key -> GValue -> Parser a
parseProperty Key
k) (Vector GValue -> Parser (Vector (p v)))
-> Parser (Vector GValue) -> Parser (Vector (p v))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GValue -> Parser (Vector GValue)
normalizeCardinality GValue
value
    parseProperty :: Key -> GValue -> Parser a
parseProperty Key
k GValue
value = GValue -> Parser a
forall v. (GraphSONTyped v, FromGraphSON v) => GValue -> Parser v
parseTypedGValue GValue
value Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> GValue -> Parser a
forall a. FromGraphSONWithKey a => Text -> GValue -> Parser a
parseGraphSONWithKey (Key -> Text
Key.toText Key
k) GValue
value

-- parhaps we might as well place it in GraphSON module and let it export.
parseTypedGValue :: (GraphSONTyped v, FromGraphSON v) => GValue -> Parser v
parseTypedGValue :: forall v. (GraphSONTyped v, FromGraphSON v) => GValue -> Parser v
parseTypedGValue  GValue
gv = do
  v
prop <- GValue -> Parser v
forall a. FromGraphSON a => GValue -> Parser a
parseGraphSON GValue
gv
  let exp_type :: Text
exp_type = v -> Text
forall a. GraphSONTyped a => a -> Text
gsonTypeFor v
prop
      mgot_type :: Maybe Text
mgot_type = GValue -> Maybe Text
gValueType GValue
gv
  if Maybe Text
mgot_type Maybe Text -> Maybe Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
exp_type
    then [Char] -> Parser v
forall a. [Char] -> Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char]
"Expected @type field of " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
exp_type [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", but got " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Maybe Text -> [Char]
forall a. Show a => a -> [Char]
show Maybe Text
mgot_type)
    else v -> Parser v
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return v
prop

expectAesonArray :: GValue -> Parser (Vector GValue)
expectAesonArray :: GValue -> Parser (Vector GValue)
expectAesonArray GValue
gv = case GValue -> GValueBody
gValueBody GValue
gv of
  GArray Vector GValue
a -> Vector GValue -> Parser (Vector GValue)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return Vector GValue
a
  GValueBody
_        -> Parser (Vector GValue)
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty

-- | A 'PropertyMap' that has a single value per key.
--
-- 'putProperty' replaces the old property by the given property.
--
-- '<>' returns the union of the two given property maps. If the two
-- property maps share some same keys, the value from the left map
-- wins.
newtype PropertyMapSingle p v
  = PropertyMapSingle (PropertyMapGeneric Semigroup.First p v)
  deriving (PropertyMapSingle p v -> PropertyMapSingle p v -> Bool
(PropertyMapSingle p v -> PropertyMapSingle p v -> Bool)
-> (PropertyMapSingle p v -> PropertyMapSingle p v -> Bool)
-> Eq (PropertyMapSingle p v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (p :: * -> *) v.
Eq (p v) =>
PropertyMapSingle p v -> PropertyMapSingle p v -> Bool
$c== :: forall (p :: * -> *) v.
Eq (p v) =>
PropertyMapSingle p v -> PropertyMapSingle p v -> Bool
== :: PropertyMapSingle p v -> PropertyMapSingle p v -> Bool
$c/= :: forall (p :: * -> *) v.
Eq (p v) =>
PropertyMapSingle p v -> PropertyMapSingle p v -> Bool
/= :: PropertyMapSingle p v -> PropertyMapSingle p v -> Bool
Eq, (forall m. Monoid m => PropertyMapSingle p m -> m)
-> (forall m a. Monoid m => (a -> m) -> PropertyMapSingle p a -> m)
-> (forall m a. Monoid m => (a -> m) -> PropertyMapSingle p a -> m)
-> (forall a b. (a -> b -> b) -> b -> PropertyMapSingle p a -> b)
-> (forall a b. (a -> b -> b) -> b -> PropertyMapSingle p a -> b)
-> (forall b a. (b -> a -> b) -> b -> PropertyMapSingle p a -> b)
-> (forall b a. (b -> a -> b) -> b -> PropertyMapSingle p a -> b)
-> (forall a. (a -> a -> a) -> PropertyMapSingle p a -> a)
-> (forall a. (a -> a -> a) -> PropertyMapSingle p a -> a)
-> (forall a. PropertyMapSingle p a -> [a])
-> (forall a. PropertyMapSingle p a -> Bool)
-> (forall a. PropertyMapSingle p a -> Int)
-> (forall a. Eq a => a -> PropertyMapSingle p a -> Bool)
-> (forall a. Ord a => PropertyMapSingle p a -> a)
-> (forall a. Ord a => PropertyMapSingle p a -> a)
-> (forall a. Num a => PropertyMapSingle p a -> a)
-> (forall a. Num a => PropertyMapSingle p a -> a)
-> Foldable (PropertyMapSingle p)
forall a. Eq a => a -> PropertyMapSingle p a -> Bool
forall a. Num a => PropertyMapSingle p a -> a
forall a. Ord a => PropertyMapSingle p a -> a
forall m. Monoid m => PropertyMapSingle p m -> m
forall a. PropertyMapSingle p a -> Bool
forall a. PropertyMapSingle p a -> Int
forall a. PropertyMapSingle p a -> [a]
forall a. (a -> a -> a) -> PropertyMapSingle p a -> a
forall m a. Monoid m => (a -> m) -> PropertyMapSingle p a -> m
forall b a. (b -> a -> b) -> b -> PropertyMapSingle p a -> b
forall a b. (a -> b -> b) -> b -> PropertyMapSingle p a -> b
forall (p :: * -> *) a.
(Foldable p, Eq a) =>
a -> PropertyMapSingle p a -> Bool
forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapSingle p a -> a
forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapSingle p a -> a
forall (p :: * -> *) m.
(Foldable p, Monoid m) =>
PropertyMapSingle p m -> m
forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> Bool
forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> Int
forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> [a]
forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapSingle p a -> a
forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapSingle p a -> m
forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (p :: * -> *) m.
(Foldable p, Monoid m) =>
PropertyMapSingle p m -> m
fold :: forall m. Monoid m => PropertyMapSingle p m -> m
$cfoldMap :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapSingle p a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PropertyMapSingle p a -> m
$cfoldMap' :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapSingle p a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PropertyMapSingle p a -> m
$cfoldr :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PropertyMapSingle p a -> b
$cfoldr' :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PropertyMapSingle p a -> b
$cfoldl :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PropertyMapSingle p a -> b
$cfoldl' :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PropertyMapSingle p a -> b
$cfoldr1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapSingle p a -> a
foldr1 :: forall a. (a -> a -> a) -> PropertyMapSingle p a -> a
$cfoldl1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapSingle p a -> a
foldl1 :: forall a. (a -> a -> a) -> PropertyMapSingle p a -> a
$ctoList :: forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> [a]
toList :: forall a. PropertyMapSingle p a -> [a]
$cnull :: forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> Bool
null :: forall a. PropertyMapSingle p a -> Bool
$clength :: forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> Int
length :: forall a. PropertyMapSingle p a -> Int
$celem :: forall (p :: * -> *) a.
(Foldable p, Eq a) =>
a -> PropertyMapSingle p a -> Bool
elem :: forall a. Eq a => a -> PropertyMapSingle p a -> Bool
$cmaximum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapSingle p a -> a
maximum :: forall a. Ord a => PropertyMapSingle p a -> a
$cminimum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapSingle p a -> a
minimum :: forall a. Ord a => PropertyMapSingle p a -> a
$csum :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapSingle p a -> a
sum :: forall a. Num a => PropertyMapSingle p a -> a
$cproduct :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapSingle p a -> a
product :: forall a. Num a => PropertyMapSingle p a -> a
Foldable, (forall a b.
 (a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b)
-> (forall a b.
    a -> PropertyMapSingle p b -> PropertyMapSingle p a)
-> Functor (PropertyMapSingle p)
forall a b. a -> PropertyMapSingle p b -> PropertyMapSingle p a
forall a b.
(a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
forall (p :: * -> *) a b.
Functor p =>
a -> PropertyMapSingle p b -> PropertyMapSingle p a
forall (p :: * -> *) a b.
Functor p =>
(a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (p :: * -> *) a b.
Functor p =>
(a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
fmap :: forall a b.
(a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
$c<$ :: forall (p :: * -> *) a b.
Functor p =>
a -> PropertyMapSingle p b -> PropertyMapSingle p a
<$ :: forall a b. a -> PropertyMapSingle p b -> PropertyMapSingle p a
Functor, Semigroup (PropertyMapSingle p v)
PropertyMapSingle p v
Semigroup (PropertyMapSingle p v) =>
PropertyMapSingle p v
-> (PropertyMapSingle p v
    -> PropertyMapSingle p v -> PropertyMapSingle p v)
-> ([PropertyMapSingle p v] -> PropertyMapSingle p v)
-> Monoid (PropertyMapSingle p v)
[PropertyMapSingle p v] -> PropertyMapSingle p v
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall (p :: * -> *) v. Semigroup (PropertyMapSingle p v)
forall (p :: * -> *) v. PropertyMapSingle p v
forall (p :: * -> *) v.
[PropertyMapSingle p v] -> PropertyMapSingle p v
forall (p :: * -> *) v.
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
$cmempty :: forall (p :: * -> *) v. PropertyMapSingle p v
mempty :: PropertyMapSingle p v
$cmappend :: forall (p :: * -> *) v.
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
mappend :: PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
$cmconcat :: forall (p :: * -> *) v.
[PropertyMapSingle p v] -> PropertyMapSingle p v
mconcat :: [PropertyMapSingle p v] -> PropertyMapSingle p v
Monoid, NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
(PropertyMapSingle p v
 -> PropertyMapSingle p v -> PropertyMapSingle p v)
-> (NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v)
-> (forall b.
    Integral b =>
    b -> PropertyMapSingle p v -> PropertyMapSingle p v)
-> Semigroup (PropertyMapSingle p v)
forall b.
Integral b =>
b -> PropertyMapSingle p v -> PropertyMapSingle p v
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall (p :: * -> *) v.
NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v
forall (p :: * -> *) v.
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
forall (p :: * -> *) v b.
Integral b =>
b -> PropertyMapSingle p v -> PropertyMapSingle p v
$c<> :: forall (p :: * -> *) v.
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
<> :: PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
$csconcat :: forall (p :: * -> *) v.
NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v
sconcat :: NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v
$cstimes :: forall (p :: * -> *) v b.
Integral b =>
b -> PropertyMapSingle p v -> PropertyMapSingle p v
stimes :: forall b.
Integral b =>
b -> PropertyMapSingle p v -> PropertyMapSingle p v
Semigroup, Int -> PropertyMapSingle p v -> [Char] -> [Char]
[PropertyMapSingle p v] -> [Char] -> [Char]
PropertyMapSingle p v -> [Char]
(Int -> PropertyMapSingle p v -> [Char] -> [Char])
-> (PropertyMapSingle p v -> [Char])
-> ([PropertyMapSingle p v] -> [Char] -> [Char])
-> Show (PropertyMapSingle p v)
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapSingle p v -> [Char] -> [Char]
forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapSingle p v] -> [Char] -> [Char]
forall (p :: * -> *) v.
Show (p v) =>
PropertyMapSingle p v -> [Char]
$cshowsPrec :: forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapSingle p v -> [Char] -> [Char]
showsPrec :: Int -> PropertyMapSingle p v -> [Char] -> [Char]
$cshow :: forall (p :: * -> *) v.
Show (p v) =>
PropertyMapSingle p v -> [Char]
show :: PropertyMapSingle p v -> [Char]
$cshowList :: forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapSingle p v] -> [Char] -> [Char]
showList :: [PropertyMapSingle p v] -> [Char] -> [Char]
Show, Functor (PropertyMapSingle p)
Foldable (PropertyMapSingle p)
(Functor (PropertyMapSingle p), Foldable (PropertyMapSingle p)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PropertyMapSingle p (f a) -> f (PropertyMapSingle p a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PropertyMapSingle p (m a) -> m (PropertyMapSingle p a))
-> Traversable (PropertyMapSingle p)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (p :: * -> *).
Traversable p =>
Functor (PropertyMapSingle p)
forall (p :: * -> *).
Traversable p =>
Foldable (PropertyMapSingle p)
forall (p :: * -> *) (m :: * -> *) a.
(Traversable p, Monad m) =>
PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)
forall (p :: * -> *) (f :: * -> *) a.
(Traversable p, Applicative f) =>
PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)
forall (p :: * -> *) (m :: * -> *) a b.
(Traversable p, Monad m) =>
(a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)
forall (p :: * -> *) (f :: * -> *) a b.
(Traversable p, Applicative f) =>
(a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b)
forall (m :: * -> *) a.
Monad m =>
PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)
forall (f :: * -> *) a.
Applicative f =>
PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b)
$ctraverse :: forall (p :: * -> *) (f :: * -> *) a b.
(Traversable p, Applicative f) =>
(a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b)
$csequenceA :: forall (p :: * -> *) (f :: * -> *) a.
(Traversable p, Applicative f) =>
PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)
$cmapM :: forall (p :: * -> *) (m :: * -> *) a b.
(Traversable p, Monad m) =>
(a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)
$csequence :: forall (p :: * -> *) (m :: * -> *) a.
(Traversable p, Monad m) =>
PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)
sequence :: forall (m :: * -> *) a.
Monad m =>
PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)
Traversable)

instance PropertyMap PropertyMapSingle where
  lookupOne :: forall (p :: * -> *) v.
Text -> PropertyMapSingle p v -> Maybe (p v)
lookupOne Text
k (PropertyMapSingle (PropertyMapGeneric HashMap Text (First (p v))
hm)) = (First (p v) -> p v) -> Maybe (First (p v)) -> Maybe (p v)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap First (p v) -> p v
forall a. First a -> a
Semigroup.getFirst (Maybe (First (p v)) -> Maybe (p v))
-> Maybe (First (p v)) -> Maybe (p v)
forall a b. (a -> b) -> a -> b
$ Text -> HashMap Text (First (p v)) -> Maybe (First (p v))
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup Text
k HashMap Text (First (p v))
hm
  lookupList :: forall (p :: * -> *) v. Text -> PropertyMapSingle p v -> [p v]
lookupList Text
k PropertyMapSingle p v
m = [p v] -> (p v -> [p v]) -> Maybe (p v) -> [p v]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] p v -> [p v]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (p v) -> [p v]) -> Maybe (p v) -> [p v]
forall a b. (a -> b) -> a -> b
$ Text -> PropertyMapSingle p v -> Maybe (p v)
forall (p :: * -> *) v.
Text -> PropertyMapSingle p v -> Maybe (p v)
forall (m :: (* -> *) -> * -> *) (p :: * -> *) v.
PropertyMap m =>
Text -> m p v -> Maybe (p v)
lookupOne Text
k PropertyMapSingle p v
m
  putProperty :: forall (p :: * -> *) v.
Property p =>
p v -> PropertyMapSingle p v -> PropertyMapSingle p v
putProperty p v
p (PropertyMapSingle PropertyMapGeneric First p v
pg) = PropertyMapGeneric First p v -> PropertyMapSingle p v
forall (p :: * -> *) v.
PropertyMapGeneric First p v -> PropertyMapSingle p v
PropertyMapSingle (PropertyMapGeneric First p v -> PropertyMapSingle p v)
-> PropertyMapGeneric First p v -> PropertyMapSingle p v
forall a b. (a -> b) -> a -> b
$ p v -> PropertyMapGeneric First p v -> PropertyMapGeneric First p v
forall (t :: * -> *) (p :: * -> *) v.
(Semigroup (t (p v)), Applicative t, Property p) =>
p v -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
putPropertyGeneric p v
p PropertyMapGeneric First p v
pg
  removeProperty :: forall (p :: * -> *) v.
Text -> PropertyMapSingle p v -> PropertyMapSingle p v
removeProperty Text
t (PropertyMapSingle PropertyMapGeneric First p v
pg) = PropertyMapGeneric First p v -> PropertyMapSingle p v
forall (p :: * -> *) v.
PropertyMapGeneric First p v -> PropertyMapSingle p v
PropertyMapSingle (PropertyMapGeneric First p v -> PropertyMapSingle p v)
-> PropertyMapGeneric First p v -> PropertyMapSingle p v
forall a b. (a -> b) -> a -> b
$ Text
-> PropertyMapGeneric First p v -> PropertyMapGeneric First p v
forall (t :: * -> *) (p :: * -> *) v.
Text -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
removePropertyGeneric Text
t PropertyMapGeneric First p v
pg
  allProperties :: forall (p :: * -> *) v. PropertyMapSingle p v -> [p v]
allProperties (PropertyMapSingle PropertyMapGeneric First p v
pg) = PropertyMapGeneric First p v -> [p v]
forall (t :: * -> *) (p :: * -> *) v.
Foldable t =>
PropertyMapGeneric t p v -> [p v]
allPropertiesGeneric PropertyMapGeneric First p v
pg

-- | In version 0.1.1.0 and before, the constraint was @FromJSON v@.
-- This has changed.
instance (Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v))
         => FromJSON (PropertyMapSingle p v) where
  parseJSON :: Value -> Parser (PropertyMapSingle p v)
parseJSON = Value -> Parser (PropertyMapSingle p v)
forall a. FromGraphSON a => Value -> Parser a
parseJSONViaGValue

instance (Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v))
         => FromGraphSON (PropertyMapSingle p v) where
  parseGraphSON :: GValue -> Parser (PropertyMapSingle p v)
parseGraphSON = (GValue -> Parser (Vector GValue))
-> GValue -> Parser (PropertyMapSingle p v)
forall (p :: * -> *) (m :: (* -> *) -> * -> *) v.
(Property p, PropertyMap m, Monoid (m p v), GraphSONTyped (p v),
 FromGraphSON (p v), FromGraphSONWithKey (p v)) =>
(GValue -> Parser (Vector GValue)) -> GValue -> Parser (m p v)
parsePropertiesGeneric (Vector GValue -> Parser (Vector GValue)
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector GValue -> Parser (Vector GValue))
-> (GValue -> Vector GValue) -> GValue -> Parser (Vector GValue)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GValue -> Vector GValue
forall a. a -> Vector a
forall (m :: * -> *) a. Monad m => a -> m a
return)

-- | A 'PropertyMap' that can keep more than one values per key.
--
-- 'lookupOne' returns the first property associated with the given
-- key.
--
-- 'putProperty' prepends the given property to the property list.
--
-- '<>' returns the union of the two given property maps. If the two
-- property maps share some same keys, those property lists are
-- concatenated.
newtype PropertyMapList p v
  = PropertyMapList (PropertyMapGeneric NonEmpty p v)
  deriving (PropertyMapList p v -> PropertyMapList p v -> Bool
(PropertyMapList p v -> PropertyMapList p v -> Bool)
-> (PropertyMapList p v -> PropertyMapList p v -> Bool)
-> Eq (PropertyMapList p v)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (p :: * -> *) v.
Eq (p v) =>
PropertyMapList p v -> PropertyMapList p v -> Bool
$c== :: forall (p :: * -> *) v.
Eq (p v) =>
PropertyMapList p v -> PropertyMapList p v -> Bool
== :: PropertyMapList p v -> PropertyMapList p v -> Bool
$c/= :: forall (p :: * -> *) v.
Eq (p v) =>
PropertyMapList p v -> PropertyMapList p v -> Bool
/= :: PropertyMapList p v -> PropertyMapList p v -> Bool
Eq, (forall m. Monoid m => PropertyMapList p m -> m)
-> (forall m a. Monoid m => (a -> m) -> PropertyMapList p a -> m)
-> (forall m a. Monoid m => (a -> m) -> PropertyMapList p a -> m)
-> (forall a b. (a -> b -> b) -> b -> PropertyMapList p a -> b)
-> (forall a b. (a -> b -> b) -> b -> PropertyMapList p a -> b)
-> (forall b a. (b -> a -> b) -> b -> PropertyMapList p a -> b)
-> (forall b a. (b -> a -> b) -> b -> PropertyMapList p a -> b)
-> (forall a. (a -> a -> a) -> PropertyMapList p a -> a)
-> (forall a. (a -> a -> a) -> PropertyMapList p a -> a)
-> (forall a. PropertyMapList p a -> [a])
-> (forall a. PropertyMapList p a -> Bool)
-> (forall a. PropertyMapList p a -> Int)
-> (forall a. Eq a => a -> PropertyMapList p a -> Bool)
-> (forall a. Ord a => PropertyMapList p a -> a)
-> (forall a. Ord a => PropertyMapList p a -> a)
-> (forall a. Num a => PropertyMapList p a -> a)
-> (forall a. Num a => PropertyMapList p a -> a)
-> Foldable (PropertyMapList p)
forall a. Eq a => a -> PropertyMapList p a -> Bool
forall a. Num a => PropertyMapList p a -> a
forall a. Ord a => PropertyMapList p a -> a
forall m. Monoid m => PropertyMapList p m -> m
forall a. PropertyMapList p a -> Bool
forall a. PropertyMapList p a -> Int
forall a. PropertyMapList p a -> [a]
forall a. (a -> a -> a) -> PropertyMapList p a -> a
forall m a. Monoid m => (a -> m) -> PropertyMapList p a -> m
forall b a. (b -> a -> b) -> b -> PropertyMapList p a -> b
forall a b. (a -> b -> b) -> b -> PropertyMapList p a -> b
forall (p :: * -> *) a.
(Foldable p, Eq a) =>
a -> PropertyMapList p a -> Bool
forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapList p a -> a
forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapList p a -> a
forall (p :: * -> *) m.
(Foldable p, Monoid m) =>
PropertyMapList p m -> m
forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> Bool
forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> Int
forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> [a]
forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapList p a -> a
forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapList p a -> m
forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapList p a -> b
forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapList p a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (p :: * -> *) m.
(Foldable p, Monoid m) =>
PropertyMapList p m -> m
fold :: forall m. Monoid m => PropertyMapList p m -> m
$cfoldMap :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapList p a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PropertyMapList p a -> m
$cfoldMap' :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapList p a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PropertyMapList p a -> m
$cfoldr :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapList p a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PropertyMapList p a -> b
$cfoldr' :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapList p a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PropertyMapList p a -> b
$cfoldl :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapList p a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PropertyMapList p a -> b
$cfoldl' :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapList p a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PropertyMapList p a -> b
$cfoldr1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapList p a -> a
foldr1 :: forall a. (a -> a -> a) -> PropertyMapList p a -> a
$cfoldl1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapList p a -> a
foldl1 :: forall a. (a -> a -> a) -> PropertyMapList p a -> a
$ctoList :: forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> [a]
toList :: forall a. PropertyMapList p a -> [a]
$cnull :: forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> Bool
null :: forall a. PropertyMapList p a -> Bool
$clength :: forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> Int
length :: forall a. PropertyMapList p a -> Int
$celem :: forall (p :: * -> *) a.
(Foldable p, Eq a) =>
a -> PropertyMapList p a -> Bool
elem :: forall a. Eq a => a -> PropertyMapList p a -> Bool
$cmaximum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapList p a -> a
maximum :: forall a. Ord a => PropertyMapList p a -> a
$cminimum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapList p a -> a
minimum :: forall a. Ord a => PropertyMapList p a -> a
$csum :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapList p a -> a
sum :: forall a. Num a => PropertyMapList p a -> a
$cproduct :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapList p a -> a
product :: forall a. Num a => PropertyMapList p a -> a
Foldable, (forall a b.
 (a -> b) -> PropertyMapList p a -> PropertyMapList p b)
-> (forall a b. a -> PropertyMapList p b -> PropertyMapList p a)
-> Functor (PropertyMapList p)
forall a b. a -> PropertyMapList p b -> PropertyMapList p a
forall a b. (a -> b) -> PropertyMapList p a -> PropertyMapList p b
forall (p :: * -> *) a b.
Functor p =>
a -> PropertyMapList p b -> PropertyMapList p a
forall (p :: * -> *) a b.
Functor p =>
(a -> b) -> PropertyMapList p a -> PropertyMapList p b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (p :: * -> *) a b.
Functor p =>
(a -> b) -> PropertyMapList p a -> PropertyMapList p b
fmap :: forall a b. (a -> b) -> PropertyMapList p a -> PropertyMapList p b
$c<$ :: forall (p :: * -> *) a b.
Functor p =>
a -> PropertyMapList p b -> PropertyMapList p a
<$ :: forall a b. a -> PropertyMapList p b -> PropertyMapList p a
Functor, Semigroup (PropertyMapList p v)
PropertyMapList p v
Semigroup (PropertyMapList p v) =>
PropertyMapList p v
-> (PropertyMapList p v
    -> PropertyMapList p v -> PropertyMapList p v)
-> ([PropertyMapList p v] -> PropertyMapList p v)
-> Monoid (PropertyMapList p v)
[PropertyMapList p v] -> PropertyMapList p v
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall (p :: * -> *) v. Semigroup (PropertyMapList p v)
forall (p :: * -> *) v. PropertyMapList p v
forall (p :: * -> *) v.
[PropertyMapList p v] -> PropertyMapList p v
forall (p :: * -> *) v.
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
$cmempty :: forall (p :: * -> *) v. PropertyMapList p v
mempty :: PropertyMapList p v
$cmappend :: forall (p :: * -> *) v.
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
mappend :: PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
$cmconcat :: forall (p :: * -> *) v.
[PropertyMapList p v] -> PropertyMapList p v
mconcat :: [PropertyMapList p v] -> PropertyMapList p v
Monoid, NonEmpty (PropertyMapList p v) -> PropertyMapList p v
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
(PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v)
-> (NonEmpty (PropertyMapList p v) -> PropertyMapList p v)
-> (forall b.
    Integral b =>
    b -> PropertyMapList p v -> PropertyMapList p v)
-> Semigroup (PropertyMapList p v)
forall b.
Integral b =>
b -> PropertyMapList p v -> PropertyMapList p v
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall (p :: * -> *) v.
NonEmpty (PropertyMapList p v) -> PropertyMapList p v
forall (p :: * -> *) v.
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
forall (p :: * -> *) v b.
Integral b =>
b -> PropertyMapList p v -> PropertyMapList p v
$c<> :: forall (p :: * -> *) v.
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
<> :: PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
$csconcat :: forall (p :: * -> *) v.
NonEmpty (PropertyMapList p v) -> PropertyMapList p v
sconcat :: NonEmpty (PropertyMapList p v) -> PropertyMapList p v
$cstimes :: forall (p :: * -> *) v b.
Integral b =>
b -> PropertyMapList p v -> PropertyMapList p v
stimes :: forall b.
Integral b =>
b -> PropertyMapList p v -> PropertyMapList p v
Semigroup, Int -> PropertyMapList p v -> [Char] -> [Char]
[PropertyMapList p v] -> [Char] -> [Char]
PropertyMapList p v -> [Char]
(Int -> PropertyMapList p v -> [Char] -> [Char])
-> (PropertyMapList p v -> [Char])
-> ([PropertyMapList p v] -> [Char] -> [Char])
-> Show (PropertyMapList p v)
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapList p v -> [Char] -> [Char]
forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapList p v] -> [Char] -> [Char]
forall (p :: * -> *) v. Show (p v) => PropertyMapList p v -> [Char]
$cshowsPrec :: forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapList p v -> [Char] -> [Char]
showsPrec :: Int -> PropertyMapList p v -> [Char] -> [Char]
$cshow :: forall (p :: * -> *) v. Show (p v) => PropertyMapList p v -> [Char]
show :: PropertyMapList p v -> [Char]
$cshowList :: forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapList p v] -> [Char] -> [Char]
showList :: [PropertyMapList p v] -> [Char] -> [Char]
Show, Functor (PropertyMapList p)
Foldable (PropertyMapList p)
(Functor (PropertyMapList p), Foldable (PropertyMapList p)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PropertyMapList p (f a) -> f (PropertyMapList p a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PropertyMapList p (m a) -> m (PropertyMapList p a))
-> Traversable (PropertyMapList p)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (p :: * -> *). Traversable p => Functor (PropertyMapList p)
forall (p :: * -> *). Traversable p => Foldable (PropertyMapList p)
forall (p :: * -> *) (m :: * -> *) a.
(Traversable p, Monad m) =>
PropertyMapList p (m a) -> m (PropertyMapList p a)
forall (p :: * -> *) (f :: * -> *) a.
(Traversable p, Applicative f) =>
PropertyMapList p (f a) -> f (PropertyMapList p a)
forall (p :: * -> *) (m :: * -> *) a b.
(Traversable p, Monad m) =>
(a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)
forall (p :: * -> *) (f :: * -> *) a b.
(Traversable p, Applicative f) =>
(a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b)
forall (m :: * -> *) a.
Monad m =>
PropertyMapList p (m a) -> m (PropertyMapList p a)
forall (f :: * -> *) a.
Applicative f =>
PropertyMapList p (f a) -> f (PropertyMapList p a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b)
$ctraverse :: forall (p :: * -> *) (f :: * -> *) a b.
(Traversable p, Applicative f) =>
(a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b)
$csequenceA :: forall (p :: * -> *) (f :: * -> *) a.
(Traversable p, Applicative f) =>
PropertyMapList p (f a) -> f (PropertyMapList p a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PropertyMapList p (f a) -> f (PropertyMapList p a)
$cmapM :: forall (p :: * -> *) (m :: * -> *) a b.
(Traversable p, Monad m) =>
(a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)
$csequence :: forall (p :: * -> *) (m :: * -> *) a.
(Traversable p, Monad m) =>
PropertyMapList p (m a) -> m (PropertyMapList p a)
sequence :: forall (m :: * -> *) a.
Monad m =>
PropertyMapList p (m a) -> m (PropertyMapList p a)
Traversable)

instance PropertyMap PropertyMapList where
  lookupList :: forall (p :: * -> *) v. Text -> PropertyMapList p v -> [p v]
lookupList Text
k (PropertyMapList (PropertyMapGeneric HashMap Text (NonEmpty (p v))
hm)) = [p v]
-> (NonEmpty (p v) -> [p v]) -> Maybe (NonEmpty (p v)) -> [p v]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] NonEmpty (p v) -> [p v]
forall a. NonEmpty a -> [a]
NL.toList (Maybe (NonEmpty (p v)) -> [p v])
-> Maybe (NonEmpty (p v)) -> [p v]
forall a b. (a -> b) -> a -> b
$ Text -> HashMap Text (NonEmpty (p v)) -> Maybe (NonEmpty (p v))
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup Text
k HashMap Text (NonEmpty (p v))
hm
  putProperty :: forall (p :: * -> *) v.
Property p =>
p v -> PropertyMapList p v -> PropertyMapList p v
putProperty p v
p (PropertyMapList PropertyMapGeneric NonEmpty p v
pg) = PropertyMapGeneric NonEmpty p v -> PropertyMapList p v
forall (p :: * -> *) v.
PropertyMapGeneric NonEmpty p v -> PropertyMapList p v
PropertyMapList (PropertyMapGeneric NonEmpty p v -> PropertyMapList p v)
-> PropertyMapGeneric NonEmpty p v -> PropertyMapList p v
forall a b. (a -> b) -> a -> b
$ p v
-> PropertyMapGeneric NonEmpty p v
-> PropertyMapGeneric NonEmpty p v
forall (t :: * -> *) (p :: * -> *) v.
(Semigroup (t (p v)), Applicative t, Property p) =>
p v -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
putPropertyGeneric p v
p PropertyMapGeneric NonEmpty p v
pg
  removeProperty :: forall (p :: * -> *) v.
Text -> PropertyMapList p v -> PropertyMapList p v
removeProperty Text
t (PropertyMapList PropertyMapGeneric NonEmpty p v
pg) = PropertyMapGeneric NonEmpty p v -> PropertyMapList p v
forall (p :: * -> *) v.
PropertyMapGeneric NonEmpty p v -> PropertyMapList p v
PropertyMapList (PropertyMapGeneric NonEmpty p v -> PropertyMapList p v)
-> PropertyMapGeneric NonEmpty p v -> PropertyMapList p v
forall a b. (a -> b) -> a -> b
$ Text
-> PropertyMapGeneric NonEmpty p v
-> PropertyMapGeneric NonEmpty p v
forall (t :: * -> *) (p :: * -> *) v.
Text -> PropertyMapGeneric t p v -> PropertyMapGeneric t p v
removePropertyGeneric Text
t PropertyMapGeneric NonEmpty p v
pg
  allProperties :: forall (p :: * -> *) v. PropertyMapList p v -> [p v]
allProperties (PropertyMapList PropertyMapGeneric NonEmpty p v
pg) = PropertyMapGeneric NonEmpty p v -> [p v]
forall (t :: * -> *) (p :: * -> *) v.
Foldable t =>
PropertyMapGeneric t p v -> [p v]
allPropertiesGeneric PropertyMapGeneric NonEmpty p v
pg

-- | In version 0.1.1.0 and before, the constraint was @FromJSON v@.
-- This has changed.
instance (Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v))
         => FromJSON (PropertyMapList p v) where
  parseJSON :: Value -> Parser (PropertyMapList p v)
parseJSON = Value -> Parser (PropertyMapList p v)
forall a. FromGraphSON a => Value -> Parser a
parseJSONViaGValue

instance (Property p, GraphSONTyped (p v), FromGraphSON (p v), FromGraphSONWithKey (p v))
         => FromGraphSON (PropertyMapList p v) where
  parseGraphSON :: GValue -> Parser (PropertyMapList p v)
parseGraphSON GValue
v = (GValue -> Parser (Vector GValue))
-> GValue -> Parser (PropertyMapList p v)
forall (p :: * -> *) (m :: (* -> *) -> * -> *) v.
(Property p, PropertyMap m, Monoid (m p v), GraphSONTyped (p v),
 FromGraphSON (p v), FromGraphSONWithKey (p v)) =>
(GValue -> Parser (Vector GValue)) -> GValue -> Parser (m p v)
parsePropertiesGeneric GValue -> Parser (Vector GValue)
expectAesonArray GValue
v

-- | __This typeclass is for internal use.__
--
-- GraphSON parser with a property key given from outside.
--
-- @since 0.2.0.0
class FromGraphSONWithKey a where
  parseGraphSONWithKey :: Text -> GValue -> Parser a

instance FromGraphSON v => FromGraphSONWithKey (AProperty v) where
  parseGraphSONWithKey :: Text -> GValue -> Parser (AProperty v)
parseGraphSONWithKey Text
k GValue
v = Text -> v -> AProperty v
forall v. Text -> v -> AProperty v
AProperty Text
k (v -> AProperty v) -> Parser v -> Parser (AProperty v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GValue -> Parser v
forall a. FromGraphSON a => GValue -> Parser a
parseGraphSON GValue
v

instance FromGraphSON v => FromGraphSONWithKey (AVertexProperty v) where
  parseGraphSONWithKey :: Text -> GValue -> Parser (AVertexProperty v)
parseGraphSONWithKey Text
k GValue
gv = case GValue -> GValueBody
gValueBody GValue
gv of
    GObject KeyMap GValue
o -> ElementID (AVertexProperty v) -> Text -> v -> AVertexProperty v
forall v.
ElementID (AVertexProperty v) -> Text -> v -> AVertexProperty v
AVertexProperty
                 (ElementID (AVertexProperty v) -> Text -> v -> AVertexProperty v)
-> Parser (ElementID (AVertexProperty v))
-> Parser (Text -> v -> AVertexProperty v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (KeyMap GValue
o KeyMap GValue -> Key -> Parser (ElementID (AVertexProperty v))
forall a. FromGraphSON a => KeyMap GValue -> Key -> Parser a
.: Key
"id")
                 Parser (Text -> v -> AVertexProperty v)
-> Parser Text -> Parser (v -> AVertexProperty v)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Parser Text
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
k
                 Parser (v -> AVertexProperty v)
-> Parser v -> Parser (AVertexProperty v)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (KeyMap GValue
o KeyMap GValue -> Key -> Parser v
forall a. FromGraphSON a => KeyMap GValue -> Key -> Parser a
.: Key
"value")
    GValueBody
_ -> Parser (AVertexProperty v)
forall a. Parser a
forall (f :: * -> *) a. Alternative f => f a
empty