{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveTraversable, 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 {-# DEPRECATED "Use PMap instead" #-}
  ( -- ** 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 Data.Aeson.Types (Parser)
import qualified Data.Aeson.KeyMap as KM
import qualified Data.Aeson.Key as Key
import Data.Foldable (Foldable(..), foldlM)
import Data.Greskell.GraphSON
  ( FromGraphSON(..), GValue, GraphSONTyped(..), (.:),
    parseJSONViaGValue
  )
import Data.Greskell.GraphSON.GValue (gValueBody, gValueType, GValueBody(..))
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 (Property(..), AProperty(..), AVertexProperty(..))

-- | 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 (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 :: Text -> m p v -> Maybe v
lookupOneValue Text
k = (p v -> v) -> Maybe (p v) -> Maybe v
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap 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 (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 :: Text -> m p v -> [v]
lookupListValues Text
k = (p v -> v) -> [p v] -> [v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap 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 (m :: (* -> *) -> * -> *) (p :: * -> *) v.
PropertyMap m =>
Text -> m p v -> [p v]
lookupList Text
k

notExistErrorMsg :: Text -> String
notExistErrorMsg :: Text -> String
notExistErrorMsg Text
k = String
"Property '" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
unpack Text
k String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' 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 :: 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 (String -> Parser v
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
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 :: String
err_msg = Text -> String
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 :: 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)
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 :: 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 [] = String -> m (NonEmpty a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m (NonEmpty a)) -> String -> m (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ Text -> String
notExistErrorMsg Text
k
    toNonEmpty (a
x : [a]
rest) = NonEmpty a -> m (NonEmpty 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 :: [p v] -> m p v
fromProperties = (p v -> m p v -> m p v) -> m p v -> [p v] -> m p v
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr 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 (Int -> PropertyMapGeneric t p v -> String -> String
[PropertyMapGeneric t p v] -> String -> String
PropertyMapGeneric t p v -> String
(Int -> PropertyMapGeneric t p v -> String -> String)
-> (PropertyMapGeneric t p v -> String)
-> ([PropertyMapGeneric t p v] -> String -> String)
-> Show (PropertyMapGeneric t p v)
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
Int -> PropertyMapGeneric t p v -> String -> String
forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
[PropertyMapGeneric t p v] -> String -> String
forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
PropertyMapGeneric t p v -> String
showList :: [PropertyMapGeneric t p v] -> String -> String
$cshowList :: forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
[PropertyMapGeneric t p v] -> String -> String
show :: PropertyMapGeneric t p v -> String
$cshow :: forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
PropertyMapGeneric t p v -> String
showsPrec :: Int -> PropertyMapGeneric t p v -> String -> String
$cshowsPrec :: forall (t :: * -> *) (p :: * -> *) v.
Show (t (p v)) =>
Int -> PropertyMapGeneric t p v -> String -> String
Show,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
/= :: 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
Eq)

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, Hashable 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 :: (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 (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 (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 (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 :: (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 (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 (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 (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 :: (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 (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)
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)
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)
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 :: 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 (p :: * -> *) v. Property p => p v -> Text
propertyKey p v
prop) (p v -> t (p v)
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 :: 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 :: 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 (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 :: (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 (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 (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 (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr 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)
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 (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 :: 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 String -> Parser v
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Expected @type field of " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
unpack Text
exp_type String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", but got " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Maybe Text -> String
forall a. Show a => a -> String
show Maybe Text
mgot_type)
    else v -> Parser v
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 (m :: * -> *) a. Monad m => a -> m a
return Vector GValue
a
  GValueBody
_ -> Parser (Vector GValue)
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 (Int -> PropertyMapSingle p v -> String -> String
[PropertyMapSingle p v] -> String -> String
PropertyMapSingle p v -> String
(Int -> PropertyMapSingle p v -> String -> String)
-> (PropertyMapSingle p v -> String)
-> ([PropertyMapSingle p v] -> String -> String)
-> Show (PropertyMapSingle p v)
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapSingle p v -> String -> String
forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapSingle p v] -> String -> String
forall (p :: * -> *) v.
Show (p v) =>
PropertyMapSingle p v -> String
showList :: [PropertyMapSingle p v] -> String -> String
$cshowList :: forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapSingle p v] -> String -> String
show :: PropertyMapSingle p v -> String
$cshow :: forall (p :: * -> *) v.
Show (p v) =>
PropertyMapSingle p v -> String
showsPrec :: Int -> PropertyMapSingle p v -> String -> String
$cshowsPrec :: forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapSingle p v -> String -> String
Show,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
/= :: 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
Eq,b -> PropertyMapSingle p v -> PropertyMapSingle p v
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
stimes :: b -> PropertyMapSingle p v -> PropertyMapSingle p v
$cstimes :: forall (p :: * -> *) v b.
Integral b =>
b -> PropertyMapSingle p v -> PropertyMapSingle p v
sconcat :: NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v
$csconcat :: forall (p :: * -> *) v.
NonEmpty (PropertyMapSingle p v) -> PropertyMapSingle p v
<> :: PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
$c<> :: forall (p :: * -> *) v.
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
Semigroup,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
mconcat :: [PropertyMapSingle p v] -> PropertyMapSingle p v
$cmconcat :: forall (p :: * -> *) v.
[PropertyMapSingle p v] -> PropertyMapSingle p v
mappend :: PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
$cmappend :: forall (p :: * -> *) v.
PropertyMapSingle p v
-> PropertyMapSingle p v -> PropertyMapSingle p v
mempty :: PropertyMapSingle p v
$cmempty :: forall (p :: * -> *) v. PropertyMapSingle p v
$cp1Monoid :: forall (p :: * -> *) v. Semigroup (PropertyMapSingle p v)
Monoid,a -> PropertyMapSingle p b -> PropertyMapSingle p a
(a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
(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
<$ :: a -> PropertyMapSingle p b -> PropertyMapSingle p a
$c<$ :: forall (p :: * -> *) a b.
Functor p =>
a -> PropertyMapSingle p b -> PropertyMapSingle p a
fmap :: (a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
$cfmap :: forall (p :: * -> *) a b.
Functor p =>
(a -> b) -> PropertyMapSingle p a -> PropertyMapSingle p b
Functor,a -> PropertyMapSingle p a -> Bool
PropertyMapSingle p m -> m
PropertyMapSingle p a -> [a]
PropertyMapSingle p a -> Bool
PropertyMapSingle p a -> Int
PropertyMapSingle p a -> a
PropertyMapSingle p a -> a
PropertyMapSingle p a -> a
PropertyMapSingle p a -> a
(a -> m) -> PropertyMapSingle p a -> m
(a -> m) -> PropertyMapSingle p a -> m
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
(a -> a -> a) -> PropertyMapSingle p a -> a
(a -> a -> a) -> PropertyMapSingle p a -> a
(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
product :: PropertyMapSingle p a -> a
$cproduct :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapSingle p a -> a
sum :: PropertyMapSingle p a -> a
$csum :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapSingle p a -> a
minimum :: PropertyMapSingle p a -> a
$cminimum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapSingle p a -> a
maximum :: PropertyMapSingle p a -> a
$cmaximum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapSingle p a -> a
elem :: a -> PropertyMapSingle p a -> Bool
$celem :: forall (p :: * -> *) a.
(Foldable p, Eq a) =>
a -> PropertyMapSingle p a -> Bool
length :: PropertyMapSingle p a -> Int
$clength :: forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> Int
null :: PropertyMapSingle p a -> Bool
$cnull :: forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> Bool
toList :: PropertyMapSingle p a -> [a]
$ctoList :: forall (p :: * -> *) a. Foldable p => PropertyMapSingle p a -> [a]
foldl1 :: (a -> a -> a) -> PropertyMapSingle p a -> a
$cfoldl1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapSingle p a -> a
foldr1 :: (a -> a -> a) -> PropertyMapSingle p a -> a
$cfoldr1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapSingle p a -> a
foldl' :: (b -> a -> b) -> b -> PropertyMapSingle p a -> b
$cfoldl' :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
foldl :: (b -> a -> b) -> b -> PropertyMapSingle p a -> b
$cfoldl :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapSingle p a -> b
foldr' :: (a -> b -> b) -> b -> PropertyMapSingle p a -> b
$cfoldr' :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
foldr :: (a -> b -> b) -> b -> PropertyMapSingle p a -> b
$cfoldr :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapSingle p a -> b
foldMap' :: (a -> m) -> PropertyMapSingle p a -> m
$cfoldMap' :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapSingle p a -> m
foldMap :: (a -> m) -> PropertyMapSingle p a -> m
$cfoldMap :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapSingle p a -> m
fold :: PropertyMapSingle p m -> m
$cfold :: forall (p :: * -> *) m.
(Foldable p, Monoid m) =>
PropertyMapSingle p m -> m
Foldable,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)
(a -> f b) -> PropertyMapSingle p a -> f (PropertyMapSingle p b)
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)
sequence :: PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)
$csequence :: forall (p :: * -> *) (m :: * -> *) a.
(Traversable p, Monad m) =>
PropertyMapSingle p (m a) -> m (PropertyMapSingle p a)
mapM :: (a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)
$cmapM :: forall (p :: * -> *) (m :: * -> *) a b.
(Traversable p, Monad m) =>
(a -> m b) -> PropertyMapSingle p a -> m (PropertyMapSingle p b)
sequenceA :: PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)
$csequenceA :: forall (p :: * -> *) (f :: * -> *) a.
(Traversable p, Applicative f) =>
PropertyMapSingle p (f a) -> f (PropertyMapSingle p a)
traverse :: (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)
$cp2Traversable :: forall (p :: * -> *).
Traversable p =>
Foldable (PropertyMapSingle p)
$cp1Traversable :: forall (p :: * -> *).
Traversable p =>
Functor (PropertyMapSingle p)
Traversable)

instance PropertyMap PropertyMapSingle where
  lookupOne :: 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 (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 :: 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 (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 (m :: (* -> *) -> * -> *) (p :: * -> *) v.
PropertyMap m =>
Text -> m p v -> Maybe (p v)
lookupOne Text
k PropertyMapSingle p v
m
  putProperty :: 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 :: 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 :: 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 (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 (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 (Int -> PropertyMapList p v -> String -> String
[PropertyMapList p v] -> String -> String
PropertyMapList p v -> String
(Int -> PropertyMapList p v -> String -> String)
-> (PropertyMapList p v -> String)
-> ([PropertyMapList p v] -> String -> String)
-> Show (PropertyMapList p v)
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapList p v -> String -> String
forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapList p v] -> String -> String
forall (p :: * -> *) v. Show (p v) => PropertyMapList p v -> String
showList :: [PropertyMapList p v] -> String -> String
$cshowList :: forall (p :: * -> *) v.
Show (p v) =>
[PropertyMapList p v] -> String -> String
show :: PropertyMapList p v -> String
$cshow :: forall (p :: * -> *) v. Show (p v) => PropertyMapList p v -> String
showsPrec :: Int -> PropertyMapList p v -> String -> String
$cshowsPrec :: forall (p :: * -> *) v.
Show (p v) =>
Int -> PropertyMapList p v -> String -> String
Show,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
/= :: 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
Eq,b -> PropertyMapList p v -> PropertyMapList p v
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
stimes :: b -> PropertyMapList p v -> PropertyMapList p v
$cstimes :: forall (p :: * -> *) v b.
Integral b =>
b -> PropertyMapList p v -> PropertyMapList p v
sconcat :: NonEmpty (PropertyMapList p v) -> PropertyMapList p v
$csconcat :: forall (p :: * -> *) v.
NonEmpty (PropertyMapList p v) -> PropertyMapList p v
<> :: PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
$c<> :: forall (p :: * -> *) v.
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
Semigroup,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
mconcat :: [PropertyMapList p v] -> PropertyMapList p v
$cmconcat :: forall (p :: * -> *) v.
[PropertyMapList p v] -> PropertyMapList p v
mappend :: PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
$cmappend :: forall (p :: * -> *) v.
PropertyMapList p v -> PropertyMapList p v -> PropertyMapList p v
mempty :: PropertyMapList p v
$cmempty :: forall (p :: * -> *) v. PropertyMapList p v
$cp1Monoid :: forall (p :: * -> *) v. Semigroup (PropertyMapList p v)
Monoid,a -> PropertyMapList p b -> PropertyMapList p a
(a -> b) -> PropertyMapList p a -> PropertyMapList p b
(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
<$ :: a -> PropertyMapList p b -> PropertyMapList p a
$c<$ :: forall (p :: * -> *) a b.
Functor p =>
a -> PropertyMapList p b -> PropertyMapList p a
fmap :: (a -> b) -> PropertyMapList p a -> PropertyMapList p b
$cfmap :: forall (p :: * -> *) a b.
Functor p =>
(a -> b) -> PropertyMapList p a -> PropertyMapList p b
Functor,a -> PropertyMapList p a -> Bool
PropertyMapList p m -> m
PropertyMapList p a -> [a]
PropertyMapList p a -> Bool
PropertyMapList p a -> Int
PropertyMapList p a -> a
PropertyMapList p a -> a
PropertyMapList p a -> a
PropertyMapList p a -> a
(a -> m) -> PropertyMapList p a -> m
(a -> m) -> PropertyMapList p a -> m
(a -> b -> b) -> b -> PropertyMapList p a -> b
(a -> b -> b) -> b -> PropertyMapList p a -> b
(b -> a -> b) -> b -> PropertyMapList p a -> b
(b -> a -> b) -> b -> PropertyMapList p a -> b
(a -> a -> a) -> PropertyMapList p a -> a
(a -> a -> a) -> PropertyMapList p a -> a
(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
product :: PropertyMapList p a -> a
$cproduct :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapList p a -> a
sum :: PropertyMapList p a -> a
$csum :: forall (p :: * -> *) a.
(Foldable p, Num a) =>
PropertyMapList p a -> a
minimum :: PropertyMapList p a -> a
$cminimum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapList p a -> a
maximum :: PropertyMapList p a -> a
$cmaximum :: forall (p :: * -> *) a.
(Foldable p, Ord a) =>
PropertyMapList p a -> a
elem :: a -> PropertyMapList p a -> Bool
$celem :: forall (p :: * -> *) a.
(Foldable p, Eq a) =>
a -> PropertyMapList p a -> Bool
length :: PropertyMapList p a -> Int
$clength :: forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> Int
null :: PropertyMapList p a -> Bool
$cnull :: forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> Bool
toList :: PropertyMapList p a -> [a]
$ctoList :: forall (p :: * -> *) a. Foldable p => PropertyMapList p a -> [a]
foldl1 :: (a -> a -> a) -> PropertyMapList p a -> a
$cfoldl1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapList p a -> a
foldr1 :: (a -> a -> a) -> PropertyMapList p a -> a
$cfoldr1 :: forall (p :: * -> *) a.
Foldable p =>
(a -> a -> a) -> PropertyMapList p a -> a
foldl' :: (b -> a -> b) -> b -> PropertyMapList p a -> b
$cfoldl' :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapList p a -> b
foldl :: (b -> a -> b) -> b -> PropertyMapList p a -> b
$cfoldl :: forall (p :: * -> *) b a.
Foldable p =>
(b -> a -> b) -> b -> PropertyMapList p a -> b
foldr' :: (a -> b -> b) -> b -> PropertyMapList p a -> b
$cfoldr' :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapList p a -> b
foldr :: (a -> b -> b) -> b -> PropertyMapList p a -> b
$cfoldr :: forall (p :: * -> *) a b.
Foldable p =>
(a -> b -> b) -> b -> PropertyMapList p a -> b
foldMap' :: (a -> m) -> PropertyMapList p a -> m
$cfoldMap' :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapList p a -> m
foldMap :: (a -> m) -> PropertyMapList p a -> m
$cfoldMap :: forall (p :: * -> *) m a.
(Foldable p, Monoid m) =>
(a -> m) -> PropertyMapList p a -> m
fold :: PropertyMapList p m -> m
$cfold :: forall (p :: * -> *) m.
(Foldable p, Monoid m) =>
PropertyMapList p m -> m
Foldable,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)
(a -> f b) -> PropertyMapList p a -> f (PropertyMapList p b)
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)
sequence :: PropertyMapList p (m a) -> m (PropertyMapList p a)
$csequence :: forall (p :: * -> *) (m :: * -> *) a.
(Traversable p, Monad m) =>
PropertyMapList p (m a) -> m (PropertyMapList p a)
mapM :: (a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)
$cmapM :: forall (p :: * -> *) (m :: * -> *) a b.
(Traversable p, Monad m) =>
(a -> m b) -> PropertyMapList p a -> m (PropertyMapList p b)
sequenceA :: PropertyMapList p (f a) -> f (PropertyMapList p a)
$csequenceA :: forall (p :: * -> *) (f :: * -> *) a.
(Traversable p, Applicative f) =>
PropertyMapList p (f a) -> f (PropertyMapList p a)
traverse :: (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)
$cp2Traversable :: forall (p :: * -> *). Traversable p => Foldable (PropertyMapList p)
$cp1Traversable :: forall (p :: * -> *). Traversable p => Functor (PropertyMapList p)
Traversable)

instance PropertyMap PropertyMapList where
  lookupList :: 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 :: 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 :: 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 :: 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 (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Parser Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
k
                 Parser (v -> AVertexProperty v)
-> Parser v -> Parser (AVertexProperty v)
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 (f :: * -> *) a. Alternative f => f a
empty