module Bio.MMTF.Decode where

import           Bio.MMTF.Decode.Codec
import           Bio.MMTF.Decode.MessagePack
import           Bio.MMTF.Type

import           Control.Monad               ((>=>))
import           Data.ByteString.Lazy        (empty)
import           Data.Char                   (ord)
import           Data.Map.Strict             (Map)
import           Data.MessagePack            (Object)
import           Data.Text                   (Text, pack)
import           Data.Vector                 (Vector, fromList)

-- | Parses format data from ObjectMap
--
formatData :: MonadFail m => Map Text Object -> m FormatData
formatData :: forall (m :: * -> *).
MonadFail m =>
Map Text Object -> m FormatData
formatData Map Text Object
mp = do Text
v <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"mmtfVersion"  forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
                   Text
p <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"mmtfProducer" forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
                   forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> FormatData
FormatData Text
v Text
p

-- | Parses model data from ObjectMap
--
modelData :: MonadFail m => Map Text Object -> m ModelData
modelData :: forall (m :: * -> *). MonadFail m => Map Text Object -> m ModelData
modelData Map Text Object
mp = Vector Int32 -> ModelData
ModelData forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Vector a
l2v forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"chainsPerModel" forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList

-- | Parses chain data from ObjectMap
--
chainData :: MonadFail m => Map Text Object -> m ChainData
chainData :: forall (m :: * -> *). MonadFail m => Map Text Object -> m ChainData
chainData Map Text Object
mp = do [Int32]
gpc <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"groupsPerChain" forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList
                  [Text]
cil <- BinaryData -> [Text]
codec5 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"chainIdList"   forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary
                  [Text]
cnl <- BinaryData -> [Text]
codec5 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"chainNameList" forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector Int32 -> Vector Text -> Vector Text -> ChainData
ChainData (forall a. [a] -> Vector a
l2v [Int32]
gpc) (forall a. [a] -> Vector a
l2v [Text]
cil) (forall a. [a] -> Vector a
l2v [Text]
cnl)

-- | Parses atom data from ObjectMap
--
atomData :: MonadFail m => Map Text Object -> m AtomData
atomData :: forall (m :: * -> *). MonadFail m => Map Text Object -> m AtomData
atomData Map Text Object
mp = do [Int32]
ail' <-       BinaryData -> [Int32]
codec8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"atomIdList"    forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                 [Text]
all' <- [Char] -> [Text]
c2s forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinaryData -> [Char]
codec6 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"altLocList"    forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                 [Float]
bfl' <-      BinaryData -> [Float]
codec10 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"bFactorList"   forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                 [Float]
xcl' <-      BinaryData -> [Float]
codec10 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"xCoordList"    forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary
                 [Float]
ycl' <-      BinaryData -> [Float]
codec10 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"yCoordList"    forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary
                 [Float]
zcl' <-      BinaryData -> [Float]
codec10 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"zCoordList"    forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary
                 [Float]
ol' <-        BinaryData -> [Float]
codec9 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"occupancyList" forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                 forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector Int32
-> Vector Text
-> Vector Float
-> Vector Float
-> Vector Float
-> Vector Float
-> Vector Float
-> AtomData
AtomData (forall a. [a] -> Vector a
l2v [Int32]
ail') (forall a. [a] -> Vector a
l2v [Text]
all') (forall a. [a] -> Vector a
l2v [Float]
bfl') (forall a. [a] -> Vector a
l2v [Float]
xcl') (forall a. [a] -> Vector a
l2v [Float]
ycl') (forall a. [a] -> Vector a
l2v [Float]
zcl') (forall a. [a] -> Vector a
l2v [Float]
ol')

-- | Parses group data from ObjectMap
--
groupData :: MonadFail m => Map Text Object -> m GroupData
groupData :: forall (m :: * -> *). MonadFail m => Map Text Object -> m GroupData
groupData Map Text Object
mp = do [GroupType]
gl' <-                                        forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"groupList"          forall (m :: * -> *). MonadFail m => Text -> Object -> m [Object]
asObjectList forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (m :: * -> *). MonadFail m => Object -> m (Map Text Object)
transformObjectMap forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *). MonadFail m => Map Text Object -> m GroupType
groupType)
                  [Int32]
gtl' <-              BinaryData -> [Int32]
codec4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"groupTypeList"     forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary
                  [Int32]
gil' <-              BinaryData -> [Int32]
codec8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"groupIdList"       forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary
                  [SecondaryStructure]
ssl' <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int8 -> SecondaryStructure
ssDec forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinaryData -> [Int8]
codec2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"secStructList"     forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                  [Text]
icl' <-        [Char] -> [Text]
c2s forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinaryData -> [Char]
codec6 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"insCodeList"       forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                  [Int32]
sil' <-              BinaryData -> [Int32]
codec8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"sequenceIndexList" forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector GroupType
-> Vector Int32
-> Vector Int32
-> Vector SecondaryStructure
-> Vector Text
-> Vector Int32
-> GroupData
GroupData (forall a. [a] -> Vector a
l2v [GroupType]
gl') (forall a. [a] -> Vector a
l2v [Int32]
gtl') (forall a. [a] -> Vector a
l2v [Int32]
gil') (forall a. [a] -> Vector a
l2v [SecondaryStructure]
ssl') (forall a. [a] -> Vector a
l2v [Text]
icl') (forall a. [a] -> Vector a
l2v [Int32]
sil')

-- | Parses group type from ObjectMap
--
groupType :: MonadFail m => Map Text Object -> m GroupType
groupType :: forall (m :: * -> *). MonadFail m => Map Text Object -> m GroupType
groupType Map Text Object
mp = do [Int32]
fcl' <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"formalChargeList" forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList
                  [Text]
anl' <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"atomNameList"     forall (m :: * -> *). MonadFail m => Text -> Object -> m [Text]
asStrList
                  [Text]
el'  <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"elementList"      forall (m :: * -> *). MonadFail m => Text -> Object -> m [Text]
asStrList
                  [(Int32, Int32)]
bal' <- forall a. [a] -> [(a, a)]
l2pl forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"bondAtomList"     forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList
                  [Int32]
bol' <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"bondOrderList"    forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList
                  Text
gn'  <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"groupName"        forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
                  Char
slc' <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"singleLetterCode" forall (m :: * -> *). MonadFail m => Text -> Object -> m Char
asChar
                  Text
cct' <-          forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"chemCompType"     forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector Int32
-> Vector Text
-> Vector Text
-> Vector (Int32, Int32)
-> Vector Int32
-> Text
-> Char
-> Text
-> GroupType
GroupType (forall a. [a] -> Vector a
l2v [Int32]
fcl') (forall a. [a] -> Vector a
l2v [Text]
anl') (forall a. [a] -> Vector a
l2v [Text]
el') (forall a. [a] -> Vector a
l2v [(Int32, Int32)]
bal') (forall a. [a] -> Vector a
l2v [Int32]
bol') Text
gn' Char
slc' Text
cct'

-- | Parses structure data from ObjectMap
--
structureData :: MonadFail m => Map Text Object -> m StructureData
structureData :: forall (m :: * -> *).
MonadFail m =>
Map Text Object -> m StructureData
structureData Map Text Object
mp = do Text
ttl' <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"title"               forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr        Text
""
                      Text
sid' <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"structureId"         forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr        Text
""
                      Text
dd'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"depositionDate"      forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr        Text
""
                      Text
rd'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"releaseDate"         forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr        Text
""
                      Int32
nb'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"numBonds"            forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m a
asInt
                      Int32
na'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"numAtoms"            forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m a
asInt
                      Int32
ng'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"numGroups"           forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m a
asInt
                      Int32
nc'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"numChains"           forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m a
asInt
                      Int32
nm'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP   Map Text Object
mp Text
"numModels"           forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m a
asInt
                      Text
sg'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"spaceGroup"          forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr        Text
""
                      Maybe UnitCell
uc'  <-                  (forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). MonadFail m => [Float] -> m UnitCell
ucDec) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
Monad m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m (Maybe a)
atPM  Map Text Object
mp Text
"unitCell"            forall (m :: * -> *). MonadFail m => Text -> Object -> m [Float]
asFloatList
                      [M44]
nol' <-                       forall (m :: * -> *). MonadFail m => [Float] -> m M44
m44Dec forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"ncsOperatorList"     forall (m :: * -> *). MonadFail m => Text -> Object -> m [Float]
asFloatList []
                      [Assembly]
bal' <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"bioAssemblyList"     forall (m :: * -> *). MonadFail m => Text -> Object -> m [Object]
asObjectList [] forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (m :: * -> *). MonadFail m => Object -> m (Map Text Object)
transformObjectMap forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *). MonadFail m => Map Text Object -> m Assembly
bioAssembly)
                      [Entity]
el'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"entityList"          forall (m :: * -> *). MonadFail m => Text -> Object -> m [Object]
asObjectList [] forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (m :: * -> *). MonadFail m => Object -> m (Map Text Object)
transformObjectMap forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *). MonadFail m => Map Text Object -> m Entity
entity)
                      Maybe Float
res' <-                                  forall (m :: * -> *) a.
Monad m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m (Maybe a)
atPM  Map Text Object
mp Text
"resolution"          forall (m :: * -> *). MonadFail m => Text -> Object -> m Float
asFloat
                      Maybe Float
rf'  <-                                  forall (m :: * -> *) a.
Monad m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m (Maybe a)
atPM  Map Text Object
mp Text
"rFree"               forall (m :: * -> *). MonadFail m => Text -> Object -> m Float
asFloat
                      Maybe Float
rw'  <-                                  forall (m :: * -> *) a.
Monad m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m (Maybe a)
atPM  Map Text Object
mp Text
"rWork"               forall (m :: * -> *). MonadFail m => Text -> Object -> m Float
asFloat
                      [Text]
em'  <-                                  forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"experimentalMethods" forall (m :: * -> *). MonadFail m => Text -> Object -> m [Text]
asStrList []
                      [(Int32, Int32)]
btl' <-  forall a. [a] -> [(a, a)]
l2pl forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinaryData -> [Int32]
codec4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"bondAtomList"        forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                      [Int8]
bol' <-         BinaryData -> [Int8]
codec2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> BinaryData
parseBinary forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> a -> m a
atPMD Map Text Object
mp Text
"bondOrderList"       forall (m :: * -> *). MonadFail m => Text -> Object -> m ByteString
asBinary ByteString
empty
                      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text
-> Text
-> Text
-> Text
-> Int32
-> Int32
-> Int32
-> Int32
-> Int32
-> Text
-> Maybe UnitCell
-> Vector M44
-> Vector Assembly
-> Vector Entity
-> Maybe Float
-> Maybe Float
-> Maybe Float
-> Vector Text
-> Vector (Int32, Int32)
-> Vector Int8
-> StructureData
StructureData Text
ttl' Text
sid' Text
dd' Text
rd' Int32
nb' Int32
na'
                                          Int32
ng' Int32
nc' Int32
nm' Text
sg' Maybe UnitCell
uc' (forall a. [a] -> Vector a
l2v [M44]
nol')
                                           (forall a. [a] -> Vector a
l2v [Assembly]
bal') (forall a. [a] -> Vector a
l2v [Entity]
el') Maybe Float
res' Maybe Float
rf'
                                           Maybe Float
rw' (forall a. [a] -> Vector a
l2v [Text]
em') (forall a. [a] -> Vector a
l2v [(Int32, Int32)]
btl') (forall a. [a] -> Vector a
l2v [Int8]
bol')

-- | Parses bio assembly data from ObjectMap
--
bioAssembly :: MonadFail m => Map Text Object -> m Assembly
bioAssembly :: forall (m :: * -> *). MonadFail m => Map Text Object -> m Assembly
bioAssembly Map Text Object
mp = do Text
nme' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"name"          forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
                    [Transform]
tlt' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"transformList" forall (m :: * -> *). MonadFail m => Text -> Object -> m [Object]
asObjectList forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (m :: * -> *). MonadFail m => Object -> m (Map Text Object)
transformObjectMap forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall (m :: * -> *). MonadFail m => Map Text Object -> m Transform
transform)
                    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector Transform -> Text -> Assembly
Assembly (forall a. [a] -> Vector a
l2v [Transform]
tlt') Text
nme'

-- | Parses transform data from ObjectMap
--
transform :: MonadFail m => Map Text Object -> m Transform
transform :: forall (m :: * -> *). MonadFail m => Map Text Object -> m Transform
transform Map Text Object
mp = do [Int32]
cil' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"chainIndexList" forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList
                  M44
mtx' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"matrix"         forall (m :: * -> *). MonadFail m => Text -> Object -> m [Float]
asFloatList forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). MonadFail m => [Float] -> m M44
m44Dec
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector Int32 -> M44 -> Transform
Transform (forall a. [a] -> Vector a
l2v [Int32]
cil') M44
mtx'

-- | Parses entity data from ObjectMap
--
entity :: MonadFail m => Map Text Object -> m Entity
entity :: forall (m :: * -> *). MonadFail m => Map Text Object -> m Entity
entity Map Text Object
mp = do [Int32]
cil' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"chainIndexList" forall (m :: * -> *) a.
(MonadFail m, Integral a) =>
Text -> Object -> m [a]
asIntList
               Text
dsc' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"description"    forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
               Text
tpe' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"type"           forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
               Text
sqc' <- forall (m :: * -> *) a.
MonadFail m =>
Map Text Object -> Text -> (Text -> Object -> m a) -> m a
atP Map Text Object
mp Text
"sequence"       forall (m :: * -> *). MonadFail m => Text -> Object -> m Text
asStr
               forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Vector Int32 -> Text -> Text -> Text -> Entity
Entity (forall a. [a] -> Vector a
l2v [Int32]
cil') Text
dsc' Text
tpe' Text
sqc'

-- Helper functions

-- | Converts list of chars to list of one-sized
-- (or zero-sized in case of zero) strings
c2s :: [Char] -> [Text]
c2s :: [Char] -> [Text]
c2s [] = []
c2s (Char
x:[Char]
xs) | Char -> Int
ord Char
x forall a. Eq a => a -> a -> Bool
== Int
0 = Text
""forall a. a -> [a] -> [a]
:[Char] -> [Text]
c2s [Char]
xs
           | Bool
otherwise  = ([Char] -> Text
pack [Char
x])forall a. a -> [a] -> [a]
:[Char] -> [Text]
c2s [Char]
xs

-- | Converst list to an array
--
l2v :: [a] -> Vector a
l2v :: forall a. [a] -> Vector a
l2v = forall a. [a] -> Vector a
fromList

-- | List to list of pairs
--
l2pl :: [a] -> [(a, a)]
l2pl :: forall a. [a] -> [(a, a)]
l2pl []       = []
l2pl (a
x:a
y:[a]
xs) = (a
x,a
y) forall a. a -> [a] -> [a]
: forall a. [a] -> [(a, a)]
l2pl [a]
xs
l2pl [a]
_        = forall a. HasCallStack => [Char] -> a
error [Char]
"Cannot convert a list of odd length to a list of pairs"