Safe Haskell | None |
---|
JSON utility functions.
- type JSField = (String, JSValue)
- type JSRecord = [JSField]
- readJSONWithDesc :: JSON a => String -> JSValue -> Result a
- fromJResult :: Monad m => String -> Result a -> m a
- fromJResultE :: (Error e, MonadError e m) => String -> Result a -> m a
- readEitherString :: Monad m => JSValue -> m String
- loadJSArray :: Monad m => String -> String -> m [JSObject JSValue]
- buildNoKeyError :: JSRecord -> String -> String
- fromObj :: (JSON a, Monad m) => JSRecord -> String -> m a
- maybeFromObj :: (JSON a, Monad m) => JSRecord -> String -> m (Maybe a)
- fromObjWithDefault :: (JSON a, Monad m) => JSRecord -> String -> a -> m a
- arrayMaybeFromJVal :: (JSON a, Monad m) => JSValue -> m [Maybe a]
- arrayMaybeFromObj :: (JSON a, Monad m) => JSRecord -> String -> m [Maybe a]
- tryArrayMaybeFromObj :: JSON a => String -> JSRecord -> String -> Result [Maybe a]
- fromKeyValue :: (JSON a, Monad m) => String -> JSValue -> m a
- fromJVal :: (Monad m, JSON a) => JSValue -> m a
- fromJValE :: (Error e, MonadError e m, JSON a) => JSValue -> m a
- jsonHead :: JSON b => [a] -> (a -> b) -> JSValue
- getMaybeJsonHead :: JSON b => [a] -> (a -> Maybe b) -> JSValue
- getMaybeJsonElem :: JSON b => [a] -> Int -> (a -> Maybe b) -> JSValue
- asJSObject :: Monad m => JSValue -> m (JSObject JSValue)
- asObjectList :: Monad m => [JSValue] -> m [JSObject JSValue]
- tryFromObj :: JSON a => String -> JSRecord -> String -> Result a
- toArray :: Monad m => JSValue -> m [JSValue]
- optionalJSField :: JSON a => String -> Maybe a -> Maybe JSField
- optFieldsToObj :: [Maybe JSField] -> JSValue
- class HasStringRepr a where
- fromStringRepr :: Monad m => String -> m a
- toStringRepr :: a -> String
- newtype GenericContainer a b = GenericContainer {
- fromContainer :: Map a b
- emptyContainer :: GenericContainer a b
- type Container = GenericContainer ByteString
- containerFromList :: Ord a => [(a, b)] -> GenericContainer a b
- lookupContainer :: (Monad m, Ord a) => m b -> a -> GenericContainer a b -> m b
- alterContainerL :: (Functor f, Ord a) => a -> (Maybe b -> f (Maybe b)) -> GenericContainer a b -> f (GenericContainer a b)
- readContainer :: (Monad m, HasStringRepr a, Ord a, JSON b) => JSObject JSValue -> m (GenericContainer a b)
- showContainer :: (HasStringRepr a, JSON b) => GenericContainer a b -> JSValue
- newtype UsedKeys = UsedKeys (Maybe (Set String))
- mkUsedKeys :: Set String -> UsedKeys
- allUsedKeys :: UsedKeys
- class DictObject a where
- toDict :: a -> [(String, JSValue)]
- fromDictWKeys :: [(String, JSValue)] -> WriterT UsedKeys Result a
- fromDict :: [(String, JSValue)] -> Result a
- showJSONtoDict :: DictObject a => a -> JSValue
- readJSONfromDict :: DictObject a => JSValue -> Result a
- class ArrayObject a where
- toJSArray :: a -> [JSValue]
- fromJSArray :: [JSValue] -> Result a
- newtype MaybeForJSON a = MaybeForJSON {
- unMaybeForJSON :: Maybe a
- newtype TimeAsDoubleJSON = TimeAsDoubleJSON {
- unTimeAsDoubleJSON :: ClockTime
- newtype Tuple5 a b c d e = Tuple5 {
- unTuple5 :: (a, b, c, d, e)
- nestedAccessByKey :: [String] -> JSValue -> Result JSValue
- nestedAccessByKeyDotted :: String -> JSValue -> Result JSValue
- branchOnField :: String -> (JSValue -> Result a) -> (JSValue -> Result a) -> JSValue -> Result a
- addField :: (String, JSValue) -> JSValue -> JSValue
- maybeParseMap :: JSON a => JSValue -> Maybe (Map String a)
JSON-related functions
:: JSON a | |
=> String | description of |
-> JSValue | input value |
-> Result a |
Annotate readJSON
error messages with descriptions of what
is being parsed into what.
fromJResult :: Monad m => String -> Result a -> m aSource
Converts a JSON Result into a monadic value.
fromJResultE :: (Error e, MonadError e m) => String -> Result a -> m aSource
Converts a JSON Result into a MonadError value.
readEitherString :: Monad m => JSValue -> m StringSource
Tries to read a string from a JSON value.
In case the value was not a string, we fail the read (in the context of the current monad.
:: Monad m | |
=> String | Operation description (for error reporting) |
-> String | Input message |
-> m [JSObject JSValue] |
Converts a JSON message into an array of JSON objects.
buildNoKeyError :: JSRecord -> String -> StringSource
fromObj :: (JSON a, Monad m) => JSRecord -> String -> m aSource
Reads the value of a key in a JSON object.
maybeFromObj :: (JSON a, Monad m) => JSRecord -> String -> m (Maybe a)Source
Reads the value of an optional key in a JSON object. Missing
keys, or keys that have a 'null' value, will be returned as
Nothing
, otherwise we attempt deserialisation and return a Just
value.
fromObjWithDefault :: (JSON a, Monad m) => JSRecord -> String -> a -> m aSource
Reads the value of a key in a JSON object with a default if missing. Note that both missing keys and keys with value 'null' will cause the default value to be returned.
arrayMaybeFromJVal :: (JSON a, Monad m) => JSValue -> m [Maybe a]Source
arrayMaybeFromObj :: (JSON a, Monad m) => JSRecord -> String -> m [Maybe a]Source
:: JSON a | |
=> String | Textual owner in error messages |
-> JSRecord | The object array |
-> String | The desired key from the object |
-> Result [Maybe a] |
Wrapper for arrayMaybeFromObj with better diagnostic
:: (JSON a, Monad m) | |
=> String | The key name |
-> JSValue | The value to read |
-> m a |
Reads a JValue, that originated from an object key.
fromJValE :: (Error e, MonadError e m, JSON a) => JSValue -> m aSource
Small wrapper over readJSON
for MonadError
.
jsonHead :: JSON b => [a] -> (a -> b) -> JSValueSource
Helper function that returns Null or first element of the list.
getMaybeJsonHead :: JSON b => [a] -> (a -> Maybe b) -> JSValueSource
Helper for extracting Maybe values from a possibly empty list.
getMaybeJsonElem :: JSON b => [a] -> Int -> (a -> Maybe b) -> JSValueSource
Helper for extracting Maybe values from a list that might be too short.
asJSObject :: Monad m => JSValue -> m (JSObject JSValue)Source
Converts a JSON value into a JSON object.
asObjectList :: Monad m => [JSValue] -> m [JSObject JSValue]Source
Coneverts a list of JSON values into a list of JSON objects.
:: JSON a | |
=> String | Textual owner in error messages |
-> JSRecord | The object array |
-> String | The desired key from the object |
-> Result a |
Try to extract a key from an object with better error reporting than fromObj.
optionalJSField :: JSON a => String -> Maybe a -> Maybe JSFieldSource
Creates a Maybe JSField. If the value string is Nothing, the JSField will be Nothing as well.
optFieldsToObj :: [Maybe JSField] -> JSValueSource
Creates an object with all the non-Nothing fields of the given list.
Container type (special type for JSON serialisation)
class HasStringRepr a whereSource
Class of types that can be converted from Strings. This is
similar to the Read
class, but it's using a different
serialisation format, so we have to define a separate class. Mostly
useful for custom key types in JSON dictionaries, which have to be
backed by strings.
fromStringRepr :: Monad m => String -> m aSource
toStringRepr :: a -> StringSource
HasStringRepr String | Trivial instance |
HasStringRepr ByteString | |
HasStringRepr DiskTemplate | |
HasStringRepr Hypervisor | |
HasStringRepr SSKey |
newtype GenericContainer a b Source
The container type, a wrapper over Data.Map
GenericContainer | |
|
Arbitrary OsParams | |
Arbitrary GroupDiskParams | No real arbitrary instance for |
Arbitrary IAllocatorParams | |
Arbitrary ClusterNicParams | |
Arbitrary ClusterOsParamsPrivate | |
Arbitrary ClusterOsParams | |
Arbitrary ClusterBeParams | |
Arbitrary OsHvParams | No real arbitrary instance for |
Arbitrary ClusterHvParams | No real arbitrary instance for |
Functor (GenericContainer a) | |
Foldable (GenericContainer a) | |
Traversable (GenericContainer a) | |
Arbitrary (Container DataCollectorConfig) | |
(Eq a, Eq b) => Eq (GenericContainer a b) | |
(Ord a, Ord b) => Ord (GenericContainer a b) | |
(Show a, Show b) => Show (GenericContainer a b) | |
(NFData a, NFData b) => NFData (GenericContainer a b) | |
(HasStringRepr a, Ord a, JSON b) => JSON (GenericContainer a b) |
emptyContainer :: GenericContainer a bSource
The empty container.
type Container = GenericContainer ByteStringSource
Type alias for string keys.
containerFromList :: Ord a => [(a, b)] -> GenericContainer a bSource
Creates a GenericContainer from a list of key-value pairs.
lookupContainer :: (Monad m, Ord a) => m b -> a -> GenericContainer a b -> m bSource
Looks up a value in a container with a default value.
If a key has no value, a given monadic default is returned.
This allows simple error handling, as the default can be
mzero
, failError
etc.
alterContainerL :: (Functor f, Ord a) => a -> (Maybe b -> f (Maybe b)) -> GenericContainer a b -> f (GenericContainer a b)Source
Updates a value inside a container. The signature of the function is crafted so that it can be directly used as a lens.
readContainer :: (Monad m, HasStringRepr a, Ord a, JSON b) => JSObject JSValue -> m (GenericContainer a b)Source
Container loader.
showContainer :: (HasStringRepr a, JSON b) => GenericContainer a b -> JSValueSource
Types that (de)serialize in a special form of JSON
mkUsedKeys :: Set String -> UsedKeysSource
class DictObject a whereSource
Class of objects that can be converted from and to JSObject
lists-format.
toDict :: a -> [(String, JSValue)]Source
fromDictWKeys :: [(String, JSValue)] -> WriterT UsedKeys Result aSource
showJSONtoDict :: DictObject a => a -> JSValueSource
A default implementation of showJSON
using toDict
.
readJSONfromDict :: DictObject a => JSValue -> Result aSource
class ArrayObject a whereSource
Class of objects that can be converted from and to [JSValue]
with
a fixed length and order.
toJSArray :: a -> [JSValue]Source
fromJSArray :: [JSValue] -> Result aSource
General purpose data types for working with JSON
newtype MaybeForJSON a Source
A Maybe newtype that allows for serialization more appropriate to the semantics of Maybe and JSON in our calls. Does not produce needless and confusing dictionaries.
In particular, JSNull
corresponds to Nothing
.
This also means that this `Maybe a` newtype should not be used with a
values that themselves can serialize to null
.
MaybeForJSON | |
|
Eq a => Eq (MaybeForJSON a) | |
Ord a => Ord (MaybeForJSON a) | |
Show a => Show (MaybeForJSON a) | |
Arbitrary a => Arbitrary (MaybeForJSON a) | |
JSON a => JSON (MaybeForJSON a) |
newtype TimeAsDoubleJSON Source
TimeAsDoubleJSON | |
|
Eq TimeAsDoubleJSON | |
Ord TimeAsDoubleJSON | |
Show TimeAsDoubleJSON | |
Arbitrary TimeAsDoubleJSON | |
JSON TimeAsDoubleJSON |
nestedAccessByKey :: [String] -> JSValue -> Result JSValueSource
nestedAccessByKeyDotted :: String -> JSValue -> Result JSValueSource
Same as nestedAccessByKey
, but accessing with a dotted string instead
(like nestedAccessByKeyDotted a.b.c
).
:: String | fieldname to branch on |
-> (JSValue -> Result a) | decoding function if field is present and |
-> (JSValue -> Result a) | decoding function otherwise |
-> JSValue | |
-> Result a |
Branch decoding on a field in a JSON object.
addField :: (String, JSValue) -> JSValue -> JSValueSource
Add a field to a JSON object; to nothing, if the argument is not an object.
maybeParseMap :: JSON a => JSValue -> Maybe (Map String a)Source
Maybe obtain a map from a JSON object.