{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE OverloadedStrings #-} {-# OPTIONS_GHC -fno-warn-missing-fields #-} {-# OPTIONS_GHC -fno-warn-missing-signatures #-} {-# OPTIONS_GHC -fno-warn-name-shadowing #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-unused-matches #-} ----------------------------------------------------------------- -- Autogenerated by Thrift Compiler (0.9.3) -- -- -- -- DO NOT EDIT UNLESS YOU ARE SURE YOU KNOW WHAT YOU ARE DOING -- ----------------------------------------------------------------- module Situations_Types where import Prelude (($), (.), (>>=), (==), (++)) import qualified Prelude as P import qualified Control.Exception as X import qualified Control.Monad as M ( liftM, ap, when ) import Data.Functor ( (<$>) ) import qualified Data.ByteString.Lazy as LBS import qualified Data.Hashable as H import qualified Data.Int as I import qualified Data.Maybe as M (catMaybes) import qualified Data.Text.Lazy.Encoding as E ( decodeUtf8, encodeUtf8 ) import qualified Data.Text.Lazy as LT import qualified GHC.Generics as G (Generic) import qualified Data.Typeable as TY ( Typeable ) import qualified Data.HashMap.Strict as Map import qualified Data.HashSet as Set import qualified Data.Vector as Vector import qualified Test.QuickCheck.Arbitrary as QC ( Arbitrary(..) ) import qualified Test.QuickCheck as QC ( elements ) import qualified Thrift as T import qualified Thrift.Types as T import qualified Thrift.Arbitraries as T import qualified Structure_Types import qualified Metadata_Types import qualified Uuid_Types import qualified Linking_Types data Property = Property { property_value :: LT.Text , property_metadata :: Metadata_Types.AnnotationMetadata , property_polarity :: P.Maybe P.Double } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable Property where hashWithSalt salt record = salt `H.hashWithSalt` property_value record `H.hashWithSalt` property_metadata record `H.hashWithSalt` property_polarity record instance QC.Arbitrary Property where arbitrary = M.liftM Property (QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_Property = [] | P.otherwise = M.catMaybes [ if obj == default_Property{property_value = property_value obj} then P.Nothing else P.Just $ default_Property{property_value = property_value obj} , if obj == default_Property{property_metadata = property_metadata obj} then P.Nothing else P.Just $ default_Property{property_metadata = property_metadata obj} , if obj == default_Property{property_polarity = property_polarity obj} then P.Nothing else P.Just $ default_Property{property_polarity = property_polarity obj} ] from_Property :: Property -> T.ThriftVal from_Property record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v2 -> P.Just (1, ("value",T.TString $ E.encodeUtf8 _v2))) $ property_value record , (\_v2 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v2))) $ property_metadata record , (\_v2 -> (3, ("polarity",T.TDouble _v2))) <$> property_polarity record ] write_Property :: (T.Protocol p, T.Transport t) => p t -> Property -> P.IO () write_Property oprot record = T.writeVal oprot $ from_Property record encode_Property :: (T.Protocol p, T.Transport t) => p t -> Property -> LBS.ByteString encode_Property oprot record = T.serializeVal oprot $ from_Property record to_Property :: T.ThriftVal -> Property to_Property (T.TStruct fields) = Property{ property_value = P.maybe (P.error "Missing required field: value") (\(_,_val4) -> (case _val4 of {T.TString _val5 -> E.decodeUtf8 _val5; _ -> P.error "wrong type"})) (Map.lookup (1) fields), property_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val4) -> (case _val4 of {T.TStruct _val6 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val6)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), property_polarity = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TDouble _val7 -> _val7; _ -> P.error "wrong type"})) (Map.lookup (3) fields) } to_Property _ = P.error "not a struct" read_Property :: (T.Transport t, T.Protocol p) => p t -> P.IO Property read_Property iprot = to_Property <$> T.readVal iprot (T.T_STRUCT typemap_Property) decode_Property :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Property decode_Property iprot bs = to_Property $ T.deserializeVal iprot (T.T_STRUCT typemap_Property) bs typemap_Property :: T.TypeMap typemap_Property = Map.fromList [(1,("value",T.T_STRING)),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("polarity",T.T_DOUBLE))] default_Property :: Property default_Property = Property{ property_value = "", property_metadata = Metadata_Types.default_AnnotationMetadata, property_polarity = P.Nothing} data Argument = Argument { argument_role :: P.Maybe LT.Text , argument_entityId :: P.Maybe Uuid_Types.UUID , argument_situationId :: P.Maybe Uuid_Types.UUID , argument_propertyList :: P.Maybe (Vector.Vector Property) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable Argument where hashWithSalt salt record = salt `H.hashWithSalt` argument_role record `H.hashWithSalt` argument_entityId record `H.hashWithSalt` argument_situationId record `H.hashWithSalt` argument_propertyList record instance QC.Arbitrary Argument where arbitrary = M.liftM Argument (M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_Argument = [] | P.otherwise = M.catMaybes [ if obj == default_Argument{argument_role = argument_role obj} then P.Nothing else P.Just $ default_Argument{argument_role = argument_role obj} , if obj == default_Argument{argument_entityId = argument_entityId obj} then P.Nothing else P.Just $ default_Argument{argument_entityId = argument_entityId obj} , if obj == default_Argument{argument_situationId = argument_situationId obj} then P.Nothing else P.Just $ default_Argument{argument_situationId = argument_situationId obj} , if obj == default_Argument{argument_propertyList = argument_propertyList obj} then P.Nothing else P.Just $ default_Argument{argument_propertyList = argument_propertyList obj} ] from_Argument :: Argument -> T.ThriftVal from_Argument record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v10 -> (1, ("role",T.TString $ E.encodeUtf8 _v10))) <$> argument_role record , (\_v10 -> (2, ("entityId",Uuid_Types.from_UUID _v10))) <$> argument_entityId record , (\_v10 -> (3, ("situationId",Uuid_Types.from_UUID _v10))) <$> argument_situationId record , (\_v10 -> (4, ("propertyList",T.TList (T.T_STRUCT typemap_Property) $ P.map (\_v12 -> from_Property _v12) $ Vector.toList _v10))) <$> argument_propertyList record ] write_Argument :: (T.Protocol p, T.Transport t) => p t -> Argument -> P.IO () write_Argument oprot record = T.writeVal oprot $ from_Argument record encode_Argument :: (T.Protocol p, T.Transport t) => p t -> Argument -> LBS.ByteString encode_Argument oprot record = T.serializeVal oprot $ from_Argument record to_Argument :: T.ThriftVal -> Argument to_Argument (T.TStruct fields) = Argument{ argument_role = P.maybe (P.Nothing) (\(_,_val14) -> P.Just (case _val14 of {T.TString _val15 -> E.decodeUtf8 _val15; _ -> P.error "wrong type"})) (Map.lookup (1) fields), argument_entityId = P.maybe (P.Nothing) (\(_,_val14) -> P.Just (case _val14 of {T.TStruct _val16 -> (Uuid_Types.to_UUID (T.TStruct _val16)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), argument_situationId = P.maybe (P.Nothing) (\(_,_val14) -> P.Just (case _val14 of {T.TStruct _val17 -> (Uuid_Types.to_UUID (T.TStruct _val17)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), argument_propertyList = P.maybe (P.Nothing) (\(_,_val14) -> P.Just (case _val14 of {T.TList _ _val18 -> (Vector.fromList $ P.map (\_v19 -> (case _v19 of {T.TStruct _val20 -> (to_Property (T.TStruct _val20)); _ -> P.error "wrong type"})) _val18); _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_Argument _ = P.error "not a struct" read_Argument :: (T.Transport t, T.Protocol p) => p t -> P.IO Argument read_Argument iprot = to_Argument <$> T.readVal iprot (T.T_STRUCT typemap_Argument) decode_Argument :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Argument decode_Argument iprot bs = to_Argument $ T.deserializeVal iprot (T.T_STRUCT typemap_Argument) bs typemap_Argument :: T.TypeMap typemap_Argument = Map.fromList [(1,("role",T.T_STRING)),(2,("entityId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(3,("situationId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("propertyList",(T.T_LIST (T.T_STRUCT typemap_Property))))] default_Argument :: Argument default_Argument = Argument{ argument_role = P.Nothing, argument_entityId = P.Nothing, argument_situationId = P.Nothing, argument_propertyList = P.Nothing} data Justification = Justification { justification_justificationType :: P.Maybe LT.Text , justification_mentionId :: Uuid_Types.UUID , justification_tokenRefSeqList :: P.Maybe (Vector.Vector Structure_Types.TokenRefSequence) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable Justification where hashWithSalt salt record = salt `H.hashWithSalt` justification_justificationType record `H.hashWithSalt` justification_mentionId record `H.hashWithSalt` justification_tokenRefSeqList record instance QC.Arbitrary Justification where arbitrary = M.liftM Justification (M.liftM P.Just QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_Justification = [] | P.otherwise = M.catMaybes [ if obj == default_Justification{justification_justificationType = justification_justificationType obj} then P.Nothing else P.Just $ default_Justification{justification_justificationType = justification_justificationType obj} , if obj == default_Justification{justification_mentionId = justification_mentionId obj} then P.Nothing else P.Just $ default_Justification{justification_mentionId = justification_mentionId obj} , if obj == default_Justification{justification_tokenRefSeqList = justification_tokenRefSeqList obj} then P.Nothing else P.Just $ default_Justification{justification_tokenRefSeqList = justification_tokenRefSeqList obj} ] from_Justification :: Justification -> T.ThriftVal from_Justification record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v23 -> (1, ("justificationType",T.TString $ E.encodeUtf8 _v23))) <$> justification_justificationType record , (\_v23 -> P.Just (2, ("mentionId",Uuid_Types.from_UUID _v23))) $ justification_mentionId record , (\_v23 -> (3, ("tokenRefSeqList",T.TList (T.T_STRUCT Structure_Types.typemap_TokenRefSequence) $ P.map (\_v25 -> Structure_Types.from_TokenRefSequence _v25) $ Vector.toList _v23))) <$> justification_tokenRefSeqList record ] write_Justification :: (T.Protocol p, T.Transport t) => p t -> Justification -> P.IO () write_Justification oprot record = T.writeVal oprot $ from_Justification record encode_Justification :: (T.Protocol p, T.Transport t) => p t -> Justification -> LBS.ByteString encode_Justification oprot record = T.serializeVal oprot $ from_Justification record to_Justification :: T.ThriftVal -> Justification to_Justification (T.TStruct fields) = Justification{ justification_justificationType = P.maybe (P.Nothing) (\(_,_val27) -> P.Just (case _val27 of {T.TString _val28 -> E.decodeUtf8 _val28; _ -> P.error "wrong type"})) (Map.lookup (1) fields), justification_mentionId = P.maybe (P.error "Missing required field: mentionId") (\(_,_val27) -> (case _val27 of {T.TStruct _val29 -> (Uuid_Types.to_UUID (T.TStruct _val29)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), justification_tokenRefSeqList = P.maybe (P.Nothing) (\(_,_val27) -> P.Just (case _val27 of {T.TList _ _val30 -> (Vector.fromList $ P.map (\_v31 -> (case _v31 of {T.TStruct _val32 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val32)); _ -> P.error "wrong type"})) _val30); _ -> P.error "wrong type"})) (Map.lookup (3) fields) } to_Justification _ = P.error "not a struct" read_Justification :: (T.Transport t, T.Protocol p) => p t -> P.IO Justification read_Justification iprot = to_Justification <$> T.readVal iprot (T.T_STRUCT typemap_Justification) decode_Justification :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Justification decode_Justification iprot bs = to_Justification $ T.deserializeVal iprot (T.T_STRUCT typemap_Justification) bs typemap_Justification :: T.TypeMap typemap_Justification = Map.fromList [(1,("justificationType",T.T_STRING)),(2,("mentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(3,("tokenRefSeqList",(T.T_LIST (T.T_STRUCT Structure_Types.typemap_TokenRefSequence))))] default_Justification :: Justification default_Justification = Justification{ justification_justificationType = P.Nothing, justification_mentionId = Uuid_Types.default_UUID, justification_tokenRefSeqList = P.Nothing} data TimeML = TimeML { timeML_timeMLClass :: P.Maybe LT.Text , timeML_timeMLTense :: P.Maybe LT.Text , timeML_timeMLAspect :: P.Maybe LT.Text } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable TimeML where hashWithSalt salt record = salt `H.hashWithSalt` timeML_timeMLClass record `H.hashWithSalt` timeML_timeMLTense record `H.hashWithSalt` timeML_timeMLAspect record instance QC.Arbitrary TimeML where arbitrary = M.liftM TimeML (M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_TimeML = [] | P.otherwise = M.catMaybes [ if obj == default_TimeML{timeML_timeMLClass = timeML_timeMLClass obj} then P.Nothing else P.Just $ default_TimeML{timeML_timeMLClass = timeML_timeMLClass obj} , if obj == default_TimeML{timeML_timeMLTense = timeML_timeMLTense obj} then P.Nothing else P.Just $ default_TimeML{timeML_timeMLTense = timeML_timeMLTense obj} , if obj == default_TimeML{timeML_timeMLAspect = timeML_timeMLAspect obj} then P.Nothing else P.Just $ default_TimeML{timeML_timeMLAspect = timeML_timeMLAspect obj} ] from_TimeML :: TimeML -> T.ThriftVal from_TimeML record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v35 -> (1, ("timeMLClass",T.TString $ E.encodeUtf8 _v35))) <$> timeML_timeMLClass record , (\_v35 -> (2, ("timeMLTense",T.TString $ E.encodeUtf8 _v35))) <$> timeML_timeMLTense record , (\_v35 -> (3, ("timeMLAspect",T.TString $ E.encodeUtf8 _v35))) <$> timeML_timeMLAspect record ] write_TimeML :: (T.Protocol p, T.Transport t) => p t -> TimeML -> P.IO () write_TimeML oprot record = T.writeVal oprot $ from_TimeML record encode_TimeML :: (T.Protocol p, T.Transport t) => p t -> TimeML -> LBS.ByteString encode_TimeML oprot record = T.serializeVal oprot $ from_TimeML record to_TimeML :: T.ThriftVal -> TimeML to_TimeML (T.TStruct fields) = TimeML{ timeML_timeMLClass = P.maybe (P.Nothing) (\(_,_val37) -> P.Just (case _val37 of {T.TString _val38 -> E.decodeUtf8 _val38; _ -> P.error "wrong type"})) (Map.lookup (1) fields), timeML_timeMLTense = P.maybe (P.Nothing) (\(_,_val37) -> P.Just (case _val37 of {T.TString _val39 -> E.decodeUtf8 _val39; _ -> P.error "wrong type"})) (Map.lookup (2) fields), timeML_timeMLAspect = P.maybe (P.Nothing) (\(_,_val37) -> P.Just (case _val37 of {T.TString _val40 -> E.decodeUtf8 _val40; _ -> P.error "wrong type"})) (Map.lookup (3) fields) } to_TimeML _ = P.error "not a struct" read_TimeML :: (T.Transport t, T.Protocol p) => p t -> P.IO TimeML read_TimeML iprot = to_TimeML <$> T.readVal iprot (T.T_STRUCT typemap_TimeML) decode_TimeML :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TimeML decode_TimeML iprot bs = to_TimeML $ T.deserializeVal iprot (T.T_STRUCT typemap_TimeML) bs typemap_TimeML :: T.TypeMap typemap_TimeML = Map.fromList [(1,("timeMLClass",T.T_STRING)),(2,("timeMLTense",T.T_STRING)),(3,("timeMLAspect",T.T_STRING))] default_TimeML :: TimeML default_TimeML = TimeML{ timeML_timeMLClass = P.Nothing, timeML_timeMLTense = P.Nothing, timeML_timeMLAspect = P.Nothing} data Situation = Situation { situation_uuid :: Uuid_Types.UUID , situation_situationType :: LT.Text , situation_situationKind :: P.Maybe LT.Text , situation_argumentList :: P.Maybe (Vector.Vector Argument) , situation_mentionIdList :: P.Maybe (Vector.Vector Uuid_Types.UUID) , situation_justificationList :: P.Maybe (Vector.Vector Justification) , situation_timeML :: P.Maybe TimeML , situation_intensity :: P.Maybe P.Double , situation_polarity :: P.Maybe LT.Text , situation_confidence :: P.Maybe P.Double } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable Situation where hashWithSalt salt record = salt `H.hashWithSalt` situation_uuid record `H.hashWithSalt` situation_situationType record `H.hashWithSalt` situation_situationKind record `H.hashWithSalt` situation_argumentList record `H.hashWithSalt` situation_mentionIdList record `H.hashWithSalt` situation_justificationList record `H.hashWithSalt` situation_timeML record `H.hashWithSalt` situation_intensity record `H.hashWithSalt` situation_polarity record `H.hashWithSalt` situation_confidence record instance QC.Arbitrary Situation where arbitrary = M.liftM Situation (QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_Situation = [] | P.otherwise = M.catMaybes [ if obj == default_Situation{situation_uuid = situation_uuid obj} then P.Nothing else P.Just $ default_Situation{situation_uuid = situation_uuid obj} , if obj == default_Situation{situation_situationType = situation_situationType obj} then P.Nothing else P.Just $ default_Situation{situation_situationType = situation_situationType obj} , if obj == default_Situation{situation_situationKind = situation_situationKind obj} then P.Nothing else P.Just $ default_Situation{situation_situationKind = situation_situationKind obj} , if obj == default_Situation{situation_argumentList = situation_argumentList obj} then P.Nothing else P.Just $ default_Situation{situation_argumentList = situation_argumentList obj} , if obj == default_Situation{situation_mentionIdList = situation_mentionIdList obj} then P.Nothing else P.Just $ default_Situation{situation_mentionIdList = situation_mentionIdList obj} , if obj == default_Situation{situation_justificationList = situation_justificationList obj} then P.Nothing else P.Just $ default_Situation{situation_justificationList = situation_justificationList obj} , if obj == default_Situation{situation_timeML = situation_timeML obj} then P.Nothing else P.Just $ default_Situation{situation_timeML = situation_timeML obj} , if obj == default_Situation{situation_intensity = situation_intensity obj} then P.Nothing else P.Just $ default_Situation{situation_intensity = situation_intensity obj} , if obj == default_Situation{situation_polarity = situation_polarity obj} then P.Nothing else P.Just $ default_Situation{situation_polarity = situation_polarity obj} , if obj == default_Situation{situation_confidence = situation_confidence obj} then P.Nothing else P.Just $ default_Situation{situation_confidence = situation_confidence obj} ] from_Situation :: Situation -> T.ThriftVal from_Situation record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v43 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v43))) $ situation_uuid record , (\_v43 -> P.Just (2, ("situationType",T.TString $ E.encodeUtf8 _v43))) $ situation_situationType record , (\_v43 -> (3, ("argumentList",T.TList (T.T_STRUCT typemap_Argument) $ P.map (\_v45 -> from_Argument _v45) $ Vector.toList _v43))) <$> situation_argumentList record , (\_v43 -> (4, ("mentionIdList",T.TList (T.T_STRUCT Uuid_Types.typemap_UUID) $ P.map (\_v47 -> Uuid_Types.from_UUID _v47) $ Vector.toList _v43))) <$> situation_mentionIdList record , (\_v43 -> (5, ("justificationList",T.TList (T.T_STRUCT typemap_Justification) $ P.map (\_v49 -> from_Justification _v49) $ Vector.toList _v43))) <$> situation_justificationList record , (\_v43 -> (50, ("situationKind",T.TString $ E.encodeUtf8 _v43))) <$> situation_situationKind record , (\_v43 -> (54, ("timeML",from_TimeML _v43))) <$> situation_timeML record , (\_v43 -> (100, ("intensity",T.TDouble _v43))) <$> situation_intensity record , (\_v43 -> (101, ("polarity",T.TString $ E.encodeUtf8 _v43))) <$> situation_polarity record , (\_v43 -> (200, ("confidence",T.TDouble _v43))) <$> situation_confidence record ] write_Situation :: (T.Protocol p, T.Transport t) => p t -> Situation -> P.IO () write_Situation oprot record = T.writeVal oprot $ from_Situation record encode_Situation :: (T.Protocol p, T.Transport t) => p t -> Situation -> LBS.ByteString encode_Situation oprot record = T.serializeVal oprot $ from_Situation record to_Situation :: T.ThriftVal -> Situation to_Situation (T.TStruct fields) = Situation{ situation_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val51) -> (case _val51 of {T.TStruct _val52 -> (Uuid_Types.to_UUID (T.TStruct _val52)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), situation_situationType = P.maybe (P.error "Missing required field: situationType") (\(_,_val51) -> (case _val51 of {T.TString _val53 -> E.decodeUtf8 _val53; _ -> P.error "wrong type"})) (Map.lookup (2) fields), situation_situationKind = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TString _val54 -> E.decodeUtf8 _val54; _ -> P.error "wrong type"})) (Map.lookup (50) fields), situation_argumentList = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TList _ _val55 -> (Vector.fromList $ P.map (\_v56 -> (case _v56 of {T.TStruct _val57 -> (to_Argument (T.TStruct _val57)); _ -> P.error "wrong type"})) _val55); _ -> P.error "wrong type"})) (Map.lookup (3) fields), situation_mentionIdList = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TList _ _val58 -> (Vector.fromList $ P.map (\_v59 -> (case _v59 of {T.TStruct _val60 -> (Uuid_Types.to_UUID (T.TStruct _val60)); _ -> P.error "wrong type"})) _val58); _ -> P.error "wrong type"})) (Map.lookup (4) fields), situation_justificationList = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TList _ _val61 -> (Vector.fromList $ P.map (\_v62 -> (case _v62 of {T.TStruct _val63 -> (to_Justification (T.TStruct _val63)); _ -> P.error "wrong type"})) _val61); _ -> P.error "wrong type"})) (Map.lookup (5) fields), situation_timeML = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TStruct _val64 -> (to_TimeML (T.TStruct _val64)); _ -> P.error "wrong type"})) (Map.lookup (54) fields), situation_intensity = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TDouble _val65 -> _val65; _ -> P.error "wrong type"})) (Map.lookup (100) fields), situation_polarity = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TString _val66 -> E.decodeUtf8 _val66; _ -> P.error "wrong type"})) (Map.lookup (101) fields), situation_confidence = P.maybe (P.Nothing) (\(_,_val51) -> P.Just (case _val51 of {T.TDouble _val67 -> _val67; _ -> P.error "wrong type"})) (Map.lookup (200) fields) } to_Situation _ = P.error "not a struct" read_Situation :: (T.Transport t, T.Protocol p) => p t -> P.IO Situation read_Situation iprot = to_Situation <$> T.readVal iprot (T.T_STRUCT typemap_Situation) decode_Situation :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Situation decode_Situation iprot bs = to_Situation $ T.deserializeVal iprot (T.T_STRUCT typemap_Situation) bs typemap_Situation :: T.TypeMap typemap_Situation = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("situationType",T.T_STRING)),(3,("argumentList",(T.T_LIST (T.T_STRUCT typemap_Argument)))),(4,("mentionIdList",(T.T_LIST (T.T_STRUCT Uuid_Types.typemap_UUID)))),(5,("justificationList",(T.T_LIST (T.T_STRUCT typemap_Justification)))),(50,("situationKind",T.T_STRING)),(54,("timeML",(T.T_STRUCT typemap_TimeML))),(100,("intensity",T.T_DOUBLE)),(101,("polarity",T.T_STRING)),(200,("confidence",T.T_DOUBLE))] default_Situation :: Situation default_Situation = Situation{ situation_uuid = Uuid_Types.default_UUID, situation_situationType = "", situation_argumentList = P.Nothing, situation_mentionIdList = P.Nothing, situation_justificationList = P.Nothing, situation_situationKind = P.Nothing, situation_timeML = P.Nothing, situation_intensity = P.Nothing, situation_polarity = P.Nothing, situation_confidence = P.Nothing} data SituationSet = SituationSet { situationSet_uuid :: Uuid_Types.UUID , situationSet_metadata :: Metadata_Types.AnnotationMetadata , situationSet_situationList :: (Vector.Vector Situation) , situationSet_linkingList :: P.Maybe (Vector.Vector Linking_Types.Linking) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable SituationSet where hashWithSalt salt record = salt `H.hashWithSalt` situationSet_uuid record `H.hashWithSalt` situationSet_metadata record `H.hashWithSalt` situationSet_situationList record `H.hashWithSalt` situationSet_linkingList record instance QC.Arbitrary SituationSet where arbitrary = M.liftM SituationSet (QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_SituationSet = [] | P.otherwise = M.catMaybes [ if obj == default_SituationSet{situationSet_uuid = situationSet_uuid obj} then P.Nothing else P.Just $ default_SituationSet{situationSet_uuid = situationSet_uuid obj} , if obj == default_SituationSet{situationSet_metadata = situationSet_metadata obj} then P.Nothing else P.Just $ default_SituationSet{situationSet_metadata = situationSet_metadata obj} , if obj == default_SituationSet{situationSet_situationList = situationSet_situationList obj} then P.Nothing else P.Just $ default_SituationSet{situationSet_situationList = situationSet_situationList obj} , if obj == default_SituationSet{situationSet_linkingList = situationSet_linkingList obj} then P.Nothing else P.Just $ default_SituationSet{situationSet_linkingList = situationSet_linkingList obj} ] from_SituationSet :: SituationSet -> T.ThriftVal from_SituationSet record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v70 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v70))) $ situationSet_uuid record , (\_v70 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v70))) $ situationSet_metadata record , (\_v70 -> P.Just (3, ("situationList",T.TList (T.T_STRUCT typemap_Situation) $ P.map (\_v72 -> from_Situation _v72) $ Vector.toList _v70))) $ situationSet_situationList record , (\_v70 -> (4, ("linkingList",T.TList (T.T_STRUCT Linking_Types.typemap_Linking) $ P.map (\_v74 -> Linking_Types.from_Linking _v74) $ Vector.toList _v70))) <$> situationSet_linkingList record ] write_SituationSet :: (T.Protocol p, T.Transport t) => p t -> SituationSet -> P.IO () write_SituationSet oprot record = T.writeVal oprot $ from_SituationSet record encode_SituationSet :: (T.Protocol p, T.Transport t) => p t -> SituationSet -> LBS.ByteString encode_SituationSet oprot record = T.serializeVal oprot $ from_SituationSet record to_SituationSet :: T.ThriftVal -> SituationSet to_SituationSet (T.TStruct fields) = SituationSet{ situationSet_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val76) -> (case _val76 of {T.TStruct _val77 -> (Uuid_Types.to_UUID (T.TStruct _val77)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), situationSet_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val76) -> (case _val76 of {T.TStruct _val78 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val78)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), situationSet_situationList = P.maybe (P.error "Missing required field: situationList") (\(_,_val76) -> (case _val76 of {T.TList _ _val79 -> (Vector.fromList $ P.map (\_v80 -> (case _v80 of {T.TStruct _val81 -> (to_Situation (T.TStruct _val81)); _ -> P.error "wrong type"})) _val79); _ -> P.error "wrong type"})) (Map.lookup (3) fields), situationSet_linkingList = P.maybe (P.Nothing) (\(_,_val76) -> P.Just (case _val76 of {T.TList _ _val82 -> (Vector.fromList $ P.map (\_v83 -> (case _v83 of {T.TStruct _val84 -> (Linking_Types.to_Linking (T.TStruct _val84)); _ -> P.error "wrong type"})) _val82); _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_SituationSet _ = P.error "not a struct" read_SituationSet :: (T.Transport t, T.Protocol p) => p t -> P.IO SituationSet read_SituationSet iprot = to_SituationSet <$> T.readVal iprot (T.T_STRUCT typemap_SituationSet) decode_SituationSet :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> SituationSet decode_SituationSet iprot bs = to_SituationSet $ T.deserializeVal iprot (T.T_STRUCT typemap_SituationSet) bs typemap_SituationSet :: T.TypeMap typemap_SituationSet = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("situationList",(T.T_LIST (T.T_STRUCT typemap_Situation)))),(4,("linkingList",(T.T_LIST (T.T_STRUCT Linking_Types.typemap_Linking))))] default_SituationSet :: SituationSet default_SituationSet = SituationSet{ situationSet_uuid = Uuid_Types.default_UUID, situationSet_metadata = Metadata_Types.default_AnnotationMetadata, situationSet_situationList = Vector.empty, situationSet_linkingList = P.Nothing} data MentionArgument = MentionArgument { mentionArgument_role :: P.Maybe LT.Text , mentionArgument_entityMentionId :: P.Maybe Uuid_Types.UUID , mentionArgument_situationMentionId :: P.Maybe Uuid_Types.UUID , mentionArgument_tokens :: P.Maybe Structure_Types.TokenRefSequence , mentionArgument_constituent :: P.Maybe Structure_Types.ConstituentRef , mentionArgument_confidence :: P.Maybe P.Double , mentionArgument_propertyList :: P.Maybe (Vector.Vector Property) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable MentionArgument where hashWithSalt salt record = salt `H.hashWithSalt` mentionArgument_role record `H.hashWithSalt` mentionArgument_entityMentionId record `H.hashWithSalt` mentionArgument_situationMentionId record `H.hashWithSalt` mentionArgument_tokens record `H.hashWithSalt` mentionArgument_constituent record `H.hashWithSalt` mentionArgument_confidence record `H.hashWithSalt` mentionArgument_propertyList record instance QC.Arbitrary MentionArgument where arbitrary = M.liftM MentionArgument (M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_MentionArgument = [] | P.otherwise = M.catMaybes [ if obj == default_MentionArgument{mentionArgument_role = mentionArgument_role obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_role = mentionArgument_role obj} , if obj == default_MentionArgument{mentionArgument_entityMentionId = mentionArgument_entityMentionId obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_entityMentionId = mentionArgument_entityMentionId obj} , if obj == default_MentionArgument{mentionArgument_situationMentionId = mentionArgument_situationMentionId obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_situationMentionId = mentionArgument_situationMentionId obj} , if obj == default_MentionArgument{mentionArgument_tokens = mentionArgument_tokens obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_tokens = mentionArgument_tokens obj} , if obj == default_MentionArgument{mentionArgument_constituent = mentionArgument_constituent obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_constituent = mentionArgument_constituent obj} , if obj == default_MentionArgument{mentionArgument_confidence = mentionArgument_confidence obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_confidence = mentionArgument_confidence obj} , if obj == default_MentionArgument{mentionArgument_propertyList = mentionArgument_propertyList obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_propertyList = mentionArgument_propertyList obj} ] from_MentionArgument :: MentionArgument -> T.ThriftVal from_MentionArgument record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v87 -> (1, ("role",T.TString $ E.encodeUtf8 _v87))) <$> mentionArgument_role record , (\_v87 -> (2, ("entityMentionId",Uuid_Types.from_UUID _v87))) <$> mentionArgument_entityMentionId record , (\_v87 -> (3, ("situationMentionId",Uuid_Types.from_UUID _v87))) <$> mentionArgument_situationMentionId record , (\_v87 -> (4, ("tokens",Structure_Types.from_TokenRefSequence _v87))) <$> mentionArgument_tokens record , (\_v87 -> (5, ("confidence",T.TDouble _v87))) <$> mentionArgument_confidence record , (\_v87 -> (6, ("propertyList",T.TList (T.T_STRUCT typemap_Property) $ P.map (\_v89 -> from_Property _v89) $ Vector.toList _v87))) <$> mentionArgument_propertyList record , (\_v87 -> (7, ("constituent",Structure_Types.from_ConstituentRef _v87))) <$> mentionArgument_constituent record ] write_MentionArgument :: (T.Protocol p, T.Transport t) => p t -> MentionArgument -> P.IO () write_MentionArgument oprot record = T.writeVal oprot $ from_MentionArgument record encode_MentionArgument :: (T.Protocol p, T.Transport t) => p t -> MentionArgument -> LBS.ByteString encode_MentionArgument oprot record = T.serializeVal oprot $ from_MentionArgument record to_MentionArgument :: T.ThriftVal -> MentionArgument to_MentionArgument (T.TStruct fields) = MentionArgument{ mentionArgument_role = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TString _val92 -> E.decodeUtf8 _val92; _ -> P.error "wrong type"})) (Map.lookup (1) fields), mentionArgument_entityMentionId = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val93 -> (Uuid_Types.to_UUID (T.TStruct _val93)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), mentionArgument_situationMentionId = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val94 -> (Uuid_Types.to_UUID (T.TStruct _val94)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), mentionArgument_tokens = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val95 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val95)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), mentionArgument_constituent = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val96 -> (Structure_Types.to_ConstituentRef (T.TStruct _val96)); _ -> P.error "wrong type"})) (Map.lookup (7) fields), mentionArgument_confidence = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TDouble _val97 -> _val97; _ -> P.error "wrong type"})) (Map.lookup (5) fields), mentionArgument_propertyList = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TList _ _val98 -> (Vector.fromList $ P.map (\_v99 -> (case _v99 of {T.TStruct _val100 -> (to_Property (T.TStruct _val100)); _ -> P.error "wrong type"})) _val98); _ -> P.error "wrong type"})) (Map.lookup (6) fields) } to_MentionArgument _ = P.error "not a struct" read_MentionArgument :: (T.Transport t, T.Protocol p) => p t -> P.IO MentionArgument read_MentionArgument iprot = to_MentionArgument <$> T.readVal iprot (T.T_STRUCT typemap_MentionArgument) decode_MentionArgument :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> MentionArgument decode_MentionArgument iprot bs = to_MentionArgument $ T.deserializeVal iprot (T.T_STRUCT typemap_MentionArgument) bs typemap_MentionArgument :: T.TypeMap typemap_MentionArgument = Map.fromList [(1,("role",T.T_STRING)),(2,("entityMentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(3,("situationMentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("tokens",(T.T_STRUCT Structure_Types.typemap_TokenRefSequence))),(5,("confidence",T.T_DOUBLE)),(6,("propertyList",(T.T_LIST (T.T_STRUCT typemap_Property)))),(7,("constituent",(T.T_STRUCT Structure_Types.typemap_ConstituentRef)))] default_MentionArgument :: MentionArgument default_MentionArgument = MentionArgument{ mentionArgument_role = P.Nothing, mentionArgument_entityMentionId = P.Nothing, mentionArgument_situationMentionId = P.Nothing, mentionArgument_tokens = P.Nothing, mentionArgument_confidence = P.Nothing, mentionArgument_propertyList = P.Nothing, mentionArgument_constituent = P.Nothing} data SituationMention = SituationMention { situationMention_uuid :: Uuid_Types.UUID , situationMention_text :: P.Maybe LT.Text , situationMention_situationType :: P.Maybe LT.Text , situationMention_situationKind :: P.Maybe LT.Text , situationMention_argumentList :: (Vector.Vector MentionArgument) , situationMention_intensity :: P.Maybe P.Double , situationMention_polarity :: P.Maybe LT.Text , situationMention_tokens :: P.Maybe Structure_Types.TokenRefSequence , situationMention_constituent :: P.Maybe Structure_Types.ConstituentRef , situationMention_confidence :: P.Maybe P.Double } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable SituationMention where hashWithSalt salt record = salt `H.hashWithSalt` situationMention_uuid record `H.hashWithSalt` situationMention_text record `H.hashWithSalt` situationMention_situationType record `H.hashWithSalt` situationMention_situationKind record `H.hashWithSalt` situationMention_argumentList record `H.hashWithSalt` situationMention_intensity record `H.hashWithSalt` situationMention_polarity record `H.hashWithSalt` situationMention_tokens record `H.hashWithSalt` situationMention_constituent record `H.hashWithSalt` situationMention_confidence record instance QC.Arbitrary SituationMention where arbitrary = M.liftM SituationMention (QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_SituationMention = [] | P.otherwise = M.catMaybes [ if obj == default_SituationMention{situationMention_uuid = situationMention_uuid obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_uuid = situationMention_uuid obj} , if obj == default_SituationMention{situationMention_text = situationMention_text obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_text = situationMention_text obj} , if obj == default_SituationMention{situationMention_situationType = situationMention_situationType obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_situationType = situationMention_situationType obj} , if obj == default_SituationMention{situationMention_situationKind = situationMention_situationKind obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_situationKind = situationMention_situationKind obj} , if obj == default_SituationMention{situationMention_argumentList = situationMention_argumentList obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_argumentList = situationMention_argumentList obj} , if obj == default_SituationMention{situationMention_intensity = situationMention_intensity obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_intensity = situationMention_intensity obj} , if obj == default_SituationMention{situationMention_polarity = situationMention_polarity obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_polarity = situationMention_polarity obj} , if obj == default_SituationMention{situationMention_tokens = situationMention_tokens obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_tokens = situationMention_tokens obj} , if obj == default_SituationMention{situationMention_constituent = situationMention_constituent obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_constituent = situationMention_constituent obj} , if obj == default_SituationMention{situationMention_confidence = situationMention_confidence obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_confidence = situationMention_confidence obj} ] from_SituationMention :: SituationMention -> T.ThriftVal from_SituationMention record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v103 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v103))) $ situationMention_uuid record , (\_v103 -> (2, ("text",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_text record , (\_v103 -> (3, ("situationType",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_situationType record , (\_v103 -> P.Just (4, ("argumentList",T.TList (T.T_STRUCT typemap_MentionArgument) $ P.map (\_v105 -> from_MentionArgument _v105) $ Vector.toList _v103))) $ situationMention_argumentList record , (\_v103 -> (50, ("situationKind",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_situationKind record , (\_v103 -> (100, ("intensity",T.TDouble _v103))) <$> situationMention_intensity record , (\_v103 -> (101, ("polarity",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_polarity record , (\_v103 -> (150, ("tokens",Structure_Types.from_TokenRefSequence _v103))) <$> situationMention_tokens record , (\_v103 -> (151, ("constituent",Structure_Types.from_ConstituentRef _v103))) <$> situationMention_constituent record , (\_v103 -> (200, ("confidence",T.TDouble _v103))) <$> situationMention_confidence record ] write_SituationMention :: (T.Protocol p, T.Transport t) => p t -> SituationMention -> P.IO () write_SituationMention oprot record = T.writeVal oprot $ from_SituationMention record encode_SituationMention :: (T.Protocol p, T.Transport t) => p t -> SituationMention -> LBS.ByteString encode_SituationMention oprot record = T.serializeVal oprot $ from_SituationMention record to_SituationMention :: T.ThriftVal -> SituationMention to_SituationMention (T.TStruct fields) = SituationMention{ situationMention_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val107) -> (case _val107 of {T.TStruct _val108 -> (Uuid_Types.to_UUID (T.TStruct _val108)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), situationMention_text = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val109 -> E.decodeUtf8 _val109; _ -> P.error "wrong type"})) (Map.lookup (2) fields), situationMention_situationType = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val110 -> E.decodeUtf8 _val110; _ -> P.error "wrong type"})) (Map.lookup (3) fields), situationMention_situationKind = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val111 -> E.decodeUtf8 _val111; _ -> P.error "wrong type"})) (Map.lookup (50) fields), situationMention_argumentList = P.maybe (P.error "Missing required field: argumentList") (\(_,_val107) -> (case _val107 of {T.TList _ _val112 -> (Vector.fromList $ P.map (\_v113 -> (case _v113 of {T.TStruct _val114 -> (to_MentionArgument (T.TStruct _val114)); _ -> P.error "wrong type"})) _val112); _ -> P.error "wrong type"})) (Map.lookup (4) fields), situationMention_intensity = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TDouble _val115 -> _val115; _ -> P.error "wrong type"})) (Map.lookup (100) fields), situationMention_polarity = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val116 -> E.decodeUtf8 _val116; _ -> P.error "wrong type"})) (Map.lookup (101) fields), situationMention_tokens = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TStruct _val117 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val117)); _ -> P.error "wrong type"})) (Map.lookup (150) fields), situationMention_constituent = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TStruct _val118 -> (Structure_Types.to_ConstituentRef (T.TStruct _val118)); _ -> P.error "wrong type"})) (Map.lookup (151) fields), situationMention_confidence = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TDouble _val119 -> _val119; _ -> P.error "wrong type"})) (Map.lookup (200) fields) } to_SituationMention _ = P.error "not a struct" read_SituationMention :: (T.Transport t, T.Protocol p) => p t -> P.IO SituationMention read_SituationMention iprot = to_SituationMention <$> T.readVal iprot (T.T_STRUCT typemap_SituationMention) decode_SituationMention :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> SituationMention decode_SituationMention iprot bs = to_SituationMention $ T.deserializeVal iprot (T.T_STRUCT typemap_SituationMention) bs typemap_SituationMention :: T.TypeMap typemap_SituationMention = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("text",T.T_STRING)),(3,("situationType",T.T_STRING)),(4,("argumentList",(T.T_LIST (T.T_STRUCT typemap_MentionArgument)))),(50,("situationKind",T.T_STRING)),(100,("intensity",T.T_DOUBLE)),(101,("polarity",T.T_STRING)),(150,("tokens",(T.T_STRUCT Structure_Types.typemap_TokenRefSequence))),(151,("constituent",(T.T_STRUCT Structure_Types.typemap_ConstituentRef))),(200,("confidence",T.T_DOUBLE))] default_SituationMention :: SituationMention default_SituationMention = SituationMention{ situationMention_uuid = Uuid_Types.default_UUID, situationMention_text = P.Nothing, situationMention_situationType = P.Nothing, situationMention_argumentList = Vector.empty, situationMention_situationKind = P.Nothing, situationMention_intensity = P.Nothing, situationMention_polarity = P.Nothing, situationMention_tokens = P.Nothing, situationMention_constituent = P.Nothing, situationMention_confidence = P.Nothing} data SituationMentionSet = SituationMentionSet { situationMentionSet_uuid :: Uuid_Types.UUID , situationMentionSet_metadata :: Metadata_Types.AnnotationMetadata , situationMentionSet_mentionList :: (Vector.Vector SituationMention) , situationMentionSet_linkingList :: P.Maybe (Vector.Vector Linking_Types.Linking) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable SituationMentionSet where hashWithSalt salt record = salt `H.hashWithSalt` situationMentionSet_uuid record `H.hashWithSalt` situationMentionSet_metadata record `H.hashWithSalt` situationMentionSet_mentionList record `H.hashWithSalt` situationMentionSet_linkingList record instance QC.Arbitrary SituationMentionSet where arbitrary = M.liftM SituationMentionSet (QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) shrink obj | obj == default_SituationMentionSet = [] | P.otherwise = M.catMaybes [ if obj == default_SituationMentionSet{situationMentionSet_uuid = situationMentionSet_uuid obj} then P.Nothing else P.Just $ default_SituationMentionSet{situationMentionSet_uuid = situationMentionSet_uuid obj} , if obj == default_SituationMentionSet{situationMentionSet_metadata = situationMentionSet_metadata obj} then P.Nothing else P.Just $ default_SituationMentionSet{situationMentionSet_metadata = situationMentionSet_metadata obj} , if obj == default_SituationMentionSet{situationMentionSet_mentionList = situationMentionSet_mentionList obj} then P.Nothing else P.Just $ default_SituationMentionSet{situationMentionSet_mentionList = situationMentionSet_mentionList obj} , if obj == default_SituationMentionSet{situationMentionSet_linkingList = situationMentionSet_linkingList obj} then P.Nothing else P.Just $ default_SituationMentionSet{situationMentionSet_linkingList = situationMentionSet_linkingList obj} ] from_SituationMentionSet :: SituationMentionSet -> T.ThriftVal from_SituationMentionSet record = T.TStruct $ Map.fromList $ M.catMaybes [ (\_v122 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v122))) $ situationMentionSet_uuid record , (\_v122 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v122))) $ situationMentionSet_metadata record , (\_v122 -> P.Just (3, ("mentionList",T.TList (T.T_STRUCT typemap_SituationMention) $ P.map (\_v124 -> from_SituationMention _v124) $ Vector.toList _v122))) $ situationMentionSet_mentionList record , (\_v122 -> (4, ("linkingList",T.TList (T.T_STRUCT Linking_Types.typemap_Linking) $ P.map (\_v126 -> Linking_Types.from_Linking _v126) $ Vector.toList _v122))) <$> situationMentionSet_linkingList record ] write_SituationMentionSet :: (T.Protocol p, T.Transport t) => p t -> SituationMentionSet -> P.IO () write_SituationMentionSet oprot record = T.writeVal oprot $ from_SituationMentionSet record encode_SituationMentionSet :: (T.Protocol p, T.Transport t) => p t -> SituationMentionSet -> LBS.ByteString encode_SituationMentionSet oprot record = T.serializeVal oprot $ from_SituationMentionSet record to_SituationMentionSet :: T.ThriftVal -> SituationMentionSet to_SituationMentionSet (T.TStruct fields) = SituationMentionSet{ situationMentionSet_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val128) -> (case _val128 of {T.TStruct _val129 -> (Uuid_Types.to_UUID (T.TStruct _val129)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), situationMentionSet_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val128) -> (case _val128 of {T.TStruct _val130 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val130)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), situationMentionSet_mentionList = P.maybe (P.error "Missing required field: mentionList") (\(_,_val128) -> (case _val128 of {T.TList _ _val131 -> (Vector.fromList $ P.map (\_v132 -> (case _v132 of {T.TStruct _val133 -> (to_SituationMention (T.TStruct _val133)); _ -> P.error "wrong type"})) _val131); _ -> P.error "wrong type"})) (Map.lookup (3) fields), situationMentionSet_linkingList = P.maybe (P.Nothing) (\(_,_val128) -> P.Just (case _val128 of {T.TList _ _val134 -> (Vector.fromList $ P.map (\_v135 -> (case _v135 of {T.TStruct _val136 -> (Linking_Types.to_Linking (T.TStruct _val136)); _ -> P.error "wrong type"})) _val134); _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_SituationMentionSet _ = P.error "not a struct" read_SituationMentionSet :: (T.Transport t, T.Protocol p) => p t -> P.IO SituationMentionSet read_SituationMentionSet iprot = to_SituationMentionSet <$> T.readVal iprot (T.T_STRUCT typemap_SituationMentionSet) decode_SituationMentionSet :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> SituationMentionSet decode_SituationMentionSet iprot bs = to_SituationMentionSet $ T.deserializeVal iprot (T.T_STRUCT typemap_SituationMentionSet) bs typemap_SituationMentionSet :: T.TypeMap typemap_SituationMentionSet = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("mentionList",(T.T_LIST (T.T_STRUCT typemap_SituationMention)))),(4,("linkingList",(T.T_LIST (T.T_STRUCT Linking_Types.typemap_Linking))))] default_SituationMentionSet :: SituationMentionSet default_SituationMentionSet = SituationMentionSet{ situationMentionSet_uuid = Uuid_Types.default_UUID, situationMentionSet_metadata = Metadata_Types.default_AnnotationMetadata, situationMentionSet_mentionList = Vector.empty, situationMentionSet_linkingList = P.Nothing}