diff --git a/concrete-haskell-autogen.cabal b/concrete-haskell-autogen.cabal --- a/concrete-haskell-autogen.cabal +++ b/concrete-haskell-autogen.cabal @@ -1,9 +1,9 @@ --- This file has been generated from package.yaml by hpack version 0.14.1. +-- This file has been generated from package.yaml by hpack version 0.17.1. -- -- see: https://github.com/sol/hpack name: concrete-haskell-autogen -version: 0.0.0.1 +version: 0.0.0.3 synopsis: Automatically generated Thrift definitions for the Concrete data format. description: Concrete is a Thrift-based data specification designed for Natural Language Processing (NLP) applications. category: Data @@ -25,6 +25,7 @@ , bytestring , containers , hashable + , lens , text , thrift , unordered-containers @@ -65,50 +66,149 @@ Data.Concrete.Autogen.SummarizationService Data.Concrete.Autogen.Access_Types Data.Concrete.Autogen.Access_Consts + Data.Concrete.Autogen.Lens.FetchResult + Data.Concrete.Autogen.Lens.FetchRequest Data.Concrete.Autogen.Annotate_Types Data.Concrete.Autogen.Annotate_Consts Data.Concrete.Autogen.Audio_Types Data.Concrete.Autogen.Audio_Consts + Data.Concrete.Autogen.Lens.Sound Data.Concrete.Autogen.Cluster_Types Data.Concrete.Autogen.Cluster_Consts + Data.Concrete.Autogen.Lens.ClusterMember + Data.Concrete.Autogen.Lens.Cluster + Data.Concrete.Autogen.Lens.Clustering Data.Concrete.Autogen.Communication_Types Data.Concrete.Autogen.Communication_Consts + Data.Concrete.Autogen.Lens.CommunicationTagging + Data.Concrete.Autogen.Lens.Communication + Data.Concrete.Autogen.Lens.CommunicationSet Data.Concrete.Autogen.Concrete_Types Data.Concrete.Autogen.Concrete_Consts Data.Concrete.Autogen.Email_Types Data.Concrete.Autogen.Email_Consts + Data.Concrete.Autogen.Lens.EmailAddress + Data.Concrete.Autogen.Lens.EmailCommunicationInfo Data.Concrete.Autogen.Entities_Types Data.Concrete.Autogen.Entities_Consts + Data.Concrete.Autogen.Lens.Entity + Data.Concrete.Autogen.Lens.EntitySet + Data.Concrete.Autogen.Lens.EntityMention + Data.Concrete.Autogen.Lens.EntityMentionSet Data.Concrete.Autogen.Ex_Types Data.Concrete.Autogen.Ex_Consts + Data.Concrete.Autogen.Lens.ConcreteThriftException + Data.Concrete.Autogen.Graph_Types + Data.Concrete.Autogen.Graph_Consts + Data.Concrete.Autogen.Lens.EdgeKind + Data.Concrete.Autogen.Lens.Node + Data.Concrete.Autogen.Lens.Edge + Data.Concrete.Autogen.Lens.GraphProperty + Data.Concrete.Autogen.Lens.GraphPropertyAssignment + Data.Concrete.Autogen.Lens.GraphAssociation + Data.Concrete.Autogen.Lens.GraphView + Data.Concrete.Autogen.Lens.NodeSet + Data.Concrete.Autogen.Lens.EdgeSet + Data.Concrete.Autogen.Lens.MultiGraph Data.Concrete.Autogen.Language_Types Data.Concrete.Autogen.Language_Consts + Data.Concrete.Autogen.Lens.LanguageIdentification Data.Concrete.Autogen.Learn_Types Data.Concrete.Autogen.Learn_Consts + Data.Concrete.Autogen.Lens.AnnotationTask + Data.Concrete.Autogen.Lens.Annotation Data.Concrete.Autogen.Linking_Types Data.Concrete.Autogen.Linking_Consts + Data.Concrete.Autogen.Lens.LinkTarget + Data.Concrete.Autogen.Lens.Link + Data.Concrete.Autogen.Lens.Linking Data.Concrete.Autogen.Metadata_Types Data.Concrete.Autogen.Metadata_Consts + Data.Concrete.Autogen.Lens.TheoryDependencies + Data.Concrete.Autogen.Lens.Digest + Data.Concrete.Autogen.Lens.AnnotationMetadata + Data.Concrete.Autogen.Lens.CommunicationMetadata Data.Concrete.Autogen.Nitf_Types Data.Concrete.Autogen.Nitf_Consts + Data.Concrete.Autogen.Lens.NITFInfo Data.Concrete.Autogen.Results_Types Data.Concrete.Autogen.Results_Consts Data.Concrete.Autogen.Search_Types Data.Concrete.Autogen.Search_Consts + Data.Concrete.Autogen.Lens.SearchType + Data.Concrete.Autogen.Lens.SearchFeedback + Data.Concrete.Autogen.Lens.SearchCapability + Data.Concrete.Autogen.Lens.SearchQuery + Data.Concrete.Autogen.Lens.SearchResultItem + Data.Concrete.Autogen.Lens.SearchResult Data.Concrete.Autogen.Services_Types Data.Concrete.Autogen.Services_Consts + Data.Concrete.Autogen.Lens.AnnotationTaskType + Data.Concrete.Autogen.Lens.AnnotationUnitType + Data.Concrete.Autogen.Lens.ServicesException + Data.Concrete.Autogen.Lens.NotImplementedException + Data.Concrete.Autogen.Lens.AsyncContactInfo + Data.Concrete.Autogen.Lens.AnnotationUnitIdentifier + Data.Concrete.Autogen.Lens.ServiceInfo Data.Concrete.Autogen.Situations_Types Data.Concrete.Autogen.Situations_Consts + Data.Concrete.Autogen.Lens.Property + Data.Concrete.Autogen.Lens.Argument + Data.Concrete.Autogen.Lens.Justification + Data.Concrete.Autogen.Lens.TimeML + Data.Concrete.Autogen.Lens.Situation + Data.Concrete.Autogen.Lens.SituationSet + Data.Concrete.Autogen.Lens.MentionArgument + Data.Concrete.Autogen.Lens.SituationMention + Data.Concrete.Autogen.Lens.SituationMentionSet Data.Concrete.Autogen.Spans_Types Data.Concrete.Autogen.Spans_Consts + Data.Concrete.Autogen.Lens.TextSpan + Data.Concrete.Autogen.Lens.AudioSpan Data.Concrete.Autogen.Structure_Types Data.Concrete.Autogen.Structure_Consts + Data.Concrete.Autogen.Lens.TokenizationKind + Data.Concrete.Autogen.Lens.Constituent + Data.Concrete.Autogen.Lens.Parse + Data.Concrete.Autogen.Lens.ConstituentRef + Data.Concrete.Autogen.Lens.Dependency + Data.Concrete.Autogen.Lens.DependencyParseStructure + Data.Concrete.Autogen.Lens.DependencyParse + Data.Concrete.Autogen.Lens.Token + Data.Concrete.Autogen.Lens.TokenRefSequence + Data.Concrete.Autogen.Lens.TaggedToken + Data.Concrete.Autogen.Lens.TokenTagging + Data.Concrete.Autogen.Lens.LatticePath + Data.Concrete.Autogen.Lens.Arc + Data.Concrete.Autogen.Lens.TokenLattice + Data.Concrete.Autogen.Lens.TokenList + Data.Concrete.Autogen.Lens.SpanLink + Data.Concrete.Autogen.Lens.Tokenization + Data.Concrete.Autogen.Lens.Sentence + Data.Concrete.Autogen.Lens.Section Data.Concrete.Autogen.Summarization_Types Data.Concrete.Autogen.Summarization_Consts + Data.Concrete.Autogen.Lens.SummarySourceType + Data.Concrete.Autogen.Lens.SummarizationRequest + Data.Concrete.Autogen.Lens.SummaryConcept + Data.Concrete.Autogen.Lens.Summary + Data.Concrete.Autogen.Lens.SummarizationCapability Data.Concrete.Autogen.Twitter_Types Data.Concrete.Autogen.Twitter_Consts + Data.Concrete.Autogen.Lens.TwitterUser + Data.Concrete.Autogen.Lens.TwitterLatLong + Data.Concrete.Autogen.Lens.BoundingBox + Data.Concrete.Autogen.Lens.PlaceAttributes + Data.Concrete.Autogen.Lens.UserMention + Data.Concrete.Autogen.Lens.URL + Data.Concrete.Autogen.Lens.HashTag + Data.Concrete.Autogen.Lens.TwitterEntities + Data.Concrete.Autogen.Lens.TwitterPlace + Data.Concrete.Autogen.Lens.TwitterCoordinates + Data.Concrete.Autogen.Lens.TweetInfo Data.Concrete.Autogen.Uuid_Types Data.Concrete.Autogen.Uuid_Consts + Data.Concrete.Autogen.Lens.UUID other-modules: Paths_concrete_haskell_autogen default-language: Haskell2010 diff --git a/src/Data/Concrete/Autogen/Concrete_Consts.hs b/src/Data/Concrete/Autogen/Concrete_Consts.hs --- a/src/Data/Concrete/Autogen/Concrete_Consts.hs +++ b/src/Data/Concrete/Autogen/Concrete_Consts.hs @@ -45,6 +45,7 @@ import Data.Concrete.Autogen.Email_Types as Email_Types import Data.Concrete.Autogen.Entities_Types as Entities_Types import Data.Concrete.Autogen.Ex_Types as Ex_Types +import Data.Concrete.Autogen.Graph_Types as Graph_Types import Data.Concrete.Autogen.Language_Types as Language_Types import Data.Concrete.Autogen.Learn_Types as Learn_Types import Data.Concrete.Autogen.Linking_Types as Linking_Types diff --git a/src/Data/Concrete/Autogen/Concrete_Types.hs b/src/Data/Concrete/Autogen/Concrete_Types.hs --- a/src/Data/Concrete/Autogen/Concrete_Types.hs +++ b/src/Data/Concrete/Autogen/Concrete_Types.hs @@ -45,6 +45,7 @@ import Data.Concrete.Autogen.Email_Types as Email_Types import Data.Concrete.Autogen.Entities_Types as Entities_Types import Data.Concrete.Autogen.Ex_Types as Ex_Types +import Data.Concrete.Autogen.Graph_Types as Graph_Types import Data.Concrete.Autogen.Language_Types as Language_Types import Data.Concrete.Autogen.Learn_Types as Learn_Types import Data.Concrete.Autogen.Linking_Types as Linking_Types diff --git a/src/Data/Concrete/Autogen/Graph_Consts.hs b/src/Data/Concrete/Autogen/Graph_Consts.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Graph_Consts.hs @@ -0,0 +1,44 @@ +{-# 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.10.0) -- +-- -- +-- DO NOT EDIT UNLESS YOU ARE SURE YOU KNOW WHAT YOU ARE DOING -- +----------------------------------------------------------------- + +module Data.Concrete.Autogen.Graph_Consts 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 Data.Concrete.Autogen.Metadata_Types as Metadata_Types +import Data.Concrete.Autogen.Uuid_Types as Uuid_Types + + +import Data.Concrete.Autogen.Graph_Types as Graph_Types diff --git a/src/Data/Concrete/Autogen/Graph_Types.hs b/src/Data/Concrete/Autogen/Graph_Types.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Graph_Types.hs @@ -0,0 +1,482 @@ +{-# 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.10.0) -- +-- -- +-- DO NOT EDIT UNLESS YOU ARE SURE YOU KNOW WHAT YOU ARE DOING -- +----------------------------------------------------------------- + +module Data.Concrete.Autogen.Graph_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 Data.Concrete.Autogen.Metadata_Types as Metadata_Types +import Data.Concrete.Autogen.Uuid_Types as Uuid_Types + + +data EdgeKind = DIRECTED|UNDIRECTED deriving (P.Show, P.Eq, G.Generic, TY.Typeable, P.Ord, P.Bounded) +instance P.Enum EdgeKind where + fromEnum t = case t of + DIRECTED -> 1 + UNDIRECTED -> 2 + toEnum t = case t of + 1 -> DIRECTED + 2 -> UNDIRECTED + _ -> X.throw T.ThriftException +instance H.Hashable EdgeKind where + hashWithSalt salt = H.hashWithSalt salt P.. P.fromEnum +instance QC.Arbitrary EdgeKind where + arbitrary = QC.elements (P.enumFromTo P.minBound P.maxBound) +data Node = Node { node_id :: I.Int64 + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable Node where + hashWithSalt salt record = salt `H.hashWithSalt` node_id record +instance QC.Arbitrary Node where + arbitrary = M.liftM Node (QC.arbitrary) + shrink obj | obj == default_Node = [] + | P.otherwise = M.catMaybes + [ if obj == default_Node{node_id = node_id obj} then P.Nothing else P.Just $ default_Node{node_id = node_id obj} + ] +from_Node :: Node -> T.ThriftVal +from_Node record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v2 -> P.Just (1, ("id",T.TI64 _v2))) $ node_id record + ] +write_Node :: (T.Protocol p, T.Transport t) => p t -> Node -> P.IO () +write_Node oprot record = T.writeVal oprot $ from_Node record +encode_Node :: (T.Protocol p, T.Transport t) => p t -> Node -> LBS.ByteString +encode_Node oprot record = T.serializeVal oprot $ from_Node record +to_Node :: T.ThriftVal -> Node +to_Node (T.TStruct fields) = Node{ + node_id = P.maybe (P.error "Missing required field: id") (\(_,_val4) -> (case _val4 of {T.TI64 _val5 -> _val5; _ -> P.error "wrong type"})) (Map.lookup (1) fields) + } +to_Node _ = P.error "not a struct" +read_Node :: (T.Transport t, T.Protocol p) => p t -> P.IO Node +read_Node iprot = to_Node <$> T.readVal iprot (T.T_STRUCT typemap_Node) +decode_Node :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Node +decode_Node iprot bs = to_Node $ T.deserializeVal iprot (T.T_STRUCT typemap_Node) bs +typemap_Node :: T.TypeMap +typemap_Node = Map.fromList [(1,("id",T.T_I64))] +default_Node :: Node +default_Node = Node{ + node_id = 0} +data Edge = Edge { edge_id :: I.Int64 + , edge_kind :: EdgeKind + , edge_sources :: (Set.HashSet Node) + , edge_targets :: (Set.HashSet Node) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable Edge where + hashWithSalt salt record = salt `H.hashWithSalt` edge_id record `H.hashWithSalt` edge_kind record `H.hashWithSalt` edge_sources record `H.hashWithSalt` edge_targets record +instance QC.Arbitrary Edge where + arbitrary = M.liftM Edge (QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + shrink obj | obj == default_Edge = [] + | P.otherwise = M.catMaybes + [ if obj == default_Edge{edge_id = edge_id obj} then P.Nothing else P.Just $ default_Edge{edge_id = edge_id obj} + , if obj == default_Edge{edge_kind = edge_kind obj} then P.Nothing else P.Just $ default_Edge{edge_kind = edge_kind obj} + , if obj == default_Edge{edge_sources = edge_sources obj} then P.Nothing else P.Just $ default_Edge{edge_sources = edge_sources obj} + , if obj == default_Edge{edge_targets = edge_targets obj} then P.Nothing else P.Just $ default_Edge{edge_targets = edge_targets obj} + ] +from_Edge :: Edge -> T.ThriftVal +from_Edge record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v8 -> P.Just (1, ("id",T.TI64 _v8))) $ edge_id record + , (\_v8 -> P.Just (2, ("kind",T.TI32 $ P.fromIntegral $ P.fromEnum _v8))) $ edge_kind record + , (\_v8 -> P.Just (3, ("sources",T.TSet (T.T_STRUCT typemap_Node) $ P.map (\_v10 -> from_Node _v10) $ Set.toList _v8))) $ edge_sources record + , (\_v8 -> P.Just (4, ("targets",T.TSet (T.T_STRUCT typemap_Node) $ P.map (\_v12 -> from_Node _v12) $ Set.toList _v8))) $ edge_targets record + ] +write_Edge :: (T.Protocol p, T.Transport t) => p t -> Edge -> P.IO () +write_Edge oprot record = T.writeVal oprot $ from_Edge record +encode_Edge :: (T.Protocol p, T.Transport t) => p t -> Edge -> LBS.ByteString +encode_Edge oprot record = T.serializeVal oprot $ from_Edge record +to_Edge :: T.ThriftVal -> Edge +to_Edge (T.TStruct fields) = Edge{ + edge_id = P.maybe (P.error "Missing required field: id") (\(_,_val14) -> (case _val14 of {T.TI64 _val15 -> _val15; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + edge_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val14) -> (case _val14 of {T.TI32 _val16 -> P.toEnum $ P.fromIntegral _val16; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + edge_sources = P.maybe (P.error "Missing required field: sources") (\(_,_val14) -> (case _val14 of {T.TSet _ _val17 -> (Set.fromList $ P.map (\_v18 -> (case _v18 of {T.TStruct _val19 -> (to_Node (T.TStruct _val19)); _ -> P.error "wrong type"})) _val17); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + edge_targets = P.maybe (P.error "Missing required field: targets") (\(_,_val14) -> (case _val14 of {T.TSet _ _val20 -> (Set.fromList $ P.map (\_v21 -> (case _v21 of {T.TStruct _val22 -> (to_Node (T.TStruct _val22)); _ -> P.error "wrong type"})) _val20); _ -> P.error "wrong type"})) (Map.lookup (4) fields) + } +to_Edge _ = P.error "not a struct" +read_Edge :: (T.Transport t, T.Protocol p) => p t -> P.IO Edge +read_Edge iprot = to_Edge <$> T.readVal iprot (T.T_STRUCT typemap_Edge) +decode_Edge :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Edge +decode_Edge iprot bs = to_Edge $ T.deserializeVal iprot (T.T_STRUCT typemap_Edge) bs +typemap_Edge :: T.TypeMap +typemap_Edge = Map.fromList [(1,("id",T.T_I64)),(2,("kind",T.T_I32)),(3,("sources",(T.T_SET (T.T_STRUCT typemap_Node)))),(4,("targets",(T.T_SET (T.T_STRUCT typemap_Node))))] +default_Edge :: Edge +default_Edge = Edge{ + edge_id = 0, + edge_kind = (P.toEnum 0), + edge_sources = Set.empty, + edge_targets = Set.empty} +data GraphProperty = GraphProperty { graphProperty_objectId :: I.Int64 + , graphProperty_tagList :: (Vector.Vector LT.Text) + , graphProperty_confidenceList :: P.Maybe (Vector.Vector P.Double) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable GraphProperty where + hashWithSalt salt record = salt `H.hashWithSalt` graphProperty_objectId record `H.hashWithSalt` graphProperty_tagList record `H.hashWithSalt` graphProperty_confidenceList record +instance QC.Arbitrary GraphProperty where + arbitrary = M.liftM GraphProperty (QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(M.liftM P.Just QC.arbitrary) + shrink obj | obj == default_GraphProperty = [] + | P.otherwise = M.catMaybes + [ if obj == default_GraphProperty{graphProperty_objectId = graphProperty_objectId obj} then P.Nothing else P.Just $ default_GraphProperty{graphProperty_objectId = graphProperty_objectId obj} + , if obj == default_GraphProperty{graphProperty_tagList = graphProperty_tagList obj} then P.Nothing else P.Just $ default_GraphProperty{graphProperty_tagList = graphProperty_tagList obj} + , if obj == default_GraphProperty{graphProperty_confidenceList = graphProperty_confidenceList obj} then P.Nothing else P.Just $ default_GraphProperty{graphProperty_confidenceList = graphProperty_confidenceList obj} + ] +from_GraphProperty :: GraphProperty -> T.ThriftVal +from_GraphProperty record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v25 -> P.Just (1, ("objectId",T.TI64 _v25))) $ graphProperty_objectId record + , (\_v25 -> P.Just (2, ("tagList",T.TList T.T_STRING $ P.map (\_v27 -> T.TString $ E.encodeUtf8 _v27) $ Vector.toList _v25))) $ graphProperty_tagList record + , (\_v25 -> (3, ("confidenceList",T.TList T.T_DOUBLE $ P.map (\_v29 -> T.TDouble _v29) $ Vector.toList _v25))) <$> graphProperty_confidenceList record + ] +write_GraphProperty :: (T.Protocol p, T.Transport t) => p t -> GraphProperty -> P.IO () +write_GraphProperty oprot record = T.writeVal oprot $ from_GraphProperty record +encode_GraphProperty :: (T.Protocol p, T.Transport t) => p t -> GraphProperty -> LBS.ByteString +encode_GraphProperty oprot record = T.serializeVal oprot $ from_GraphProperty record +to_GraphProperty :: T.ThriftVal -> GraphProperty +to_GraphProperty (T.TStruct fields) = GraphProperty{ + graphProperty_objectId = P.maybe (P.error "Missing required field: objectId") (\(_,_val31) -> (case _val31 of {T.TI64 _val32 -> _val32; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + graphProperty_tagList = P.maybe (P.error "Missing required field: tagList") (\(_,_val31) -> (case _val31 of {T.TList _ _val33 -> (Vector.fromList $ P.map (\_v34 -> (case _v34 of {T.TString _val35 -> E.decodeUtf8 _val35; _ -> P.error "wrong type"})) _val33); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + graphProperty_confidenceList = P.maybe (P.Nothing) (\(_,_val31) -> P.Just (case _val31 of {T.TList _ _val36 -> (Vector.fromList $ P.map (\_v37 -> (case _v37 of {T.TDouble _val38 -> _val38; _ -> P.error "wrong type"})) _val36); _ -> P.error "wrong type"})) (Map.lookup (3) fields) + } +to_GraphProperty _ = P.error "not a struct" +read_GraphProperty :: (T.Transport t, T.Protocol p) => p t -> P.IO GraphProperty +read_GraphProperty iprot = to_GraphProperty <$> T.readVal iprot (T.T_STRUCT typemap_GraphProperty) +decode_GraphProperty :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> GraphProperty +decode_GraphProperty iprot bs = to_GraphProperty $ T.deserializeVal iprot (T.T_STRUCT typemap_GraphProperty) bs +typemap_GraphProperty :: T.TypeMap +typemap_GraphProperty = Map.fromList [(1,("objectId",T.T_I64)),(2,("tagList",(T.T_LIST T.T_STRING))),(3,("confidenceList",(T.T_LIST T.T_DOUBLE)))] +default_GraphProperty :: GraphProperty +default_GraphProperty = GraphProperty{ + graphProperty_objectId = 0, + graphProperty_tagList = Vector.empty, + graphProperty_confidenceList = P.Nothing} +data GraphPropertyAssignment = GraphPropertyAssignment { graphPropertyAssignment_uuid :: Uuid_Types.UUID + , graphPropertyAssignment_type :: LT.Text + , graphPropertyAssignment_propertyList :: (Vector.Vector GraphProperty) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable GraphPropertyAssignment where + hashWithSalt salt record = salt `H.hashWithSalt` graphPropertyAssignment_uuid record `H.hashWithSalt` graphPropertyAssignment_type record `H.hashWithSalt` graphPropertyAssignment_propertyList record +instance QC.Arbitrary GraphPropertyAssignment where + arbitrary = M.liftM GraphPropertyAssignment (QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + shrink obj | obj == default_GraphPropertyAssignment = [] + | P.otherwise = M.catMaybes + [ if obj == default_GraphPropertyAssignment{graphPropertyAssignment_uuid = graphPropertyAssignment_uuid obj} then P.Nothing else P.Just $ default_GraphPropertyAssignment{graphPropertyAssignment_uuid = graphPropertyAssignment_uuid obj} + , if obj == default_GraphPropertyAssignment{graphPropertyAssignment_type = graphPropertyAssignment_type obj} then P.Nothing else P.Just $ default_GraphPropertyAssignment{graphPropertyAssignment_type = graphPropertyAssignment_type obj} + , if obj == default_GraphPropertyAssignment{graphPropertyAssignment_propertyList = graphPropertyAssignment_propertyList obj} then P.Nothing else P.Just $ default_GraphPropertyAssignment{graphPropertyAssignment_propertyList = graphPropertyAssignment_propertyList obj} + ] +from_GraphPropertyAssignment :: GraphPropertyAssignment -> T.ThriftVal +from_GraphPropertyAssignment record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v41 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v41))) $ graphPropertyAssignment_uuid record + , (\_v41 -> P.Just (2, ("type",T.TString $ E.encodeUtf8 _v41))) $ graphPropertyAssignment_type record + , (\_v41 -> P.Just (3, ("propertyList",T.TList (T.T_STRUCT typemap_GraphProperty) $ P.map (\_v43 -> from_GraphProperty _v43) $ Vector.toList _v41))) $ graphPropertyAssignment_propertyList record + ] +write_GraphPropertyAssignment :: (T.Protocol p, T.Transport t) => p t -> GraphPropertyAssignment -> P.IO () +write_GraphPropertyAssignment oprot record = T.writeVal oprot $ from_GraphPropertyAssignment record +encode_GraphPropertyAssignment :: (T.Protocol p, T.Transport t) => p t -> GraphPropertyAssignment -> LBS.ByteString +encode_GraphPropertyAssignment oprot record = T.serializeVal oprot $ from_GraphPropertyAssignment record +to_GraphPropertyAssignment :: T.ThriftVal -> GraphPropertyAssignment +to_GraphPropertyAssignment (T.TStruct fields) = GraphPropertyAssignment{ + graphPropertyAssignment_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val45) -> (case _val45 of {T.TStruct _val46 -> (Uuid_Types.to_UUID (T.TStruct _val46)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + graphPropertyAssignment_type = P.maybe (P.error "Missing required field: type") (\(_,_val45) -> (case _val45 of {T.TString _val47 -> E.decodeUtf8 _val47; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + graphPropertyAssignment_propertyList = P.maybe (P.error "Missing required field: propertyList") (\(_,_val45) -> (case _val45 of {T.TList _ _val48 -> (Vector.fromList $ P.map (\_v49 -> (case _v49 of {T.TStruct _val50 -> (to_GraphProperty (T.TStruct _val50)); _ -> P.error "wrong type"})) _val48); _ -> P.error "wrong type"})) (Map.lookup (3) fields) + } +to_GraphPropertyAssignment _ = P.error "not a struct" +read_GraphPropertyAssignment :: (T.Transport t, T.Protocol p) => p t -> P.IO GraphPropertyAssignment +read_GraphPropertyAssignment iprot = to_GraphPropertyAssignment <$> T.readVal iprot (T.T_STRUCT typemap_GraphPropertyAssignment) +decode_GraphPropertyAssignment :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> GraphPropertyAssignment +decode_GraphPropertyAssignment iprot bs = to_GraphPropertyAssignment $ T.deserializeVal iprot (T.T_STRUCT typemap_GraphPropertyAssignment) bs +typemap_GraphPropertyAssignment :: T.TypeMap +typemap_GraphPropertyAssignment = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("type",T.T_STRING)),(3,("propertyList",(T.T_LIST (T.T_STRUCT typemap_GraphProperty))))] +default_GraphPropertyAssignment :: GraphPropertyAssignment +default_GraphPropertyAssignment = GraphPropertyAssignment{ + graphPropertyAssignment_uuid = Uuid_Types.default_UUID, + graphPropertyAssignment_type = "", + graphPropertyAssignment_propertyList = Vector.empty} +data GraphAssociation = GraphAssociation { graphAssociation_objectId :: I.Int64 + , graphAssociation_externalEntityId :: Uuid_Types.UUID + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable GraphAssociation where + hashWithSalt salt record = salt `H.hashWithSalt` graphAssociation_objectId record `H.hashWithSalt` graphAssociation_externalEntityId record +instance QC.Arbitrary GraphAssociation where + arbitrary = M.liftM GraphAssociation (QC.arbitrary) + `M.ap`(QC.arbitrary) + shrink obj | obj == default_GraphAssociation = [] + | P.otherwise = M.catMaybes + [ if obj == default_GraphAssociation{graphAssociation_objectId = graphAssociation_objectId obj} then P.Nothing else P.Just $ default_GraphAssociation{graphAssociation_objectId = graphAssociation_objectId obj} + , if obj == default_GraphAssociation{graphAssociation_externalEntityId = graphAssociation_externalEntityId obj} then P.Nothing else P.Just $ default_GraphAssociation{graphAssociation_externalEntityId = graphAssociation_externalEntityId obj} + ] +from_GraphAssociation :: GraphAssociation -> T.ThriftVal +from_GraphAssociation record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v53 -> P.Just (1, ("objectId",T.TI64 _v53))) $ graphAssociation_objectId record + , (\_v53 -> P.Just (2, ("externalEntityId",Uuid_Types.from_UUID _v53))) $ graphAssociation_externalEntityId record + ] +write_GraphAssociation :: (T.Protocol p, T.Transport t) => p t -> GraphAssociation -> P.IO () +write_GraphAssociation oprot record = T.writeVal oprot $ from_GraphAssociation record +encode_GraphAssociation :: (T.Protocol p, T.Transport t) => p t -> GraphAssociation -> LBS.ByteString +encode_GraphAssociation oprot record = T.serializeVal oprot $ from_GraphAssociation record +to_GraphAssociation :: T.ThriftVal -> GraphAssociation +to_GraphAssociation (T.TStruct fields) = GraphAssociation{ + graphAssociation_objectId = P.maybe (P.error "Missing required field: objectId") (\(_,_val55) -> (case _val55 of {T.TI64 _val56 -> _val56; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + graphAssociation_externalEntityId = P.maybe (P.error "Missing required field: externalEntityId") (\(_,_val55) -> (case _val55 of {T.TStruct _val57 -> (Uuid_Types.to_UUID (T.TStruct _val57)); _ -> P.error "wrong type"})) (Map.lookup (2) fields) + } +to_GraphAssociation _ = P.error "not a struct" +read_GraphAssociation :: (T.Transport t, T.Protocol p) => p t -> P.IO GraphAssociation +read_GraphAssociation iprot = to_GraphAssociation <$> T.readVal iprot (T.T_STRUCT typemap_GraphAssociation) +decode_GraphAssociation :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> GraphAssociation +decode_GraphAssociation iprot bs = to_GraphAssociation $ T.deserializeVal iprot (T.T_STRUCT typemap_GraphAssociation) bs +typemap_GraphAssociation :: T.TypeMap +typemap_GraphAssociation = Map.fromList [(1,("objectId",T.T_I64)),(2,("externalEntityId",(T.T_STRUCT Uuid_Types.typemap_UUID)))] +default_GraphAssociation :: GraphAssociation +default_GraphAssociation = GraphAssociation{ + graphAssociation_objectId = 0, + graphAssociation_externalEntityId = Uuid_Types.default_UUID} +data GraphView = GraphView { graphView_uuid :: Uuid_Types.UUID + , graphView_nodeSetIDSet :: (Set.HashSet Uuid_Types.UUID) + , graphView_edgeSetIDSet :: (Set.HashSet Uuid_Types.UUID) + , graphView_metadata :: P.Maybe Metadata_Types.AnnotationMetadata + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable GraphView where + hashWithSalt salt record = salt `H.hashWithSalt` graphView_uuid record `H.hashWithSalt` graphView_nodeSetIDSet record `H.hashWithSalt` graphView_edgeSetIDSet record `H.hashWithSalt` graphView_metadata record +instance QC.Arbitrary GraphView where + arbitrary = M.liftM GraphView (QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(M.liftM P.Just QC.arbitrary) + shrink obj | obj == default_GraphView = [] + | P.otherwise = M.catMaybes + [ if obj == default_GraphView{graphView_uuid = graphView_uuid obj} then P.Nothing else P.Just $ default_GraphView{graphView_uuid = graphView_uuid obj} + , if obj == default_GraphView{graphView_nodeSetIDSet = graphView_nodeSetIDSet obj} then P.Nothing else P.Just $ default_GraphView{graphView_nodeSetIDSet = graphView_nodeSetIDSet obj} + , if obj == default_GraphView{graphView_edgeSetIDSet = graphView_edgeSetIDSet obj} then P.Nothing else P.Just $ default_GraphView{graphView_edgeSetIDSet = graphView_edgeSetIDSet obj} + , if obj == default_GraphView{graphView_metadata = graphView_metadata obj} then P.Nothing else P.Just $ default_GraphView{graphView_metadata = graphView_metadata obj} + ] +from_GraphView :: GraphView -> T.ThriftVal +from_GraphView record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v60 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v60))) $ graphView_uuid record + , (\_v60 -> P.Just (2, ("nodeSetIDSet",T.TSet (T.T_STRUCT Uuid_Types.typemap_UUID) $ P.map (\_v62 -> Uuid_Types.from_UUID _v62) $ Set.toList _v60))) $ graphView_nodeSetIDSet record + , (\_v60 -> P.Just (3, ("edgeSetIDSet",T.TSet (T.T_STRUCT Uuid_Types.typemap_UUID) $ P.map (\_v64 -> Uuid_Types.from_UUID _v64) $ Set.toList _v60))) $ graphView_edgeSetIDSet record + , (\_v60 -> (4, ("metadata",Metadata_Types.from_AnnotationMetadata _v60))) <$> graphView_metadata record + ] +write_GraphView :: (T.Protocol p, T.Transport t) => p t -> GraphView -> P.IO () +write_GraphView oprot record = T.writeVal oprot $ from_GraphView record +encode_GraphView :: (T.Protocol p, T.Transport t) => p t -> GraphView -> LBS.ByteString +encode_GraphView oprot record = T.serializeVal oprot $ from_GraphView record +to_GraphView :: T.ThriftVal -> GraphView +to_GraphView (T.TStruct fields) = GraphView{ + graphView_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val66) -> (case _val66 of {T.TStruct _val67 -> (Uuid_Types.to_UUID (T.TStruct _val67)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + graphView_nodeSetIDSet = P.maybe (P.error "Missing required field: nodeSetIDSet") (\(_,_val66) -> (case _val66 of {T.TSet _ _val68 -> (Set.fromList $ P.map (\_v69 -> (case _v69 of {T.TStruct _val70 -> (Uuid_Types.to_UUID (T.TStruct _val70)); _ -> P.error "wrong type"})) _val68); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + graphView_edgeSetIDSet = P.maybe (P.error "Missing required field: edgeSetIDSet") (\(_,_val66) -> (case _val66 of {T.TSet _ _val71 -> (Set.fromList $ P.map (\_v72 -> (case _v72 of {T.TStruct _val73 -> (Uuid_Types.to_UUID (T.TStruct _val73)); _ -> P.error "wrong type"})) _val71); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + graphView_metadata = P.maybe (P.Nothing) (\(_,_val66) -> P.Just (case _val66 of {T.TStruct _val74 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val74)); _ -> P.error "wrong type"})) (Map.lookup (4) fields) + } +to_GraphView _ = P.error "not a struct" +read_GraphView :: (T.Transport t, T.Protocol p) => p t -> P.IO GraphView +read_GraphView iprot = to_GraphView <$> T.readVal iprot (T.T_STRUCT typemap_GraphView) +decode_GraphView :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> GraphView +decode_GraphView iprot bs = to_GraphView $ T.deserializeVal iprot (T.T_STRUCT typemap_GraphView) bs +typemap_GraphView :: T.TypeMap +typemap_GraphView = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("nodeSetIDSet",(T.T_SET (T.T_STRUCT Uuid_Types.typemap_UUID)))),(3,("edgeSetIDSet",(T.T_SET (T.T_STRUCT Uuid_Types.typemap_UUID)))),(4,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata)))] +default_GraphView :: GraphView +default_GraphView = GraphView{ + graphView_uuid = Uuid_Types.default_UUID, + graphView_nodeSetIDSet = Set.empty, + graphView_edgeSetIDSet = Set.empty, + graphView_metadata = P.Nothing} +data NodeSet = NodeSet { nodeSet_uuid :: Uuid_Types.UUID + , nodeSet_nodes :: (Set.HashSet Node) + , nodeSet_metadata :: P.Maybe Metadata_Types.AnnotationMetadata + , nodeSet_propertyAssignmentSet :: P.Maybe (Set.HashSet GraphPropertyAssignment) + , nodeSet_associationSet :: P.Maybe (Set.HashSet GraphAssociation) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable NodeSet where + hashWithSalt salt record = salt `H.hashWithSalt` nodeSet_uuid record `H.hashWithSalt` nodeSet_nodes record `H.hashWithSalt` nodeSet_metadata record `H.hashWithSalt` nodeSet_propertyAssignmentSet record `H.hashWithSalt` nodeSet_associationSet record +instance QC.Arbitrary NodeSet where + arbitrary = M.liftM NodeSet (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) + shrink obj | obj == default_NodeSet = [] + | P.otherwise = M.catMaybes + [ if obj == default_NodeSet{nodeSet_uuid = nodeSet_uuid obj} then P.Nothing else P.Just $ default_NodeSet{nodeSet_uuid = nodeSet_uuid obj} + , if obj == default_NodeSet{nodeSet_nodes = nodeSet_nodes obj} then P.Nothing else P.Just $ default_NodeSet{nodeSet_nodes = nodeSet_nodes obj} + , if obj == default_NodeSet{nodeSet_metadata = nodeSet_metadata obj} then P.Nothing else P.Just $ default_NodeSet{nodeSet_metadata = nodeSet_metadata obj} + , if obj == default_NodeSet{nodeSet_propertyAssignmentSet = nodeSet_propertyAssignmentSet obj} then P.Nothing else P.Just $ default_NodeSet{nodeSet_propertyAssignmentSet = nodeSet_propertyAssignmentSet obj} + , if obj == default_NodeSet{nodeSet_associationSet = nodeSet_associationSet obj} then P.Nothing else P.Just $ default_NodeSet{nodeSet_associationSet = nodeSet_associationSet obj} + ] +from_NodeSet :: NodeSet -> T.ThriftVal +from_NodeSet record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v77 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v77))) $ nodeSet_uuid record + , (\_v77 -> P.Just (2, ("nodes",T.TSet (T.T_STRUCT typemap_Node) $ P.map (\_v79 -> from_Node _v79) $ Set.toList _v77))) $ nodeSet_nodes record + , (\_v77 -> (3, ("metadata",Metadata_Types.from_AnnotationMetadata _v77))) <$> nodeSet_metadata record + , (\_v77 -> (4, ("propertyAssignmentSet",T.TSet (T.T_STRUCT typemap_GraphPropertyAssignment) $ P.map (\_v81 -> from_GraphPropertyAssignment _v81) $ Set.toList _v77))) <$> nodeSet_propertyAssignmentSet record + , (\_v77 -> (5, ("associationSet",T.TSet (T.T_STRUCT typemap_GraphAssociation) $ P.map (\_v83 -> from_GraphAssociation _v83) $ Set.toList _v77))) <$> nodeSet_associationSet record + ] +write_NodeSet :: (T.Protocol p, T.Transport t) => p t -> NodeSet -> P.IO () +write_NodeSet oprot record = T.writeVal oprot $ from_NodeSet record +encode_NodeSet :: (T.Protocol p, T.Transport t) => p t -> NodeSet -> LBS.ByteString +encode_NodeSet oprot record = T.serializeVal oprot $ from_NodeSet record +to_NodeSet :: T.ThriftVal -> NodeSet +to_NodeSet (T.TStruct fields) = NodeSet{ + nodeSet_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val85) -> (case _val85 of {T.TStruct _val86 -> (Uuid_Types.to_UUID (T.TStruct _val86)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + nodeSet_nodes = P.maybe (P.error "Missing required field: nodes") (\(_,_val85) -> (case _val85 of {T.TSet _ _val87 -> (Set.fromList $ P.map (\_v88 -> (case _v88 of {T.TStruct _val89 -> (to_Node (T.TStruct _val89)); _ -> P.error "wrong type"})) _val87); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + nodeSet_metadata = P.maybe (P.Nothing) (\(_,_val85) -> P.Just (case _val85 of {T.TStruct _val90 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val90)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + nodeSet_propertyAssignmentSet = P.maybe (P.Nothing) (\(_,_val85) -> P.Just (case _val85 of {T.TSet _ _val91 -> (Set.fromList $ P.map (\_v92 -> (case _v92 of {T.TStruct _val93 -> (to_GraphPropertyAssignment (T.TStruct _val93)); _ -> P.error "wrong type"})) _val91); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + nodeSet_associationSet = P.maybe (P.Nothing) (\(_,_val85) -> P.Just (case _val85 of {T.TSet _ _val94 -> (Set.fromList $ P.map (\_v95 -> (case _v95 of {T.TStruct _val96 -> (to_GraphAssociation (T.TStruct _val96)); _ -> P.error "wrong type"})) _val94); _ -> P.error "wrong type"})) (Map.lookup (5) fields) + } +to_NodeSet _ = P.error "not a struct" +read_NodeSet :: (T.Transport t, T.Protocol p) => p t -> P.IO NodeSet +read_NodeSet iprot = to_NodeSet <$> T.readVal iprot (T.T_STRUCT typemap_NodeSet) +decode_NodeSet :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> NodeSet +decode_NodeSet iprot bs = to_NodeSet $ T.deserializeVal iprot (T.T_STRUCT typemap_NodeSet) bs +typemap_NodeSet :: T.TypeMap +typemap_NodeSet = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("nodes",(T.T_SET (T.T_STRUCT typemap_Node)))),(3,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(4,("propertyAssignmentSet",(T.T_SET (T.T_STRUCT typemap_GraphPropertyAssignment)))),(5,("associationSet",(T.T_SET (T.T_STRUCT typemap_GraphAssociation))))] +default_NodeSet :: NodeSet +default_NodeSet = NodeSet{ + nodeSet_uuid = Uuid_Types.default_UUID, + nodeSet_nodes = Set.empty, + nodeSet_metadata = P.Nothing, + nodeSet_propertyAssignmentSet = P.Nothing, + nodeSet_associationSet = P.Nothing} +data EdgeSet = EdgeSet { edgeSet_uuid :: Uuid_Types.UUID + , edgeSet_edges :: (Set.HashSet Edge) + , edgeSet_metadata :: P.Maybe Metadata_Types.AnnotationMetadata + , edgeSet_propertyAssignmentSet :: P.Maybe (Set.HashSet GraphPropertyAssignment) + , edgeSet_associationSet :: P.Maybe (Set.HashSet GraphAssociation) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable EdgeSet where + hashWithSalt salt record = salt `H.hashWithSalt` edgeSet_uuid record `H.hashWithSalt` edgeSet_edges record `H.hashWithSalt` edgeSet_metadata record `H.hashWithSalt` edgeSet_propertyAssignmentSet record `H.hashWithSalt` edgeSet_associationSet record +instance QC.Arbitrary EdgeSet where + arbitrary = M.liftM EdgeSet (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) + shrink obj | obj == default_EdgeSet = [] + | P.otherwise = M.catMaybes + [ if obj == default_EdgeSet{edgeSet_uuid = edgeSet_uuid obj} then P.Nothing else P.Just $ default_EdgeSet{edgeSet_uuid = edgeSet_uuid obj} + , if obj == default_EdgeSet{edgeSet_edges = edgeSet_edges obj} then P.Nothing else P.Just $ default_EdgeSet{edgeSet_edges = edgeSet_edges obj} + , if obj == default_EdgeSet{edgeSet_metadata = edgeSet_metadata obj} then P.Nothing else P.Just $ default_EdgeSet{edgeSet_metadata = edgeSet_metadata obj} + , if obj == default_EdgeSet{edgeSet_propertyAssignmentSet = edgeSet_propertyAssignmentSet obj} then P.Nothing else P.Just $ default_EdgeSet{edgeSet_propertyAssignmentSet = edgeSet_propertyAssignmentSet obj} + , if obj == default_EdgeSet{edgeSet_associationSet = edgeSet_associationSet obj} then P.Nothing else P.Just $ default_EdgeSet{edgeSet_associationSet = edgeSet_associationSet obj} + ] +from_EdgeSet :: EdgeSet -> T.ThriftVal +from_EdgeSet record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v99 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v99))) $ edgeSet_uuid record + , (\_v99 -> P.Just (2, ("edges",T.TSet (T.T_STRUCT typemap_Edge) $ P.map (\_v101 -> from_Edge _v101) $ Set.toList _v99))) $ edgeSet_edges record + , (\_v99 -> (3, ("metadata",Metadata_Types.from_AnnotationMetadata _v99))) <$> edgeSet_metadata record + , (\_v99 -> (4, ("propertyAssignmentSet",T.TSet (T.T_STRUCT typemap_GraphPropertyAssignment) $ P.map (\_v103 -> from_GraphPropertyAssignment _v103) $ Set.toList _v99))) <$> edgeSet_propertyAssignmentSet record + , (\_v99 -> (5, ("associationSet",T.TSet (T.T_STRUCT typemap_GraphAssociation) $ P.map (\_v105 -> from_GraphAssociation _v105) $ Set.toList _v99))) <$> edgeSet_associationSet record + ] +write_EdgeSet :: (T.Protocol p, T.Transport t) => p t -> EdgeSet -> P.IO () +write_EdgeSet oprot record = T.writeVal oprot $ from_EdgeSet record +encode_EdgeSet :: (T.Protocol p, T.Transport t) => p t -> EdgeSet -> LBS.ByteString +encode_EdgeSet oprot record = T.serializeVal oprot $ from_EdgeSet record +to_EdgeSet :: T.ThriftVal -> EdgeSet +to_EdgeSet (T.TStruct fields) = EdgeSet{ + edgeSet_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), + edgeSet_edges = P.maybe (P.error "Missing required field: edges") (\(_,_val107) -> (case _val107 of {T.TSet _ _val109 -> (Set.fromList $ P.map (\_v110 -> (case _v110 of {T.TStruct _val111 -> (to_Edge (T.TStruct _val111)); _ -> P.error "wrong type"})) _val109); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + edgeSet_metadata = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TStruct _val112 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val112)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + edgeSet_propertyAssignmentSet = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TSet _ _val113 -> (Set.fromList $ P.map (\_v114 -> (case _v114 of {T.TStruct _val115 -> (to_GraphPropertyAssignment (T.TStruct _val115)); _ -> P.error "wrong type"})) _val113); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + edgeSet_associationSet = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TSet _ _val116 -> (Set.fromList $ P.map (\_v117 -> (case _v117 of {T.TStruct _val118 -> (to_GraphAssociation (T.TStruct _val118)); _ -> P.error "wrong type"})) _val116); _ -> P.error "wrong type"})) (Map.lookup (5) fields) + } +to_EdgeSet _ = P.error "not a struct" +read_EdgeSet :: (T.Transport t, T.Protocol p) => p t -> P.IO EdgeSet +read_EdgeSet iprot = to_EdgeSet <$> T.readVal iprot (T.T_STRUCT typemap_EdgeSet) +decode_EdgeSet :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> EdgeSet +decode_EdgeSet iprot bs = to_EdgeSet $ T.deserializeVal iprot (T.T_STRUCT typemap_EdgeSet) bs +typemap_EdgeSet :: T.TypeMap +typemap_EdgeSet = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("edges",(T.T_SET (T.T_STRUCT typemap_Edge)))),(3,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(4,("propertyAssignmentSet",(T.T_SET (T.T_STRUCT typemap_GraphPropertyAssignment)))),(5,("associationSet",(T.T_SET (T.T_STRUCT typemap_GraphAssociation))))] +default_EdgeSet :: EdgeSet +default_EdgeSet = EdgeSet{ + edgeSet_uuid = Uuid_Types.default_UUID, + edgeSet_edges = Set.empty, + edgeSet_metadata = P.Nothing, + edgeSet_propertyAssignmentSet = P.Nothing, + edgeSet_associationSet = P.Nothing} +data MultiGraph = MultiGraph { multiGraph_uuid :: Uuid_Types.UUID + , multiGraph_graphViews :: (Set.HashSet GraphView) + , multiGraph_nodeSets :: (Set.HashSet NodeSet) + , multiGraph_edgeSets :: (Set.HashSet EdgeSet) + , multiGraph_metadata :: P.Maybe Metadata_Types.AnnotationMetadata + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable MultiGraph where + hashWithSalt salt record = salt `H.hashWithSalt` multiGraph_uuid record `H.hashWithSalt` multiGraph_graphViews record `H.hashWithSalt` multiGraph_nodeSets record `H.hashWithSalt` multiGraph_edgeSets record `H.hashWithSalt` multiGraph_metadata record +instance QC.Arbitrary MultiGraph where + arbitrary = M.liftM MultiGraph (QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(M.liftM P.Just QC.arbitrary) + shrink obj | obj == default_MultiGraph = [] + | P.otherwise = M.catMaybes + [ if obj == default_MultiGraph{multiGraph_uuid = multiGraph_uuid obj} then P.Nothing else P.Just $ default_MultiGraph{multiGraph_uuid = multiGraph_uuid obj} + , if obj == default_MultiGraph{multiGraph_graphViews = multiGraph_graphViews obj} then P.Nothing else P.Just $ default_MultiGraph{multiGraph_graphViews = multiGraph_graphViews obj} + , if obj == default_MultiGraph{multiGraph_nodeSets = multiGraph_nodeSets obj} then P.Nothing else P.Just $ default_MultiGraph{multiGraph_nodeSets = multiGraph_nodeSets obj} + , if obj == default_MultiGraph{multiGraph_edgeSets = multiGraph_edgeSets obj} then P.Nothing else P.Just $ default_MultiGraph{multiGraph_edgeSets = multiGraph_edgeSets obj} + , if obj == default_MultiGraph{multiGraph_metadata = multiGraph_metadata obj} then P.Nothing else P.Just $ default_MultiGraph{multiGraph_metadata = multiGraph_metadata obj} + ] +from_MultiGraph :: MultiGraph -> T.ThriftVal +from_MultiGraph record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v121 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v121))) $ multiGraph_uuid record + , (\_v121 -> P.Just (2, ("graphViews",T.TSet (T.T_STRUCT typemap_GraphView) $ P.map (\_v123 -> from_GraphView _v123) $ Set.toList _v121))) $ multiGraph_graphViews record + , (\_v121 -> P.Just (3, ("nodeSets",T.TSet (T.T_STRUCT typemap_NodeSet) $ P.map (\_v125 -> from_NodeSet _v125) $ Set.toList _v121))) $ multiGraph_nodeSets record + , (\_v121 -> P.Just (4, ("edgeSets",T.TSet (T.T_STRUCT typemap_EdgeSet) $ P.map (\_v127 -> from_EdgeSet _v127) $ Set.toList _v121))) $ multiGraph_edgeSets record + , (\_v121 -> (5, ("metadata",Metadata_Types.from_AnnotationMetadata _v121))) <$> multiGraph_metadata record + ] +write_MultiGraph :: (T.Protocol p, T.Transport t) => p t -> MultiGraph -> P.IO () +write_MultiGraph oprot record = T.writeVal oprot $ from_MultiGraph record +encode_MultiGraph :: (T.Protocol p, T.Transport t) => p t -> MultiGraph -> LBS.ByteString +encode_MultiGraph oprot record = T.serializeVal oprot $ from_MultiGraph record +to_MultiGraph :: T.ThriftVal -> MultiGraph +to_MultiGraph (T.TStruct fields) = MultiGraph{ + multiGraph_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val129) -> (case _val129 of {T.TStruct _val130 -> (Uuid_Types.to_UUID (T.TStruct _val130)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + multiGraph_graphViews = P.maybe (P.error "Missing required field: graphViews") (\(_,_val129) -> (case _val129 of {T.TSet _ _val131 -> (Set.fromList $ P.map (\_v132 -> (case _v132 of {T.TStruct _val133 -> (to_GraphView (T.TStruct _val133)); _ -> P.error "wrong type"})) _val131); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + multiGraph_nodeSets = P.maybe (P.error "Missing required field: nodeSets") (\(_,_val129) -> (case _val129 of {T.TSet _ _val134 -> (Set.fromList $ P.map (\_v135 -> (case _v135 of {T.TStruct _val136 -> (to_NodeSet (T.TStruct _val136)); _ -> P.error "wrong type"})) _val134); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + multiGraph_edgeSets = P.maybe (P.error "Missing required field: edgeSets") (\(_,_val129) -> (case _val129 of {T.TSet _ _val137 -> (Set.fromList $ P.map (\_v138 -> (case _v138 of {T.TStruct _val139 -> (to_EdgeSet (T.TStruct _val139)); _ -> P.error "wrong type"})) _val137); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + multiGraph_metadata = P.maybe (P.Nothing) (\(_,_val129) -> P.Just (case _val129 of {T.TStruct _val140 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val140)); _ -> P.error "wrong type"})) (Map.lookup (5) fields) + } +to_MultiGraph _ = P.error "not a struct" +read_MultiGraph :: (T.Transport t, T.Protocol p) => p t -> P.IO MultiGraph +read_MultiGraph iprot = to_MultiGraph <$> T.readVal iprot (T.T_STRUCT typemap_MultiGraph) +decode_MultiGraph :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> MultiGraph +decode_MultiGraph iprot bs = to_MultiGraph $ T.deserializeVal iprot (T.T_STRUCT typemap_MultiGraph) bs +typemap_MultiGraph :: T.TypeMap +typemap_MultiGraph = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("graphViews",(T.T_SET (T.T_STRUCT typemap_GraphView)))),(3,("nodeSets",(T.T_SET (T.T_STRUCT typemap_NodeSet)))),(4,("edgeSets",(T.T_SET (T.T_STRUCT typemap_EdgeSet)))),(5,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata)))] +default_MultiGraph :: MultiGraph +default_MultiGraph = MultiGraph{ + multiGraph_uuid = Uuid_Types.default_UUID, + multiGraph_graphViews = Set.empty, + multiGraph_nodeSets = Set.empty, + multiGraph_edgeSets = Set.empty, + multiGraph_metadata = P.Nothing} diff --git a/src/Data/Concrete/Autogen/Lens/Annotation.hs b/src/Data/Concrete/Autogen/Lens/Annotation.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Annotation.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Annotation where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Learn_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Annotation diff --git a/src/Data/Concrete/Autogen/Lens/AnnotationMetadata.hs b/src/Data/Concrete/Autogen/Lens/AnnotationMetadata.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AnnotationMetadata.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AnnotationMetadata where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Metadata_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AnnotationMetadata diff --git a/src/Data/Concrete/Autogen/Lens/AnnotationTask.hs b/src/Data/Concrete/Autogen/Lens/AnnotationTask.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AnnotationTask.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AnnotationTask where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Learn_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AnnotationTask diff --git a/src/Data/Concrete/Autogen/Lens/AnnotationTaskType.hs b/src/Data/Concrete/Autogen/Lens/AnnotationTaskType.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AnnotationTaskType.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AnnotationTaskType where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AnnotationTaskType diff --git a/src/Data/Concrete/Autogen/Lens/AnnotationUnitIdentifier.hs b/src/Data/Concrete/Autogen/Lens/AnnotationUnitIdentifier.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AnnotationUnitIdentifier.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AnnotationUnitIdentifier where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AnnotationUnitIdentifier diff --git a/src/Data/Concrete/Autogen/Lens/AnnotationUnitType.hs b/src/Data/Concrete/Autogen/Lens/AnnotationUnitType.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AnnotationUnitType.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AnnotationUnitType where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AnnotationUnitType diff --git a/src/Data/Concrete/Autogen/Lens/Arc.hs b/src/Data/Concrete/Autogen/Lens/Arc.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Arc.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Arc where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Arc diff --git a/src/Data/Concrete/Autogen/Lens/Argument.hs b/src/Data/Concrete/Autogen/Lens/Argument.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Argument.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Argument where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Argument diff --git a/src/Data/Concrete/Autogen/Lens/AsyncContactInfo.hs b/src/Data/Concrete/Autogen/Lens/AsyncContactInfo.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AsyncContactInfo.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AsyncContactInfo where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AsyncContactInfo diff --git a/src/Data/Concrete/Autogen/Lens/AudioSpan.hs b/src/Data/Concrete/Autogen/Lens/AudioSpan.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/AudioSpan.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.AudioSpan where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Spans_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''AudioSpan diff --git a/src/Data/Concrete/Autogen/Lens/BoundingBox.hs b/src/Data/Concrete/Autogen/Lens/BoundingBox.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/BoundingBox.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.BoundingBox where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''BoundingBox diff --git a/src/Data/Concrete/Autogen/Lens/Cluster.hs b/src/Data/Concrete/Autogen/Lens/Cluster.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Cluster.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Cluster where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Cluster_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Cluster diff --git a/src/Data/Concrete/Autogen/Lens/ClusterMember.hs b/src/Data/Concrete/Autogen/Lens/ClusterMember.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/ClusterMember.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.ClusterMember where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Cluster_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''ClusterMember diff --git a/src/Data/Concrete/Autogen/Lens/Clustering.hs b/src/Data/Concrete/Autogen/Lens/Clustering.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Clustering.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Clustering where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Cluster_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Clustering diff --git a/src/Data/Concrete/Autogen/Lens/Communication.hs b/src/Data/Concrete/Autogen/Lens/Communication.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Communication.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Communication where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Communication_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Communication diff --git a/src/Data/Concrete/Autogen/Lens/CommunicationMetadata.hs b/src/Data/Concrete/Autogen/Lens/CommunicationMetadata.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/CommunicationMetadata.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.CommunicationMetadata where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Metadata_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''CommunicationMetadata diff --git a/src/Data/Concrete/Autogen/Lens/CommunicationSet.hs b/src/Data/Concrete/Autogen/Lens/CommunicationSet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/CommunicationSet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.CommunicationSet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Communication_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''CommunicationSet diff --git a/src/Data/Concrete/Autogen/Lens/CommunicationTagging.hs b/src/Data/Concrete/Autogen/Lens/CommunicationTagging.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/CommunicationTagging.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.CommunicationTagging where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Communication_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''CommunicationTagging diff --git a/src/Data/Concrete/Autogen/Lens/ConcreteThriftException.hs b/src/Data/Concrete/Autogen/Lens/ConcreteThriftException.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/ConcreteThriftException.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.ConcreteThriftException where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Ex_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''ConcreteThriftException diff --git a/src/Data/Concrete/Autogen/Lens/Constituent.hs b/src/Data/Concrete/Autogen/Lens/Constituent.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Constituent.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Constituent where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Constituent diff --git a/src/Data/Concrete/Autogen/Lens/ConstituentRef.hs b/src/Data/Concrete/Autogen/Lens/ConstituentRef.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/ConstituentRef.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.ConstituentRef where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''ConstituentRef diff --git a/src/Data/Concrete/Autogen/Lens/Dependency.hs b/src/Data/Concrete/Autogen/Lens/Dependency.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Dependency.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Dependency where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Dependency diff --git a/src/Data/Concrete/Autogen/Lens/DependencyParse.hs b/src/Data/Concrete/Autogen/Lens/DependencyParse.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/DependencyParse.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.DependencyParse where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''DependencyParse diff --git a/src/Data/Concrete/Autogen/Lens/DependencyParseStructure.hs b/src/Data/Concrete/Autogen/Lens/DependencyParseStructure.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/DependencyParseStructure.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.DependencyParseStructure where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''DependencyParseStructure diff --git a/src/Data/Concrete/Autogen/Lens/Digest.hs b/src/Data/Concrete/Autogen/Lens/Digest.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Digest.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Digest where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Metadata_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Digest diff --git a/src/Data/Concrete/Autogen/Lens/Edge.hs b/src/Data/Concrete/Autogen/Lens/Edge.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Edge.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Edge where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Edge diff --git a/src/Data/Concrete/Autogen/Lens/EdgeKind.hs b/src/Data/Concrete/Autogen/Lens/EdgeKind.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EdgeKind.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EdgeKind where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EdgeKind diff --git a/src/Data/Concrete/Autogen/Lens/EdgeSet.hs b/src/Data/Concrete/Autogen/Lens/EdgeSet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EdgeSet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EdgeSet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EdgeSet diff --git a/src/Data/Concrete/Autogen/Lens/EmailAddress.hs b/src/Data/Concrete/Autogen/Lens/EmailAddress.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EmailAddress.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EmailAddress where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Email_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EmailAddress diff --git a/src/Data/Concrete/Autogen/Lens/EmailCommunicationInfo.hs b/src/Data/Concrete/Autogen/Lens/EmailCommunicationInfo.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EmailCommunicationInfo.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EmailCommunicationInfo where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Email_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EmailCommunicationInfo diff --git a/src/Data/Concrete/Autogen/Lens/Entity.hs b/src/Data/Concrete/Autogen/Lens/Entity.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Entity.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Entity where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Entities_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Entity diff --git a/src/Data/Concrete/Autogen/Lens/EntityMention.hs b/src/Data/Concrete/Autogen/Lens/EntityMention.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EntityMention.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EntityMention where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Entities_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EntityMention diff --git a/src/Data/Concrete/Autogen/Lens/EntityMentionSet.hs b/src/Data/Concrete/Autogen/Lens/EntityMentionSet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EntityMentionSet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EntityMentionSet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Entities_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EntityMentionSet diff --git a/src/Data/Concrete/Autogen/Lens/EntitySet.hs b/src/Data/Concrete/Autogen/Lens/EntitySet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/EntitySet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.EntitySet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Entities_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''EntitySet diff --git a/src/Data/Concrete/Autogen/Lens/FetchRequest.hs b/src/Data/Concrete/Autogen/Lens/FetchRequest.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/FetchRequest.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.FetchRequest where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Access_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''FetchRequest diff --git a/src/Data/Concrete/Autogen/Lens/FetchResult.hs b/src/Data/Concrete/Autogen/Lens/FetchResult.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/FetchResult.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.FetchResult where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Access_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''FetchResult diff --git a/src/Data/Concrete/Autogen/Lens/GraphAssociation.hs b/src/Data/Concrete/Autogen/Lens/GraphAssociation.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/GraphAssociation.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.GraphAssociation where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''GraphAssociation diff --git a/src/Data/Concrete/Autogen/Lens/GraphProperty.hs b/src/Data/Concrete/Autogen/Lens/GraphProperty.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/GraphProperty.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.GraphProperty where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''GraphProperty diff --git a/src/Data/Concrete/Autogen/Lens/GraphPropertyAssignment.hs b/src/Data/Concrete/Autogen/Lens/GraphPropertyAssignment.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/GraphPropertyAssignment.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.GraphPropertyAssignment where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''GraphPropertyAssignment diff --git a/src/Data/Concrete/Autogen/Lens/GraphView.hs b/src/Data/Concrete/Autogen/Lens/GraphView.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/GraphView.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.GraphView where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''GraphView diff --git a/src/Data/Concrete/Autogen/Lens/HashTag.hs b/src/Data/Concrete/Autogen/Lens/HashTag.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/HashTag.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.HashTag where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''HashTag diff --git a/src/Data/Concrete/Autogen/Lens/Justification.hs b/src/Data/Concrete/Autogen/Lens/Justification.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Justification.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Justification where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Justification diff --git a/src/Data/Concrete/Autogen/Lens/LanguageIdentification.hs b/src/Data/Concrete/Autogen/Lens/LanguageIdentification.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/LanguageIdentification.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.LanguageIdentification where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Language_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''LanguageIdentification diff --git a/src/Data/Concrete/Autogen/Lens/LatticePath.hs b/src/Data/Concrete/Autogen/Lens/LatticePath.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/LatticePath.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.LatticePath where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''LatticePath diff --git a/src/Data/Concrete/Autogen/Lens/Link.hs b/src/Data/Concrete/Autogen/Lens/Link.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Link.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Link where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Linking_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Link diff --git a/src/Data/Concrete/Autogen/Lens/LinkTarget.hs b/src/Data/Concrete/Autogen/Lens/LinkTarget.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/LinkTarget.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.LinkTarget where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Linking_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''LinkTarget diff --git a/src/Data/Concrete/Autogen/Lens/Linking.hs b/src/Data/Concrete/Autogen/Lens/Linking.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Linking.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Linking where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Linking_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Linking diff --git a/src/Data/Concrete/Autogen/Lens/MentionArgument.hs b/src/Data/Concrete/Autogen/Lens/MentionArgument.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/MentionArgument.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.MentionArgument where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''MentionArgument diff --git a/src/Data/Concrete/Autogen/Lens/MultiGraph.hs b/src/Data/Concrete/Autogen/Lens/MultiGraph.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/MultiGraph.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.MultiGraph where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''MultiGraph diff --git a/src/Data/Concrete/Autogen/Lens/NITFInfo.hs b/src/Data/Concrete/Autogen/Lens/NITFInfo.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/NITFInfo.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.NITFInfo where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Nitf_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''NITFInfo diff --git a/src/Data/Concrete/Autogen/Lens/Node.hs b/src/Data/Concrete/Autogen/Lens/Node.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Node.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Node where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Node diff --git a/src/Data/Concrete/Autogen/Lens/NodeSet.hs b/src/Data/Concrete/Autogen/Lens/NodeSet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/NodeSet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.NodeSet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Graph_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''NodeSet diff --git a/src/Data/Concrete/Autogen/Lens/NotImplementedException.hs b/src/Data/Concrete/Autogen/Lens/NotImplementedException.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/NotImplementedException.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.NotImplementedException where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''NotImplementedException diff --git a/src/Data/Concrete/Autogen/Lens/Parse.hs b/src/Data/Concrete/Autogen/Lens/Parse.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Parse.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Parse where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Parse diff --git a/src/Data/Concrete/Autogen/Lens/PlaceAttributes.hs b/src/Data/Concrete/Autogen/Lens/PlaceAttributes.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/PlaceAttributes.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.PlaceAttributes where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''PlaceAttributes diff --git a/src/Data/Concrete/Autogen/Lens/Property.hs b/src/Data/Concrete/Autogen/Lens/Property.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Property.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Property where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Property diff --git a/src/Data/Concrete/Autogen/Lens/SearchCapability.hs b/src/Data/Concrete/Autogen/Lens/SearchCapability.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SearchCapability.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SearchCapability where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Search_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SearchCapability diff --git a/src/Data/Concrete/Autogen/Lens/SearchFeedback.hs b/src/Data/Concrete/Autogen/Lens/SearchFeedback.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SearchFeedback.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SearchFeedback where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Search_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SearchFeedback diff --git a/src/Data/Concrete/Autogen/Lens/SearchQuery.hs b/src/Data/Concrete/Autogen/Lens/SearchQuery.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SearchQuery.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SearchQuery where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Search_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SearchQuery diff --git a/src/Data/Concrete/Autogen/Lens/SearchResult.hs b/src/Data/Concrete/Autogen/Lens/SearchResult.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SearchResult.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SearchResult where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Search_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SearchResult diff --git a/src/Data/Concrete/Autogen/Lens/SearchResultItem.hs b/src/Data/Concrete/Autogen/Lens/SearchResultItem.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SearchResultItem.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SearchResultItem where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Search_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SearchResultItem diff --git a/src/Data/Concrete/Autogen/Lens/SearchType.hs b/src/Data/Concrete/Autogen/Lens/SearchType.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SearchType.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SearchType where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Search_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SearchType diff --git a/src/Data/Concrete/Autogen/Lens/Section.hs b/src/Data/Concrete/Autogen/Lens/Section.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Section.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Section where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Section diff --git a/src/Data/Concrete/Autogen/Lens/Sentence.hs b/src/Data/Concrete/Autogen/Lens/Sentence.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Sentence.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Sentence where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Sentence diff --git a/src/Data/Concrete/Autogen/Lens/ServiceInfo.hs b/src/Data/Concrete/Autogen/Lens/ServiceInfo.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/ServiceInfo.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.ServiceInfo where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''ServiceInfo diff --git a/src/Data/Concrete/Autogen/Lens/ServicesException.hs b/src/Data/Concrete/Autogen/Lens/ServicesException.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/ServicesException.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.ServicesException where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Services_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''ServicesException diff --git a/src/Data/Concrete/Autogen/Lens/Situation.hs b/src/Data/Concrete/Autogen/Lens/Situation.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Situation.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Situation where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Situation diff --git a/src/Data/Concrete/Autogen/Lens/SituationMention.hs b/src/Data/Concrete/Autogen/Lens/SituationMention.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SituationMention.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SituationMention where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SituationMention diff --git a/src/Data/Concrete/Autogen/Lens/SituationMentionSet.hs b/src/Data/Concrete/Autogen/Lens/SituationMentionSet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SituationMentionSet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SituationMentionSet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SituationMentionSet diff --git a/src/Data/Concrete/Autogen/Lens/SituationSet.hs b/src/Data/Concrete/Autogen/Lens/SituationSet.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SituationSet.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SituationSet where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SituationSet diff --git a/src/Data/Concrete/Autogen/Lens/Sound.hs b/src/Data/Concrete/Autogen/Lens/Sound.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Sound.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Sound where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Audio_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Sound diff --git a/src/Data/Concrete/Autogen/Lens/SpanLink.hs b/src/Data/Concrete/Autogen/Lens/SpanLink.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SpanLink.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SpanLink where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SpanLink diff --git a/src/Data/Concrete/Autogen/Lens/SummarizationCapability.hs b/src/Data/Concrete/Autogen/Lens/SummarizationCapability.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SummarizationCapability.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SummarizationCapability where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Summarization_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SummarizationCapability diff --git a/src/Data/Concrete/Autogen/Lens/SummarizationRequest.hs b/src/Data/Concrete/Autogen/Lens/SummarizationRequest.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SummarizationRequest.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SummarizationRequest where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Summarization_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SummarizationRequest diff --git a/src/Data/Concrete/Autogen/Lens/Summary.hs b/src/Data/Concrete/Autogen/Lens/Summary.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Summary.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Summary where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Summarization_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Summary diff --git a/src/Data/Concrete/Autogen/Lens/SummaryConcept.hs b/src/Data/Concrete/Autogen/Lens/SummaryConcept.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SummaryConcept.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SummaryConcept where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Summarization_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SummaryConcept diff --git a/src/Data/Concrete/Autogen/Lens/SummarySourceType.hs b/src/Data/Concrete/Autogen/Lens/SummarySourceType.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/SummarySourceType.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.SummarySourceType where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Summarization_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''SummarySourceType diff --git a/src/Data/Concrete/Autogen/Lens/TaggedToken.hs b/src/Data/Concrete/Autogen/Lens/TaggedToken.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TaggedToken.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TaggedToken where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TaggedToken diff --git a/src/Data/Concrete/Autogen/Lens/TextSpan.hs b/src/Data/Concrete/Autogen/Lens/TextSpan.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TextSpan.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TextSpan where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Spans_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TextSpan diff --git a/src/Data/Concrete/Autogen/Lens/TheoryDependencies.hs b/src/Data/Concrete/Autogen/Lens/TheoryDependencies.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TheoryDependencies.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TheoryDependencies where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Metadata_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TheoryDependencies diff --git a/src/Data/Concrete/Autogen/Lens/TimeML.hs b/src/Data/Concrete/Autogen/Lens/TimeML.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TimeML.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TimeML where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Situations_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TimeML diff --git a/src/Data/Concrete/Autogen/Lens/Token.hs b/src/Data/Concrete/Autogen/Lens/Token.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Token.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Token where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Token diff --git a/src/Data/Concrete/Autogen/Lens/TokenLattice.hs b/src/Data/Concrete/Autogen/Lens/TokenLattice.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TokenLattice.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TokenLattice where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TokenLattice diff --git a/src/Data/Concrete/Autogen/Lens/TokenList.hs b/src/Data/Concrete/Autogen/Lens/TokenList.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TokenList.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TokenList where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TokenList diff --git a/src/Data/Concrete/Autogen/Lens/TokenRefSequence.hs b/src/Data/Concrete/Autogen/Lens/TokenRefSequence.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TokenRefSequence.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TokenRefSequence where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TokenRefSequence diff --git a/src/Data/Concrete/Autogen/Lens/TokenTagging.hs b/src/Data/Concrete/Autogen/Lens/TokenTagging.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TokenTagging.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TokenTagging where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TokenTagging diff --git a/src/Data/Concrete/Autogen/Lens/Tokenization.hs b/src/Data/Concrete/Autogen/Lens/Tokenization.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/Tokenization.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.Tokenization where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''Tokenization diff --git a/src/Data/Concrete/Autogen/Lens/TokenizationKind.hs b/src/Data/Concrete/Autogen/Lens/TokenizationKind.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TokenizationKind.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TokenizationKind where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Structure_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TokenizationKind diff --git a/src/Data/Concrete/Autogen/Lens/TweetInfo.hs b/src/Data/Concrete/Autogen/Lens/TweetInfo.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TweetInfo.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TweetInfo where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TweetInfo diff --git a/src/Data/Concrete/Autogen/Lens/TwitterCoordinates.hs b/src/Data/Concrete/Autogen/Lens/TwitterCoordinates.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TwitterCoordinates.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TwitterCoordinates where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TwitterCoordinates diff --git a/src/Data/Concrete/Autogen/Lens/TwitterEntities.hs b/src/Data/Concrete/Autogen/Lens/TwitterEntities.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TwitterEntities.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TwitterEntities where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TwitterEntities diff --git a/src/Data/Concrete/Autogen/Lens/TwitterLatLong.hs b/src/Data/Concrete/Autogen/Lens/TwitterLatLong.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TwitterLatLong.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TwitterLatLong where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TwitterLatLong diff --git a/src/Data/Concrete/Autogen/Lens/TwitterPlace.hs b/src/Data/Concrete/Autogen/Lens/TwitterPlace.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TwitterPlace.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TwitterPlace where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TwitterPlace diff --git a/src/Data/Concrete/Autogen/Lens/TwitterUser.hs b/src/Data/Concrete/Autogen/Lens/TwitterUser.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/TwitterUser.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.TwitterUser where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''TwitterUser diff --git a/src/Data/Concrete/Autogen/Lens/URL.hs b/src/Data/Concrete/Autogen/Lens/URL.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/URL.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.URL where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''URL diff --git a/src/Data/Concrete/Autogen/Lens/UUID.hs b/src/Data/Concrete/Autogen/Lens/UUID.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/UUID.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.UUID where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Uuid_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''UUID diff --git a/src/Data/Concrete/Autogen/Lens/UserMention.hs b/src/Data/Concrete/Autogen/Lens/UserMention.hs new file mode 100644 --- /dev/null +++ b/src/Data/Concrete/Autogen/Lens/UserMention.hs @@ -0,0 +1,7 @@ +{-# LANGUAGE TemplateHaskell #-} +module Data.Concrete.Autogen.Lens.UserMention where + +import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~)) +import Data.Concrete.Autogen.Twitter_Types + +makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ['_':f])) ''UserMention diff --git a/src/Data/Concrete/Autogen/Situations_Types.hs b/src/Data/Concrete/Autogen/Situations_Types.hs --- a/src/Data/Concrete/Autogen/Situations_Types.hs +++ b/src/Data/Concrete/Autogen/Situations_Types.hs @@ -365,12 +365,11 @@ , 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 + 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_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) @@ -378,14 +377,12 @@ `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} ] @@ -397,7 +394,6 @@ , (\_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 @@ -409,9 +405,8 @@ 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) + mentionArgument_confidence = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TDouble _val96 -> _val96; _ -> P.error "wrong type"})) (Map.lookup (5) fields), + mentionArgument_propertyList = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TList _ _val97 -> (Vector.fromList $ P.map (\_v98 -> (case _v98 of {T.TStruct _val99 -> (to_Property (T.TStruct _val99)); _ -> P.error "wrong type"})) _val97); _ -> 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 @@ -419,7 +414,7 @@ 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)))] +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))))] default_MentionArgument :: MentionArgument default_MentionArgument = MentionArgument{ mentionArgument_role = P.Nothing, @@ -427,8 +422,7 @@ mentionArgument_situationMentionId = P.Nothing, mentionArgument_tokens = P.Nothing, mentionArgument_confidence = P.Nothing, - mentionArgument_propertyList = P.Nothing, - mentionArgument_constituent = P.Nothing} + mentionArgument_propertyList = P.Nothing} data SituationMention = SituationMention { situationMention_uuid :: Uuid_Types.UUID , situationMention_text :: P.Maybe LT.Text , situationMention_situationType :: P.Maybe LT.Text @@ -437,11 +431,10 @@ , 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 + 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_confidence record instance QC.Arbitrary SituationMention where arbitrary = M.liftM SituationMention (QC.arbitrary) `M.ap`(M.liftM P.Just QC.arbitrary) @@ -452,7 +445,6 @@ `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} @@ -463,21 +455,19 @@ , 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 + [ (\_v102 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v102))) $ situationMention_uuid record + , (\_v102 -> (2, ("text",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_text record + , (\_v102 -> (3, ("situationType",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_situationType record + , (\_v102 -> P.Just (4, ("argumentList",T.TList (T.T_STRUCT typemap_MentionArgument) $ P.map (\_v104 -> from_MentionArgument _v104) $ Vector.toList _v102))) $ situationMention_argumentList record + , (\_v102 -> (50, ("situationKind",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_situationKind record + , (\_v102 -> (100, ("intensity",T.TDouble _v102))) <$> situationMention_intensity record + , (\_v102 -> (101, ("polarity",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_polarity record + , (\_v102 -> (150, ("tokens",Structure_Types.from_TokenRefSequence _v102))) <$> situationMention_tokens record + , (\_v102 -> (200, ("confidence",T.TDouble _v102))) <$> 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 @@ -485,16 +475,15 @@ 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) + situationMention_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val106) -> (case _val106 of {T.TStruct _val107 -> (Uuid_Types.to_UUID (T.TStruct _val107)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + situationMention_text = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val108 -> E.decodeUtf8 _val108; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + situationMention_situationType = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val109 -> E.decodeUtf8 _val109; _ -> P.error "wrong type"})) (Map.lookup (3) fields), + situationMention_situationKind = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val110 -> E.decodeUtf8 _val110; _ -> P.error "wrong type"})) (Map.lookup (50) fields), + situationMention_argumentList = P.maybe (P.error "Missing required field: argumentList") (\(_,_val106) -> (case _val106 of {T.TList _ _val111 -> (Vector.fromList $ P.map (\_v112 -> (case _v112 of {T.TStruct _val113 -> (to_MentionArgument (T.TStruct _val113)); _ -> P.error "wrong type"})) _val111); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + situationMention_intensity = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TDouble _val114 -> _val114; _ -> P.error "wrong type"})) (Map.lookup (100) fields), + situationMention_polarity = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val115 -> E.decodeUtf8 _val115; _ -> P.error "wrong type"})) (Map.lookup (101) fields), + situationMention_tokens = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TStruct _val116 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val116)); _ -> P.error "wrong type"})) (Map.lookup (150) fields), + situationMention_confidence = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TDouble _val117 -> _val117; _ -> 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 @@ -502,7 +491,7 @@ 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))] +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))),(200,("confidence",T.T_DOUBLE))] default_SituationMention :: SituationMention default_SituationMention = SituationMention{ situationMention_uuid = Uuid_Types.default_UUID, @@ -513,7 +502,6 @@ 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 @@ -536,10 +524,10 @@ ] 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 + [ (\_v120 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v120))) $ situationMentionSet_uuid record + , (\_v120 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v120))) $ situationMentionSet_metadata record + , (\_v120 -> P.Just (3, ("mentionList",T.TList (T.T_STRUCT typemap_SituationMention) $ P.map (\_v122 -> from_SituationMention _v122) $ Vector.toList _v120))) $ situationMentionSet_mentionList record + , (\_v120 -> (4, ("linkingList",T.TList (T.T_STRUCT Linking_Types.typemap_Linking) $ P.map (\_v124 -> Linking_Types.from_Linking _v124) $ Vector.toList _v120))) <$> 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 @@ -547,10 +535,10 @@ 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) + situationMentionSet_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val126) -> (case _val126 of {T.TStruct _val127 -> (Uuid_Types.to_UUID (T.TStruct _val127)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + situationMentionSet_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val126) -> (case _val126 of {T.TStruct _val128 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val128)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + situationMentionSet_mentionList = P.maybe (P.error "Missing required field: mentionList") (\(_,_val126) -> (case _val126 of {T.TList _ _val129 -> (Vector.fromList $ P.map (\_v130 -> (case _v130 of {T.TStruct _val131 -> (to_SituationMention (T.TStruct _val131)); _ -> P.error "wrong type"})) _val129); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + situationMentionSet_linkingList = P.maybe (P.Nothing) (\(_,_val126) -> P.Just (case _val126 of {T.TList _ _val132 -> (Vector.fromList $ P.map (\_v133 -> (case _v133 of {T.TStruct _val134 -> (Linking_Types.to_Linking (T.TStruct _val134)); _ -> P.error "wrong type"})) _val132); _ -> 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 diff --git a/src/Data/Concrete/Autogen/Structure_Types.hs b/src/Data/Concrete/Autogen/Structure_Types.hs --- a/src/Data/Concrete/Autogen/Structure_Types.hs +++ b/src/Data/Concrete/Autogen/Structure_Types.hs @@ -56,62 +56,112 @@ hashWithSalt salt = H.hashWithSalt salt P.. P.fromEnum instance QC.Arbitrary TokenizationKind where arbitrary = QC.elements (P.enumFromTo P.minBound P.maxBound) -data Token = Token { token_tokenIndex :: I.Int32 - , token_text :: P.Maybe LT.Text - , token_textSpan :: P.Maybe Spans_Types.TextSpan - , token_rawTextSpan :: P.Maybe Spans_Types.TextSpan - , token_audioSpan :: P.Maybe Spans_Types.AudioSpan +data Constituent = Constituent { constituent_id :: I.Int32 + , constituent_tag :: P.Maybe LT.Text + , constituent_childList :: (Vector.Vector I.Int32) + , constituent_headChildIndex :: P.Maybe I.Int32 + , constituent_start :: P.Maybe I.Int32 + , constituent_ending :: P.Maybe I.Int32 } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable Token where - hashWithSalt salt record = salt `H.hashWithSalt` token_tokenIndex record `H.hashWithSalt` token_text record `H.hashWithSalt` token_textSpan record `H.hashWithSalt` token_rawTextSpan record `H.hashWithSalt` token_audioSpan record -instance QC.Arbitrary Token where - arbitrary = M.liftM Token (QC.arbitrary) +instance H.Hashable Constituent where + hashWithSalt salt record = salt `H.hashWithSalt` constituent_id record `H.hashWithSalt` constituent_tag record `H.hashWithSalt` constituent_childList record `H.hashWithSalt` constituent_headChildIndex record `H.hashWithSalt` constituent_start record `H.hashWithSalt` constituent_ending record +instance QC.Arbitrary Constituent where + arbitrary = M.liftM Constituent (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) - shrink obj | obj == default_Token = [] + shrink obj | obj == default_Constituent = [] | P.otherwise = M.catMaybes - [ if obj == default_Token{token_tokenIndex = token_tokenIndex obj} then P.Nothing else P.Just $ default_Token{token_tokenIndex = token_tokenIndex obj} - , if obj == default_Token{token_text = token_text obj} then P.Nothing else P.Just $ default_Token{token_text = token_text obj} - , if obj == default_Token{token_textSpan = token_textSpan obj} then P.Nothing else P.Just $ default_Token{token_textSpan = token_textSpan obj} - , if obj == default_Token{token_rawTextSpan = token_rawTextSpan obj} then P.Nothing else P.Just $ default_Token{token_rawTextSpan = token_rawTextSpan obj} - , if obj == default_Token{token_audioSpan = token_audioSpan obj} then P.Nothing else P.Just $ default_Token{token_audioSpan = token_audioSpan obj} + [ if obj == default_Constituent{constituent_id = constituent_id obj} then P.Nothing else P.Just $ default_Constituent{constituent_id = constituent_id obj} + , if obj == default_Constituent{constituent_tag = constituent_tag obj} then P.Nothing else P.Just $ default_Constituent{constituent_tag = constituent_tag obj} + , if obj == default_Constituent{constituent_childList = constituent_childList obj} then P.Nothing else P.Just $ default_Constituent{constituent_childList = constituent_childList obj} + , if obj == default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj} then P.Nothing else P.Just $ default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj} + , if obj == default_Constituent{constituent_start = constituent_start obj} then P.Nothing else P.Just $ default_Constituent{constituent_start = constituent_start obj} + , if obj == default_Constituent{constituent_ending = constituent_ending obj} then P.Nothing else P.Just $ default_Constituent{constituent_ending = constituent_ending obj} ] -from_Token :: Token -> T.ThriftVal -from_Token record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v2 -> P.Just (1, ("tokenIndex",T.TI32 _v2))) $ token_tokenIndex record - , (\_v2 -> (2, ("text",T.TString $ E.encodeUtf8 _v2))) <$> token_text record - , (\_v2 -> (3, ("textSpan",Spans_Types.from_TextSpan _v2))) <$> token_textSpan record - , (\_v2 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v2))) <$> token_rawTextSpan record - , (\_v2 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v2))) <$> token_audioSpan record +from_Constituent :: Constituent -> T.ThriftVal +from_Constituent record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v2 -> P.Just (1, ("id",T.TI32 _v2))) $ constituent_id record + , (\_v2 -> (2, ("tag",T.TString $ E.encodeUtf8 _v2))) <$> constituent_tag record + , (\_v2 -> P.Just (3, ("childList",T.TList T.T_I32 $ P.map (\_v4 -> T.TI32 _v4) $ Vector.toList _v2))) $ constituent_childList record + , (\_v2 -> (4, ("headChildIndex",T.TI32 _v2))) <$> constituent_headChildIndex record + , (\_v2 -> (5, ("start",T.TI32 _v2))) <$> constituent_start record + , (\_v2 -> (6, ("ending",T.TI32 _v2))) <$> constituent_ending record ] -write_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> P.IO () -write_Token oprot record = T.writeVal oprot $ from_Token record -encode_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> LBS.ByteString -encode_Token oprot record = T.serializeVal oprot $ from_Token record -to_Token :: T.ThriftVal -> Token -to_Token (T.TStruct fields) = Token{ - token_tokenIndex = P.maybe (P.error "Missing required field: tokenIndex") (\(_,_val4) -> (case _val4 of {T.TI32 _val5 -> _val5; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - token_text = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TString _val6 -> E.decodeUtf8 _val6; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - token_textSpan = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TStruct _val7 -> (Spans_Types.to_TextSpan (T.TStruct _val7)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - token_rawTextSpan = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TStruct _val8 -> (Spans_Types.to_TextSpan (T.TStruct _val8)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), - token_audioSpan = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TStruct _val9 -> (Spans_Types.to_AudioSpan (T.TStruct _val9)); _ -> P.error "wrong type"})) (Map.lookup (5) fields) +write_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> P.IO () +write_Constituent oprot record = T.writeVal oprot $ from_Constituent record +encode_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> LBS.ByteString +encode_Constituent oprot record = T.serializeVal oprot $ from_Constituent record +to_Constituent :: T.ThriftVal -> Constituent +to_Constituent (T.TStruct fields) = Constituent{ + constituent_id = P.maybe (P.error "Missing required field: id") (\(_,_val6) -> (case _val6 of {T.TI32 _val7 -> _val7; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + constituent_tag = P.maybe (P.Nothing) (\(_,_val6) -> P.Just (case _val6 of {T.TString _val8 -> E.decodeUtf8 _val8; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + constituent_childList = P.maybe (P.error "Missing required field: childList") (\(_,_val6) -> (case _val6 of {T.TList _ _val9 -> (Vector.fromList $ P.map (\_v10 -> (case _v10 of {T.TI32 _val11 -> _val11; _ -> P.error "wrong type"})) _val9); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + constituent_headChildIndex = P.maybe (constituent_headChildIndex default_Constituent) (\(_,_val6) -> P.Just (case _val6 of {T.TI32 _val12 -> _val12; _ -> P.error "wrong type"})) (Map.lookup (4) fields), + constituent_start = P.maybe (P.Nothing) (\(_,_val6) -> P.Just (case _val6 of {T.TI32 _val13 -> _val13; _ -> P.error "wrong type"})) (Map.lookup (5) fields), + constituent_ending = P.maybe (P.Nothing) (\(_,_val6) -> P.Just (case _val6 of {T.TI32 _val14 -> _val14; _ -> P.error "wrong type"})) (Map.lookup (6) fields) } -to_Token _ = P.error "not a struct" -read_Token :: (T.Transport t, T.Protocol p) => p t -> P.IO Token -read_Token iprot = to_Token <$> T.readVal iprot (T.T_STRUCT typemap_Token) -decode_Token :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Token -decode_Token iprot bs = to_Token $ T.deserializeVal iprot (T.T_STRUCT typemap_Token) bs -typemap_Token :: T.TypeMap -typemap_Token = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("text",T.T_STRING)),(3,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(4,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan)))] -default_Token :: Token -default_Token = Token{ - token_tokenIndex = 0, - token_text = P.Nothing, - token_textSpan = P.Nothing, - token_rawTextSpan = P.Nothing, - token_audioSpan = P.Nothing} +to_Constituent _ = P.error "not a struct" +read_Constituent :: (T.Transport t, T.Protocol p) => p t -> P.IO Constituent +read_Constituent iprot = to_Constituent <$> T.readVal iprot (T.T_STRUCT typemap_Constituent) +decode_Constituent :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Constituent +decode_Constituent iprot bs = to_Constituent $ T.deserializeVal iprot (T.T_STRUCT typemap_Constituent) bs +typemap_Constituent :: T.TypeMap +typemap_Constituent = Map.fromList [(1,("id",T.T_I32)),(2,("tag",T.T_STRING)),(3,("childList",(T.T_LIST T.T_I32))),(4,("headChildIndex",T.T_I32)),(5,("start",T.T_I32)),(6,("ending",T.T_I32))] +default_Constituent :: Constituent +default_Constituent = Constituent{ + constituent_id = 0, + constituent_tag = P.Nothing, + constituent_childList = Vector.empty, + constituent_headChildIndex = P.Just (-1), + constituent_start = P.Nothing, + constituent_ending = P.Nothing} +data Parse = Parse { parse_uuid :: Uuid_Types.UUID + , parse_metadata :: Metadata_Types.AnnotationMetadata + , parse_constituentList :: (Vector.Vector Constituent) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable Parse where + hashWithSalt salt record = salt `H.hashWithSalt` parse_uuid record `H.hashWithSalt` parse_metadata record `H.hashWithSalt` parse_constituentList record +instance QC.Arbitrary Parse where + arbitrary = M.liftM Parse (QC.arbitrary) + `M.ap`(QC.arbitrary) + `M.ap`(QC.arbitrary) + shrink obj | obj == default_Parse = [] + | P.otherwise = M.catMaybes + [ if obj == default_Parse{parse_uuid = parse_uuid obj} then P.Nothing else P.Just $ default_Parse{parse_uuid = parse_uuid obj} + , if obj == default_Parse{parse_metadata = parse_metadata obj} then P.Nothing else P.Just $ default_Parse{parse_metadata = parse_metadata obj} + , if obj == default_Parse{parse_constituentList = parse_constituentList obj} then P.Nothing else P.Just $ default_Parse{parse_constituentList = parse_constituentList obj} + ] +from_Parse :: Parse -> T.ThriftVal +from_Parse record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v17 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v17))) $ parse_uuid record + , (\_v17 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v17))) $ parse_metadata record + , (\_v17 -> P.Just (3, ("constituentList",T.TList (T.T_STRUCT typemap_Constituent) $ P.map (\_v19 -> from_Constituent _v19) $ Vector.toList _v17))) $ parse_constituentList record + ] +write_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> P.IO () +write_Parse oprot record = T.writeVal oprot $ from_Parse record +encode_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> LBS.ByteString +encode_Parse oprot record = T.serializeVal oprot $ from_Parse record +to_Parse :: T.ThriftVal -> Parse +to_Parse (T.TStruct fields) = Parse{ + parse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val21) -> (case _val21 of {T.TStruct _val22 -> (Uuid_Types.to_UUID (T.TStruct _val22)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + parse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val21) -> (case _val21 of {T.TStruct _val23 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val23)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + parse_constituentList = P.maybe (P.error "Missing required field: constituentList") (\(_,_val21) -> (case _val21 of {T.TList _ _val24 -> (Vector.fromList $ P.map (\_v25 -> (case _v25 of {T.TStruct _val26 -> (to_Constituent (T.TStruct _val26)); _ -> P.error "wrong type"})) _val24); _ -> P.error "wrong type"})) (Map.lookup (3) fields) + } +to_Parse _ = P.error "not a struct" +read_Parse :: (T.Transport t, T.Protocol p) => p t -> P.IO Parse +read_Parse iprot = to_Parse <$> T.readVal iprot (T.T_STRUCT typemap_Parse) +decode_Parse :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Parse +decode_Parse iprot bs = to_Parse $ T.deserializeVal iprot (T.T_STRUCT typemap_Parse) bs +typemap_Parse :: T.TypeMap +typemap_Parse = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("constituentList",(T.T_LIST (T.T_STRUCT typemap_Constituent))))] +default_Parse :: Parse +default_Parse = Parse{ + parse_uuid = Uuid_Types.default_UUID, + parse_metadata = Metadata_Types.default_AnnotationMetadata, + parse_constituentList = Vector.empty} data ConstituentRef = ConstituentRef { constituentRef_parseId :: Uuid_Types.UUID , constituentRef_constituentIndex :: I.Int32 } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) @@ -127,8 +177,8 @@ ] from_ConstituentRef :: ConstituentRef -> T.ThriftVal from_ConstituentRef record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v12 -> P.Just (1, ("parseId",Uuid_Types.from_UUID _v12))) $ constituentRef_parseId record - , (\_v12 -> P.Just (2, ("constituentIndex",T.TI32 _v12))) $ constituentRef_constituentIndex record + [ (\_v29 -> P.Just (1, ("parseId",Uuid_Types.from_UUID _v29))) $ constituentRef_parseId record + , (\_v29 -> P.Just (2, ("constituentIndex",T.TI32 _v29))) $ constituentRef_constituentIndex record ] write_ConstituentRef :: (T.Protocol p, T.Transport t) => p t -> ConstituentRef -> P.IO () write_ConstituentRef oprot record = T.writeVal oprot $ from_ConstituentRef record @@ -136,8 +186,8 @@ encode_ConstituentRef oprot record = T.serializeVal oprot $ from_ConstituentRef record to_ConstituentRef :: T.ThriftVal -> ConstituentRef to_ConstituentRef (T.TStruct fields) = ConstituentRef{ - constituentRef_parseId = P.maybe (P.error "Missing required field: parseId") (\(_,_val14) -> (case _val14 of {T.TStruct _val15 -> (Uuid_Types.to_UUID (T.TStruct _val15)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - constituentRef_constituentIndex = P.maybe (P.error "Missing required field: constituentIndex") (\(_,_val14) -> (case _val14 of {T.TI32 _val16 -> _val16; _ -> P.error "wrong type"})) (Map.lookup (2) fields) + constituentRef_parseId = P.maybe (P.error "Missing required field: parseId") (\(_,_val31) -> (case _val31 of {T.TStruct _val32 -> (Uuid_Types.to_UUID (T.TStruct _val32)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + constituentRef_constituentIndex = P.maybe (P.error "Missing required field: constituentIndex") (\(_,_val31) -> (case _val31 of {T.TI32 _val33 -> _val33; _ -> P.error "wrong type"})) (Map.lookup (2) fields) } to_ConstituentRef _ = P.error "not a struct" read_ConstituentRef :: (T.Transport t, T.Protocol p) => p t -> P.IO ConstituentRef @@ -150,174 +200,6 @@ default_ConstituentRef = ConstituentRef{ constituentRef_parseId = Uuid_Types.default_UUID, constituentRef_constituentIndex = 0} -data TokenRefSequence = TokenRefSequence { tokenRefSequence_tokenIndexList :: (Vector.Vector I.Int32) - , tokenRefSequence_anchorTokenIndex :: P.Maybe I.Int32 - , tokenRefSequence_tokenizationId :: Uuid_Types.UUID - , tokenRefSequence_textSpan :: P.Maybe Spans_Types.TextSpan - , tokenRefSequence_rawTextSpan :: P.Maybe Spans_Types.TextSpan - , tokenRefSequence_audioSpan :: P.Maybe Spans_Types.AudioSpan - } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable TokenRefSequence where - hashWithSalt salt record = salt `H.hashWithSalt` tokenRefSequence_tokenIndexList record `H.hashWithSalt` tokenRefSequence_anchorTokenIndex record `H.hashWithSalt` tokenRefSequence_tokenizationId record `H.hashWithSalt` tokenRefSequence_textSpan record `H.hashWithSalt` tokenRefSequence_rawTextSpan record `H.hashWithSalt` tokenRefSequence_audioSpan record -instance QC.Arbitrary TokenRefSequence where - arbitrary = M.liftM TokenRefSequence (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) - shrink obj | obj == default_TokenRefSequence = [] - | P.otherwise = M.catMaybes - [ if obj == default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj} - , if obj == default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj} - , if obj == default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj} - , if obj == default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj} - , if obj == default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj} - , if obj == default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj} - ] -from_TokenRefSequence :: TokenRefSequence -> T.ThriftVal -from_TokenRefSequence record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v19 -> P.Just (1, ("tokenIndexList",T.TList T.T_I32 $ P.map (\_v21 -> T.TI32 _v21) $ Vector.toList _v19))) $ tokenRefSequence_tokenIndexList record - , (\_v19 -> (2, ("anchorTokenIndex",T.TI32 _v19))) <$> tokenRefSequence_anchorTokenIndex record - , (\_v19 -> P.Just (3, ("tokenizationId",Uuid_Types.from_UUID _v19))) $ tokenRefSequence_tokenizationId record - , (\_v19 -> (4, ("textSpan",Spans_Types.from_TextSpan _v19))) <$> tokenRefSequence_textSpan record - , (\_v19 -> (5, ("rawTextSpan",Spans_Types.from_TextSpan _v19))) <$> tokenRefSequence_rawTextSpan record - , (\_v19 -> (6, ("audioSpan",Spans_Types.from_AudioSpan _v19))) <$> tokenRefSequence_audioSpan record - ] -write_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> P.IO () -write_TokenRefSequence oprot record = T.writeVal oprot $ from_TokenRefSequence record -encode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> LBS.ByteString -encode_TokenRefSequence oprot record = T.serializeVal oprot $ from_TokenRefSequence record -to_TokenRefSequence :: T.ThriftVal -> TokenRefSequence -to_TokenRefSequence (T.TStruct fields) = TokenRefSequence{ - tokenRefSequence_tokenIndexList = P.maybe (P.error "Missing required field: tokenIndexList") (\(_,_val23) -> (case _val23 of {T.TList _ _val24 -> (Vector.fromList $ P.map (\_v25 -> (case _v25 of {T.TI32 _val26 -> _val26; _ -> P.error "wrong type"})) _val24); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - tokenRefSequence_anchorTokenIndex = P.maybe (tokenRefSequence_anchorTokenIndex default_TokenRefSequence) (\(_,_val23) -> P.Just (case _val23 of {T.TI32 _val27 -> _val27; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - tokenRefSequence_tokenizationId = P.maybe (P.error "Missing required field: tokenizationId") (\(_,_val23) -> (case _val23 of {T.TStruct _val28 -> (Uuid_Types.to_UUID (T.TStruct _val28)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - tokenRefSequence_textSpan = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val29 -> (Spans_Types.to_TextSpan (T.TStruct _val29)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), - tokenRefSequence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val30 -> (Spans_Types.to_TextSpan (T.TStruct _val30)); _ -> P.error "wrong type"})) (Map.lookup (5) fields), - tokenRefSequence_audioSpan = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val31 -> (Spans_Types.to_AudioSpan (T.TStruct _val31)); _ -> P.error "wrong type"})) (Map.lookup (6) fields) - } -to_TokenRefSequence _ = P.error "not a struct" -read_TokenRefSequence :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenRefSequence -read_TokenRefSequence iprot = to_TokenRefSequence <$> T.readVal iprot (T.T_STRUCT typemap_TokenRefSequence) -decode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenRefSequence -decode_TokenRefSequence iprot bs = to_TokenRefSequence $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenRefSequence) bs -typemap_TokenRefSequence :: T.TypeMap -typemap_TokenRefSequence = Map.fromList [(1,("tokenIndexList",(T.T_LIST T.T_I32))),(2,("anchorTokenIndex",T.T_I32)),(3,("tokenizationId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(6,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan)))] -default_TokenRefSequence :: TokenRefSequence -default_TokenRefSequence = TokenRefSequence{ - tokenRefSequence_tokenIndexList = Vector.empty, - tokenRefSequence_anchorTokenIndex = P.Just (-1), - tokenRefSequence_tokenizationId = Uuid_Types.default_UUID, - tokenRefSequence_textSpan = P.Nothing, - tokenRefSequence_rawTextSpan = P.Nothing, - tokenRefSequence_audioSpan = P.Nothing} -data TaggedToken = TaggedToken { taggedToken_tokenIndex :: P.Maybe I.Int32 - , taggedToken_tag :: P.Maybe LT.Text - , taggedToken_confidence :: P.Maybe P.Double - , taggedToken_tagList :: P.Maybe (Vector.Vector LT.Text) - , taggedToken_confidenceList :: P.Maybe (Vector.Vector P.Double) - } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable TaggedToken where - hashWithSalt salt record = salt `H.hashWithSalt` taggedToken_tokenIndex record `H.hashWithSalt` taggedToken_tag record `H.hashWithSalt` taggedToken_confidence record `H.hashWithSalt` taggedToken_tagList record `H.hashWithSalt` taggedToken_confidenceList record -instance QC.Arbitrary TaggedToken where - arbitrary = M.liftM TaggedToken (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_TaggedToken = [] - | P.otherwise = M.catMaybes - [ if obj == default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj} - , if obj == default_TaggedToken{taggedToken_tag = taggedToken_tag obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tag = taggedToken_tag obj} - , if obj == default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj} - , if obj == default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj} - , if obj == default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj} - ] -from_TaggedToken :: TaggedToken -> T.ThriftVal -from_TaggedToken record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v34 -> (1, ("tokenIndex",T.TI32 _v34))) <$> taggedToken_tokenIndex record - , (\_v34 -> (2, ("tag",T.TString $ E.encodeUtf8 _v34))) <$> taggedToken_tag record - , (\_v34 -> (3, ("confidence",T.TDouble _v34))) <$> taggedToken_confidence record - , (\_v34 -> (4, ("tagList",T.TList T.T_STRING $ P.map (\_v36 -> T.TString $ E.encodeUtf8 _v36) $ Vector.toList _v34))) <$> taggedToken_tagList record - , (\_v34 -> (5, ("confidenceList",T.TList T.T_DOUBLE $ P.map (\_v38 -> T.TDouble _v38) $ Vector.toList _v34))) <$> taggedToken_confidenceList record - ] -write_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> P.IO () -write_TaggedToken oprot record = T.writeVal oprot $ from_TaggedToken record -encode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> LBS.ByteString -encode_TaggedToken oprot record = T.serializeVal oprot $ from_TaggedToken record -to_TaggedToken :: T.ThriftVal -> TaggedToken -to_TaggedToken (T.TStruct fields) = TaggedToken{ - taggedToken_tokenIndex = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TI32 _val41 -> _val41; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - taggedToken_tag = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TString _val42 -> E.decodeUtf8 _val42; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - taggedToken_confidence = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TDouble _val43 -> _val43; _ -> P.error "wrong type"})) (Map.lookup (3) fields), - taggedToken_tagList = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TList _ _val44 -> (Vector.fromList $ P.map (\_v45 -> (case _v45 of {T.TString _val46 -> E.decodeUtf8 _val46; _ -> P.error "wrong type"})) _val44); _ -> P.error "wrong type"})) (Map.lookup (4) fields), - taggedToken_confidenceList = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TList _ _val47 -> (Vector.fromList $ P.map (\_v48 -> (case _v48 of {T.TDouble _val49 -> _val49; _ -> P.error "wrong type"})) _val47); _ -> P.error "wrong type"})) (Map.lookup (5) fields) - } -to_TaggedToken _ = P.error "not a struct" -read_TaggedToken :: (T.Transport t, T.Protocol p) => p t -> P.IO TaggedToken -read_TaggedToken iprot = to_TaggedToken <$> T.readVal iprot (T.T_STRUCT typemap_TaggedToken) -decode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TaggedToken -decode_TaggedToken iprot bs = to_TaggedToken $ T.deserializeVal iprot (T.T_STRUCT typemap_TaggedToken) bs -typemap_TaggedToken :: T.TypeMap -typemap_TaggedToken = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("tag",T.T_STRING)),(3,("confidence",T.T_DOUBLE)),(4,("tagList",(T.T_LIST T.T_STRING))),(5,("confidenceList",(T.T_LIST T.T_DOUBLE)))] -default_TaggedToken :: TaggedToken -default_TaggedToken = TaggedToken{ - taggedToken_tokenIndex = P.Nothing, - taggedToken_tag = P.Nothing, - taggedToken_confidence = P.Nothing, - taggedToken_tagList = P.Nothing, - taggedToken_confidenceList = P.Nothing} -data TokenTagging = TokenTagging { tokenTagging_uuid :: Uuid_Types.UUID - , tokenTagging_metadata :: Metadata_Types.AnnotationMetadata - , tokenTagging_taggedTokenList :: (Vector.Vector TaggedToken) - , tokenTagging_taggingType :: P.Maybe LT.Text - } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable TokenTagging where - hashWithSalt salt record = salt `H.hashWithSalt` tokenTagging_uuid record `H.hashWithSalt` tokenTagging_metadata record `H.hashWithSalt` tokenTagging_taggedTokenList record `H.hashWithSalt` tokenTagging_taggingType record -instance QC.Arbitrary TokenTagging where - arbitrary = M.liftM TokenTagging (QC.arbitrary) - `M.ap`(QC.arbitrary) - `M.ap`(QC.arbitrary) - `M.ap`(M.liftM P.Just QC.arbitrary) - shrink obj | obj == default_TokenTagging = [] - | P.otherwise = M.catMaybes - [ if obj == default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj} - , if obj == default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj} - , if obj == default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj} - , if obj == default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj} - ] -from_TokenTagging :: TokenTagging -> T.ThriftVal -from_TokenTagging record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v52 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v52))) $ tokenTagging_uuid record - , (\_v52 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v52))) $ tokenTagging_metadata record - , (\_v52 -> P.Just (3, ("taggedTokenList",T.TList (T.T_STRUCT typemap_TaggedToken) $ P.map (\_v54 -> from_TaggedToken _v54) $ Vector.toList _v52))) $ tokenTagging_taggedTokenList record - , (\_v52 -> (4, ("taggingType",T.TString $ E.encodeUtf8 _v52))) <$> tokenTagging_taggingType record - ] -write_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> P.IO () -write_TokenTagging oprot record = T.writeVal oprot $ from_TokenTagging record -encode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> LBS.ByteString -encode_TokenTagging oprot record = T.serializeVal oprot $ from_TokenTagging record -to_TokenTagging :: T.ThriftVal -> TokenTagging -to_TokenTagging (T.TStruct fields) = TokenTagging{ - tokenTagging_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val56) -> (case _val56 of {T.TStruct _val57 -> (Uuid_Types.to_UUID (T.TStruct _val57)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - tokenTagging_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val56) -> (case _val56 of {T.TStruct _val58 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val58)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - tokenTagging_taggedTokenList = P.maybe (P.error "Missing required field: taggedTokenList") (\(_,_val56) -> (case _val56 of {T.TList _ _val59 -> (Vector.fromList $ P.map (\_v60 -> (case _v60 of {T.TStruct _val61 -> (to_TaggedToken (T.TStruct _val61)); _ -> P.error "wrong type"})) _val59); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - tokenTagging_taggingType = P.maybe (P.Nothing) (\(_,_val56) -> P.Just (case _val56 of {T.TString _val62 -> E.decodeUtf8 _val62; _ -> P.error "wrong type"})) (Map.lookup (4) fields) - } -to_TokenTagging _ = P.error "not a struct" -read_TokenTagging :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenTagging -read_TokenTagging iprot = to_TokenTagging <$> T.readVal iprot (T.T_STRUCT typemap_TokenTagging) -decode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenTagging -decode_TokenTagging iprot bs = to_TokenTagging $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenTagging) bs -typemap_TokenTagging :: T.TypeMap -typemap_TokenTagging = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("taggedTokenList",(T.T_LIST (T.T_STRUCT typemap_TaggedToken)))),(4,("taggingType",T.T_STRING))] -default_TokenTagging :: TokenTagging -default_TokenTagging = TokenTagging{ - tokenTagging_uuid = Uuid_Types.default_UUID, - tokenTagging_metadata = Metadata_Types.default_AnnotationMetadata, - tokenTagging_taggedTokenList = Vector.empty, - tokenTagging_taggingType = P.Nothing} data Dependency = Dependency { dependency_gov :: P.Maybe I.Int32 , dependency_dep :: I.Int32 , dependency_edgeType :: P.Maybe LT.Text @@ -336,9 +218,9 @@ ] from_Dependency :: Dependency -> T.ThriftVal from_Dependency record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v65 -> (1, ("gov",T.TI32 _v65))) <$> dependency_gov record - , (\_v65 -> P.Just (2, ("dep",T.TI32 _v65))) $ dependency_dep record - , (\_v65 -> (3, ("edgeType",T.TString $ E.encodeUtf8 _v65))) <$> dependency_edgeType record + [ (\_v36 -> (1, ("gov",T.TI32 _v36))) <$> dependency_gov record + , (\_v36 -> P.Just (2, ("dep",T.TI32 _v36))) $ dependency_dep record + , (\_v36 -> (3, ("edgeType",T.TString $ E.encodeUtf8 _v36))) <$> dependency_edgeType record ] write_Dependency :: (T.Protocol p, T.Transport t) => p t -> Dependency -> P.IO () write_Dependency oprot record = T.writeVal oprot $ from_Dependency record @@ -346,9 +228,9 @@ encode_Dependency oprot record = T.serializeVal oprot $ from_Dependency record to_Dependency :: T.ThriftVal -> Dependency to_Dependency (T.TStruct fields) = Dependency{ - dependency_gov = P.maybe (dependency_gov default_Dependency) (\(_,_val67) -> P.Just (case _val67 of {T.TI32 _val68 -> _val68; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - dependency_dep = P.maybe (P.error "Missing required field: dep") (\(_,_val67) -> (case _val67 of {T.TI32 _val69 -> _val69; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - dependency_edgeType = P.maybe (P.Nothing) (\(_,_val67) -> P.Just (case _val67 of {T.TString _val70 -> E.decodeUtf8 _val70; _ -> P.error "wrong type"})) (Map.lookup (3) fields) + dependency_gov = P.maybe (dependency_gov default_Dependency) (\(_,_val38) -> P.Just (case _val38 of {T.TI32 _val39 -> _val39; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + dependency_dep = P.maybe (P.error "Missing required field: dep") (\(_,_val38) -> (case _val38 of {T.TI32 _val40 -> _val40; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + dependency_edgeType = P.maybe (P.Nothing) (\(_,_val38) -> P.Just (case _val38 of {T.TString _val41 -> E.decodeUtf8 _val41; _ -> P.error "wrong type"})) (Map.lookup (3) fields) } to_Dependency _ = P.error "not a struct" read_Dependency :: (T.Transport t, T.Protocol p) => p t -> P.IO Dependency @@ -383,10 +265,10 @@ ] from_DependencyParseStructure :: DependencyParseStructure -> T.ThriftVal from_DependencyParseStructure record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v73 -> P.Just (1, ("isAcyclic",T.TBool _v73))) $ dependencyParseStructure_isAcyclic record - , (\_v73 -> P.Just (2, ("isConnected",T.TBool _v73))) $ dependencyParseStructure_isConnected record - , (\_v73 -> P.Just (3, ("isSingleHeaded",T.TBool _v73))) $ dependencyParseStructure_isSingleHeaded record - , (\_v73 -> P.Just (4, ("isProjective",T.TBool _v73))) $ dependencyParseStructure_isProjective record + [ (\_v44 -> P.Just (1, ("isAcyclic",T.TBool _v44))) $ dependencyParseStructure_isAcyclic record + , (\_v44 -> P.Just (2, ("isConnected",T.TBool _v44))) $ dependencyParseStructure_isConnected record + , (\_v44 -> P.Just (3, ("isSingleHeaded",T.TBool _v44))) $ dependencyParseStructure_isSingleHeaded record + , (\_v44 -> P.Just (4, ("isProjective",T.TBool _v44))) $ dependencyParseStructure_isProjective record ] write_DependencyParseStructure :: (T.Protocol p, T.Transport t) => p t -> DependencyParseStructure -> P.IO () write_DependencyParseStructure oprot record = T.writeVal oprot $ from_DependencyParseStructure record @@ -394,10 +276,10 @@ encode_DependencyParseStructure oprot record = T.serializeVal oprot $ from_DependencyParseStructure record to_DependencyParseStructure :: T.ThriftVal -> DependencyParseStructure to_DependencyParseStructure (T.TStruct fields) = DependencyParseStructure{ - dependencyParseStructure_isAcyclic = P.maybe (P.error "Missing required field: isAcyclic") (\(_,_val75) -> (case _val75 of {T.TBool _val76 -> _val76; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - dependencyParseStructure_isConnected = P.maybe (P.error "Missing required field: isConnected") (\(_,_val75) -> (case _val75 of {T.TBool _val77 -> _val77; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - dependencyParseStructure_isSingleHeaded = P.maybe (P.error "Missing required field: isSingleHeaded") (\(_,_val75) -> (case _val75 of {T.TBool _val78 -> _val78; _ -> P.error "wrong type"})) (Map.lookup (3) fields), - dependencyParseStructure_isProjective = P.maybe (P.error "Missing required field: isProjective") (\(_,_val75) -> (case _val75 of {T.TBool _val79 -> _val79; _ -> P.error "wrong type"})) (Map.lookup (4) fields) + dependencyParseStructure_isAcyclic = P.maybe (P.error "Missing required field: isAcyclic") (\(_,_val46) -> (case _val46 of {T.TBool _val47 -> _val47; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + dependencyParseStructure_isConnected = P.maybe (P.error "Missing required field: isConnected") (\(_,_val46) -> (case _val46 of {T.TBool _val48 -> _val48; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + dependencyParseStructure_isSingleHeaded = P.maybe (P.error "Missing required field: isSingleHeaded") (\(_,_val46) -> (case _val46 of {T.TBool _val49 -> _val49; _ -> P.error "wrong type"})) (Map.lookup (3) fields), + dependencyParseStructure_isProjective = P.maybe (P.error "Missing required field: isProjective") (\(_,_val46) -> (case _val46 of {T.TBool _val50 -> _val50; _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_DependencyParseStructure _ = P.error "not a struct" read_DependencyParseStructure :: (T.Transport t, T.Protocol p) => p t -> P.IO DependencyParseStructure @@ -433,10 +315,10 @@ ] from_DependencyParse :: DependencyParse -> T.ThriftVal from_DependencyParse record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v82 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v82))) $ dependencyParse_uuid record - , (\_v82 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v82))) $ dependencyParse_metadata record - , (\_v82 -> P.Just (3, ("dependencyList",T.TList (T.T_STRUCT typemap_Dependency) $ P.map (\_v84 -> from_Dependency _v84) $ Vector.toList _v82))) $ dependencyParse_dependencyList record - , (\_v82 -> (4, ("structureInformation",from_DependencyParseStructure _v82))) <$> dependencyParse_structureInformation record + [ (\_v53 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v53))) $ dependencyParse_uuid record + , (\_v53 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v53))) $ dependencyParse_metadata record + , (\_v53 -> P.Just (3, ("dependencyList",T.TList (T.T_STRUCT typemap_Dependency) $ P.map (\_v55 -> from_Dependency _v55) $ Vector.toList _v53))) $ dependencyParse_dependencyList record + , (\_v53 -> (4, ("structureInformation",from_DependencyParseStructure _v53))) <$> dependencyParse_structureInformation record ] write_DependencyParse :: (T.Protocol p, T.Transport t) => p t -> DependencyParse -> P.IO () write_DependencyParse oprot record = T.writeVal oprot $ from_DependencyParse record @@ -444,10 +326,10 @@ encode_DependencyParse oprot record = T.serializeVal oprot $ from_DependencyParse record to_DependencyParse :: T.ThriftVal -> DependencyParse to_DependencyParse (T.TStruct fields) = DependencyParse{ - dependencyParse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val86) -> (case _val86 of {T.TStruct _val87 -> (Uuid_Types.to_UUID (T.TStruct _val87)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - dependencyParse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val86) -> (case _val86 of {T.TStruct _val88 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val88)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - dependencyParse_dependencyList = P.maybe (P.error "Missing required field: dependencyList") (\(_,_val86) -> (case _val86 of {T.TList _ _val89 -> (Vector.fromList $ P.map (\_v90 -> (case _v90 of {T.TStruct _val91 -> (to_Dependency (T.TStruct _val91)); _ -> P.error "wrong type"})) _val89); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - dependencyParse_structureInformation = P.maybe (P.Nothing) (\(_,_val86) -> P.Just (case _val86 of {T.TStruct _val92 -> (to_DependencyParseStructure (T.TStruct _val92)); _ -> P.error "wrong type"})) (Map.lookup (4) fields) + dependencyParse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val57) -> (case _val57 of {T.TStruct _val58 -> (Uuid_Types.to_UUID (T.TStruct _val58)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + dependencyParse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val57) -> (case _val57 of {T.TStruct _val59 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val59)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + dependencyParse_dependencyList = P.maybe (P.error "Missing required field: dependencyList") (\(_,_val57) -> (case _val57 of {T.TList _ _val60 -> (Vector.fromList $ P.map (\_v61 -> (case _v61 of {T.TStruct _val62 -> (to_Dependency (T.TStruct _val62)); _ -> P.error "wrong type"})) _val60); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + dependencyParse_structureInformation = P.maybe (P.Nothing) (\(_,_val57) -> P.Just (case _val57 of {T.TStruct _val63 -> (to_DependencyParseStructure (T.TStruct _val63)); _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_DependencyParse _ = P.error "not a struct" read_DependencyParse :: (T.Transport t, T.Protocol p) => p t -> P.IO DependencyParse @@ -462,112 +344,242 @@ dependencyParse_metadata = Metadata_Types.default_AnnotationMetadata, dependencyParse_dependencyList = Vector.empty, dependencyParse_structureInformation = P.Nothing} -data Constituent = Constituent { constituent_id :: I.Int32 - , constituent_tag :: P.Maybe LT.Text - , constituent_childList :: (Vector.Vector I.Int32) - , constituent_headChildIndex :: P.Maybe I.Int32 - , constituent_start :: P.Maybe I.Int32 - , constituent_ending :: P.Maybe I.Int32 +data Token = Token { token_tokenIndex :: I.Int32 + , token_text :: P.Maybe LT.Text + , token_textSpan :: P.Maybe Spans_Types.TextSpan + , token_rawTextSpan :: P.Maybe Spans_Types.TextSpan + , token_audioSpan :: P.Maybe Spans_Types.AudioSpan } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable Constituent where - hashWithSalt salt record = salt `H.hashWithSalt` constituent_id record `H.hashWithSalt` constituent_tag record `H.hashWithSalt` constituent_childList record `H.hashWithSalt` constituent_headChildIndex record `H.hashWithSalt` constituent_start record `H.hashWithSalt` constituent_ending record -instance QC.Arbitrary Constituent where - arbitrary = M.liftM Constituent (QC.arbitrary) +instance H.Hashable Token where + hashWithSalt salt record = salt `H.hashWithSalt` token_tokenIndex record `H.hashWithSalt` token_text record `H.hashWithSalt` token_textSpan record `H.hashWithSalt` token_rawTextSpan record `H.hashWithSalt` token_audioSpan record +instance QC.Arbitrary Token where + arbitrary = M.liftM Token (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_Token = [] + | P.otherwise = M.catMaybes + [ if obj == default_Token{token_tokenIndex = token_tokenIndex obj} then P.Nothing else P.Just $ default_Token{token_tokenIndex = token_tokenIndex obj} + , if obj == default_Token{token_text = token_text obj} then P.Nothing else P.Just $ default_Token{token_text = token_text obj} + , if obj == default_Token{token_textSpan = token_textSpan obj} then P.Nothing else P.Just $ default_Token{token_textSpan = token_textSpan obj} + , if obj == default_Token{token_rawTextSpan = token_rawTextSpan obj} then P.Nothing else P.Just $ default_Token{token_rawTextSpan = token_rawTextSpan obj} + , if obj == default_Token{token_audioSpan = token_audioSpan obj} then P.Nothing else P.Just $ default_Token{token_audioSpan = token_audioSpan obj} + ] +from_Token :: Token -> T.ThriftVal +from_Token record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v66 -> P.Just (1, ("tokenIndex",T.TI32 _v66))) $ token_tokenIndex record + , (\_v66 -> (2, ("text",T.TString $ E.encodeUtf8 _v66))) <$> token_text record + , (\_v66 -> (3, ("textSpan",Spans_Types.from_TextSpan _v66))) <$> token_textSpan record + , (\_v66 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v66))) <$> token_rawTextSpan record + , (\_v66 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v66))) <$> token_audioSpan record + ] +write_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> P.IO () +write_Token oprot record = T.writeVal oprot $ from_Token record +encode_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> LBS.ByteString +encode_Token oprot record = T.serializeVal oprot $ from_Token record +to_Token :: T.ThriftVal -> Token +to_Token (T.TStruct fields) = Token{ + token_tokenIndex = P.maybe (P.error "Missing required field: tokenIndex") (\(_,_val68) -> (case _val68 of {T.TI32 _val69 -> _val69; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + token_text = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TString _val70 -> E.decodeUtf8 _val70; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + token_textSpan = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TStruct _val71 -> (Spans_Types.to_TextSpan (T.TStruct _val71)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + token_rawTextSpan = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TStruct _val72 -> (Spans_Types.to_TextSpan (T.TStruct _val72)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + token_audioSpan = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TStruct _val73 -> (Spans_Types.to_AudioSpan (T.TStruct _val73)); _ -> P.error "wrong type"})) (Map.lookup (5) fields) + } +to_Token _ = P.error "not a struct" +read_Token :: (T.Transport t, T.Protocol p) => p t -> P.IO Token +read_Token iprot = to_Token <$> T.readVal iprot (T.T_STRUCT typemap_Token) +decode_Token :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Token +decode_Token iprot bs = to_Token $ T.deserializeVal iprot (T.T_STRUCT typemap_Token) bs +typemap_Token :: T.TypeMap +typemap_Token = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("text",T.T_STRING)),(3,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(4,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan)))] +default_Token :: Token +default_Token = Token{ + token_tokenIndex = 0, + token_text = P.Nothing, + token_textSpan = P.Nothing, + token_rawTextSpan = P.Nothing, + token_audioSpan = P.Nothing} +data TokenRefSequence = TokenRefSequence { tokenRefSequence_tokenIndexList :: (Vector.Vector I.Int32) + , tokenRefSequence_anchorTokenIndex :: P.Maybe I.Int32 + , tokenRefSequence_tokenizationId :: Uuid_Types.UUID + , tokenRefSequence_textSpan :: P.Maybe Spans_Types.TextSpan + , tokenRefSequence_rawTextSpan :: P.Maybe Spans_Types.TextSpan + , tokenRefSequence_audioSpan :: P.Maybe Spans_Types.AudioSpan + , tokenRefSequence_dependencies :: P.Maybe (Vector.Vector Dependency) + , tokenRefSequence_constituent :: P.Maybe ConstituentRef + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable TokenRefSequence where + hashWithSalt salt record = salt `H.hashWithSalt` tokenRefSequence_tokenIndexList record `H.hashWithSalt` tokenRefSequence_anchorTokenIndex record `H.hashWithSalt` tokenRefSequence_tokenizationId record `H.hashWithSalt` tokenRefSequence_textSpan record `H.hashWithSalt` tokenRefSequence_rawTextSpan record `H.hashWithSalt` tokenRefSequence_audioSpan record `H.hashWithSalt` tokenRefSequence_dependencies record `H.hashWithSalt` tokenRefSequence_constituent record +instance QC.Arbitrary TokenRefSequence where + arbitrary = M.liftM TokenRefSequence (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) - shrink obj | obj == default_Constituent = [] + `M.ap`(M.liftM P.Just QC.arbitrary) + `M.ap`(M.liftM P.Just QC.arbitrary) + shrink obj | obj == default_TokenRefSequence = [] | P.otherwise = M.catMaybes - [ if obj == default_Constituent{constituent_id = constituent_id obj} then P.Nothing else P.Just $ default_Constituent{constituent_id = constituent_id obj} - , if obj == default_Constituent{constituent_tag = constituent_tag obj} then P.Nothing else P.Just $ default_Constituent{constituent_tag = constituent_tag obj} - , if obj == default_Constituent{constituent_childList = constituent_childList obj} then P.Nothing else P.Just $ default_Constituent{constituent_childList = constituent_childList obj} - , if obj == default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj} then P.Nothing else P.Just $ default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj} - , if obj == default_Constituent{constituent_start = constituent_start obj} then P.Nothing else P.Just $ default_Constituent{constituent_start = constituent_start obj} - , if obj == default_Constituent{constituent_ending = constituent_ending obj} then P.Nothing else P.Just $ default_Constituent{constituent_ending = constituent_ending obj} + [ if obj == default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj} + , if obj == default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj} + , if obj == default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj} + , if obj == default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj} + , if obj == default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj} + , if obj == default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj} + , if obj == default_TokenRefSequence{tokenRefSequence_dependencies = tokenRefSequence_dependencies obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_dependencies = tokenRefSequence_dependencies obj} + , if obj == default_TokenRefSequence{tokenRefSequence_constituent = tokenRefSequence_constituent obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_constituent = tokenRefSequence_constituent obj} ] -from_Constituent :: Constituent -> T.ThriftVal -from_Constituent record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v95 -> P.Just (1, ("id",T.TI32 _v95))) $ constituent_id record - , (\_v95 -> (2, ("tag",T.TString $ E.encodeUtf8 _v95))) <$> constituent_tag record - , (\_v95 -> P.Just (3, ("childList",T.TList T.T_I32 $ P.map (\_v97 -> T.TI32 _v97) $ Vector.toList _v95))) $ constituent_childList record - , (\_v95 -> (4, ("headChildIndex",T.TI32 _v95))) <$> constituent_headChildIndex record - , (\_v95 -> (5, ("start",T.TI32 _v95))) <$> constituent_start record - , (\_v95 -> (6, ("ending",T.TI32 _v95))) <$> constituent_ending record +from_TokenRefSequence :: TokenRefSequence -> T.ThriftVal +from_TokenRefSequence record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v76 -> P.Just (1, ("tokenIndexList",T.TList T.T_I32 $ P.map (\_v78 -> T.TI32 _v78) $ Vector.toList _v76))) $ tokenRefSequence_tokenIndexList record + , (\_v76 -> (2, ("anchorTokenIndex",T.TI32 _v76))) <$> tokenRefSequence_anchorTokenIndex record + , (\_v76 -> P.Just (3, ("tokenizationId",Uuid_Types.from_UUID _v76))) $ tokenRefSequence_tokenizationId record + , (\_v76 -> (4, ("textSpan",Spans_Types.from_TextSpan _v76))) <$> tokenRefSequence_textSpan record + , (\_v76 -> (5, ("rawTextSpan",Spans_Types.from_TextSpan _v76))) <$> tokenRefSequence_rawTextSpan record + , (\_v76 -> (6, ("audioSpan",Spans_Types.from_AudioSpan _v76))) <$> tokenRefSequence_audioSpan record + , (\_v76 -> (7, ("dependencies",T.TList (T.T_STRUCT typemap_Dependency) $ P.map (\_v80 -> from_Dependency _v80) $ Vector.toList _v76))) <$> tokenRefSequence_dependencies record + , (\_v76 -> (8, ("constituent",from_ConstituentRef _v76))) <$> tokenRefSequence_constituent record ] -write_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> P.IO () -write_Constituent oprot record = T.writeVal oprot $ from_Constituent record -encode_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> LBS.ByteString -encode_Constituent oprot record = T.serializeVal oprot $ from_Constituent record -to_Constituent :: T.ThriftVal -> Constituent -to_Constituent (T.TStruct fields) = Constituent{ - constituent_id = P.maybe (P.error "Missing required field: id") (\(_,_val99) -> (case _val99 of {T.TI32 _val100 -> _val100; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - constituent_tag = P.maybe (P.Nothing) (\(_,_val99) -> P.Just (case _val99 of {T.TString _val101 -> E.decodeUtf8 _val101; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - constituent_childList = P.maybe (P.error "Missing required field: childList") (\(_,_val99) -> (case _val99 of {T.TList _ _val102 -> (Vector.fromList $ P.map (\_v103 -> (case _v103 of {T.TI32 _val104 -> _val104; _ -> P.error "wrong type"})) _val102); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - constituent_headChildIndex = P.maybe (constituent_headChildIndex default_Constituent) (\(_,_val99) -> P.Just (case _val99 of {T.TI32 _val105 -> _val105; _ -> P.error "wrong type"})) (Map.lookup (4) fields), - constituent_start = P.maybe (P.Nothing) (\(_,_val99) -> P.Just (case _val99 of {T.TI32 _val106 -> _val106; _ -> P.error "wrong type"})) (Map.lookup (5) fields), - constituent_ending = P.maybe (P.Nothing) (\(_,_val99) -> P.Just (case _val99 of {T.TI32 _val107 -> _val107; _ -> P.error "wrong type"})) (Map.lookup (6) fields) +write_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> P.IO () +write_TokenRefSequence oprot record = T.writeVal oprot $ from_TokenRefSequence record +encode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> LBS.ByteString +encode_TokenRefSequence oprot record = T.serializeVal oprot $ from_TokenRefSequence record +to_TokenRefSequence :: T.ThriftVal -> TokenRefSequence +to_TokenRefSequence (T.TStruct fields) = TokenRefSequence{ + tokenRefSequence_tokenIndexList = P.maybe (P.error "Missing required field: tokenIndexList") (\(_,_val82) -> (case _val82 of {T.TList _ _val83 -> (Vector.fromList $ P.map (\_v84 -> (case _v84 of {T.TI32 _val85 -> _val85; _ -> P.error "wrong type"})) _val83); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + tokenRefSequence_anchorTokenIndex = P.maybe (tokenRefSequence_anchorTokenIndex default_TokenRefSequence) (\(_,_val82) -> P.Just (case _val82 of {T.TI32 _val86 -> _val86; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + tokenRefSequence_tokenizationId = P.maybe (P.error "Missing required field: tokenizationId") (\(_,_val82) -> (case _val82 of {T.TStruct _val87 -> (Uuid_Types.to_UUID (T.TStruct _val87)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + tokenRefSequence_textSpan = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val88 -> (Spans_Types.to_TextSpan (T.TStruct _val88)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + tokenRefSequence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val89 -> (Spans_Types.to_TextSpan (T.TStruct _val89)); _ -> P.error "wrong type"})) (Map.lookup (5) fields), + tokenRefSequence_audioSpan = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val90 -> (Spans_Types.to_AudioSpan (T.TStruct _val90)); _ -> P.error "wrong type"})) (Map.lookup (6) fields), + tokenRefSequence_dependencies = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TList _ _val91 -> (Vector.fromList $ P.map (\_v92 -> (case _v92 of {T.TStruct _val93 -> (to_Dependency (T.TStruct _val93)); _ -> P.error "wrong type"})) _val91); _ -> P.error "wrong type"})) (Map.lookup (7) fields), + tokenRefSequence_constituent = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val94 -> (to_ConstituentRef (T.TStruct _val94)); _ -> P.error "wrong type"})) (Map.lookup (8) fields) } -to_Constituent _ = P.error "not a struct" -read_Constituent :: (T.Transport t, T.Protocol p) => p t -> P.IO Constituent -read_Constituent iprot = to_Constituent <$> T.readVal iprot (T.T_STRUCT typemap_Constituent) -decode_Constituent :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Constituent -decode_Constituent iprot bs = to_Constituent $ T.deserializeVal iprot (T.T_STRUCT typemap_Constituent) bs -typemap_Constituent :: T.TypeMap -typemap_Constituent = Map.fromList [(1,("id",T.T_I32)),(2,("tag",T.T_STRING)),(3,("childList",(T.T_LIST T.T_I32))),(4,("headChildIndex",T.T_I32)),(5,("start",T.T_I32)),(6,("ending",T.T_I32))] -default_Constituent :: Constituent -default_Constituent = Constituent{ - constituent_id = 0, - constituent_tag = P.Nothing, - constituent_childList = Vector.empty, - constituent_headChildIndex = P.Just (-1), - constituent_start = P.Nothing, - constituent_ending = P.Nothing} -data Parse = Parse { parse_uuid :: Uuid_Types.UUID - , parse_metadata :: Metadata_Types.AnnotationMetadata - , parse_constituentList :: (Vector.Vector Constituent) +to_TokenRefSequence _ = P.error "not a struct" +read_TokenRefSequence :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenRefSequence +read_TokenRefSequence iprot = to_TokenRefSequence <$> T.readVal iprot (T.T_STRUCT typemap_TokenRefSequence) +decode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenRefSequence +decode_TokenRefSequence iprot bs = to_TokenRefSequence $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenRefSequence) bs +typemap_TokenRefSequence :: T.TypeMap +typemap_TokenRefSequence = Map.fromList [(1,("tokenIndexList",(T.T_LIST T.T_I32))),(2,("anchorTokenIndex",T.T_I32)),(3,("tokenizationId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(6,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan))),(7,("dependencies",(T.T_LIST (T.T_STRUCT typemap_Dependency)))),(8,("constituent",(T.T_STRUCT typemap_ConstituentRef)))] +default_TokenRefSequence :: TokenRefSequence +default_TokenRefSequence = TokenRefSequence{ + tokenRefSequence_tokenIndexList = Vector.empty, + tokenRefSequence_anchorTokenIndex = P.Just (-1), + tokenRefSequence_tokenizationId = Uuid_Types.default_UUID, + tokenRefSequence_textSpan = P.Nothing, + tokenRefSequence_rawTextSpan = P.Nothing, + tokenRefSequence_audioSpan = P.Nothing, + tokenRefSequence_dependencies = P.Nothing, + tokenRefSequence_constituent = P.Nothing} +data TaggedToken = TaggedToken { taggedToken_tokenIndex :: P.Maybe I.Int32 + , taggedToken_tag :: P.Maybe LT.Text + , taggedToken_confidence :: P.Maybe P.Double + , taggedToken_tagList :: P.Maybe (Vector.Vector LT.Text) + , taggedToken_confidenceList :: P.Maybe (Vector.Vector P.Double) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable Parse where - hashWithSalt salt record = salt `H.hashWithSalt` parse_uuid record `H.hashWithSalt` parse_metadata record `H.hashWithSalt` parse_constituentList record -instance QC.Arbitrary Parse where - arbitrary = M.liftM Parse (QC.arbitrary) +instance H.Hashable TaggedToken where + hashWithSalt salt record = salt `H.hashWithSalt` taggedToken_tokenIndex record `H.hashWithSalt` taggedToken_tag record `H.hashWithSalt` taggedToken_confidence record `H.hashWithSalt` taggedToken_tagList record `H.hashWithSalt` taggedToken_confidenceList record +instance QC.Arbitrary TaggedToken where + arbitrary = M.liftM TaggedToken (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_TaggedToken = [] + | P.otherwise = M.catMaybes + [ if obj == default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj} + , if obj == default_TaggedToken{taggedToken_tag = taggedToken_tag obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tag = taggedToken_tag obj} + , if obj == default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj} + , if obj == default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj} + , if obj == default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj} + ] +from_TaggedToken :: TaggedToken -> T.ThriftVal +from_TaggedToken record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v97 -> (1, ("tokenIndex",T.TI32 _v97))) <$> taggedToken_tokenIndex record + , (\_v97 -> (2, ("tag",T.TString $ E.encodeUtf8 _v97))) <$> taggedToken_tag record + , (\_v97 -> (3, ("confidence",T.TDouble _v97))) <$> taggedToken_confidence record + , (\_v97 -> (4, ("tagList",T.TList T.T_STRING $ P.map (\_v99 -> T.TString $ E.encodeUtf8 _v99) $ Vector.toList _v97))) <$> taggedToken_tagList record + , (\_v97 -> (5, ("confidenceList",T.TList T.T_DOUBLE $ P.map (\_v101 -> T.TDouble _v101) $ Vector.toList _v97))) <$> taggedToken_confidenceList record + ] +write_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> P.IO () +write_TaggedToken oprot record = T.writeVal oprot $ from_TaggedToken record +encode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> LBS.ByteString +encode_TaggedToken oprot record = T.serializeVal oprot $ from_TaggedToken record +to_TaggedToken :: T.ThriftVal -> TaggedToken +to_TaggedToken (T.TStruct fields) = TaggedToken{ + taggedToken_tokenIndex = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TI32 _val104 -> _val104; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + taggedToken_tag = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TString _val105 -> E.decodeUtf8 _val105; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + taggedToken_confidence = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TDouble _val106 -> _val106; _ -> P.error "wrong type"})) (Map.lookup (3) fields), + taggedToken_tagList = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TList _ _val107 -> (Vector.fromList $ P.map (\_v108 -> (case _v108 of {T.TString _val109 -> E.decodeUtf8 _val109; _ -> P.error "wrong type"})) _val107); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + taggedToken_confidenceList = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TList _ _val110 -> (Vector.fromList $ P.map (\_v111 -> (case _v111 of {T.TDouble _val112 -> _val112; _ -> P.error "wrong type"})) _val110); _ -> P.error "wrong type"})) (Map.lookup (5) fields) + } +to_TaggedToken _ = P.error "not a struct" +read_TaggedToken :: (T.Transport t, T.Protocol p) => p t -> P.IO TaggedToken +read_TaggedToken iprot = to_TaggedToken <$> T.readVal iprot (T.T_STRUCT typemap_TaggedToken) +decode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TaggedToken +decode_TaggedToken iprot bs = to_TaggedToken $ T.deserializeVal iprot (T.T_STRUCT typemap_TaggedToken) bs +typemap_TaggedToken :: T.TypeMap +typemap_TaggedToken = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("tag",T.T_STRING)),(3,("confidence",T.T_DOUBLE)),(4,("tagList",(T.T_LIST T.T_STRING))),(5,("confidenceList",(T.T_LIST T.T_DOUBLE)))] +default_TaggedToken :: TaggedToken +default_TaggedToken = TaggedToken{ + taggedToken_tokenIndex = P.Nothing, + taggedToken_tag = P.Nothing, + taggedToken_confidence = P.Nothing, + taggedToken_tagList = P.Nothing, + taggedToken_confidenceList = P.Nothing} +data TokenTagging = TokenTagging { tokenTagging_uuid :: Uuid_Types.UUID + , tokenTagging_metadata :: Metadata_Types.AnnotationMetadata + , tokenTagging_taggedTokenList :: (Vector.Vector TaggedToken) + , tokenTagging_taggingType :: P.Maybe LT.Text + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable TokenTagging where + hashWithSalt salt record = salt `H.hashWithSalt` tokenTagging_uuid record `H.hashWithSalt` tokenTagging_metadata record `H.hashWithSalt` tokenTagging_taggedTokenList record `H.hashWithSalt` tokenTagging_taggingType record +instance QC.Arbitrary TokenTagging where + arbitrary = M.liftM TokenTagging (QC.arbitrary) `M.ap`(QC.arbitrary) `M.ap`(QC.arbitrary) - shrink obj | obj == default_Parse = [] + `M.ap`(M.liftM P.Just QC.arbitrary) + shrink obj | obj == default_TokenTagging = [] | P.otherwise = M.catMaybes - [ if obj == default_Parse{parse_uuid = parse_uuid obj} then P.Nothing else P.Just $ default_Parse{parse_uuid = parse_uuid obj} - , if obj == default_Parse{parse_metadata = parse_metadata obj} then P.Nothing else P.Just $ default_Parse{parse_metadata = parse_metadata obj} - , if obj == default_Parse{parse_constituentList = parse_constituentList obj} then P.Nothing else P.Just $ default_Parse{parse_constituentList = parse_constituentList obj} + [ if obj == default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj} + , if obj == default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj} + , if obj == default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj} + , if obj == default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj} ] -from_Parse :: Parse -> T.ThriftVal -from_Parse record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v110 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v110))) $ parse_uuid record - , (\_v110 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v110))) $ parse_metadata record - , (\_v110 -> P.Just (3, ("constituentList",T.TList (T.T_STRUCT typemap_Constituent) $ P.map (\_v112 -> from_Constituent _v112) $ Vector.toList _v110))) $ parse_constituentList record +from_TokenTagging :: TokenTagging -> T.ThriftVal +from_TokenTagging record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v115 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v115))) $ tokenTagging_uuid record + , (\_v115 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v115))) $ tokenTagging_metadata record + , (\_v115 -> P.Just (3, ("taggedTokenList",T.TList (T.T_STRUCT typemap_TaggedToken) $ P.map (\_v117 -> from_TaggedToken _v117) $ Vector.toList _v115))) $ tokenTagging_taggedTokenList record + , (\_v115 -> (4, ("taggingType",T.TString $ E.encodeUtf8 _v115))) <$> tokenTagging_taggingType record ] -write_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> P.IO () -write_Parse oprot record = T.writeVal oprot $ from_Parse record -encode_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> LBS.ByteString -encode_Parse oprot record = T.serializeVal oprot $ from_Parse record -to_Parse :: T.ThriftVal -> Parse -to_Parse (T.TStruct fields) = Parse{ - parse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val114) -> (case _val114 of {T.TStruct _val115 -> (Uuid_Types.to_UUID (T.TStruct _val115)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - parse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val114) -> (case _val114 of {T.TStruct _val116 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val116)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - parse_constituentList = P.maybe (P.error "Missing required field: constituentList") (\(_,_val114) -> (case _val114 of {T.TList _ _val117 -> (Vector.fromList $ P.map (\_v118 -> (case _v118 of {T.TStruct _val119 -> (to_Constituent (T.TStruct _val119)); _ -> P.error "wrong type"})) _val117); _ -> P.error "wrong type"})) (Map.lookup (3) fields) +write_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> P.IO () +write_TokenTagging oprot record = T.writeVal oprot $ from_TokenTagging record +encode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> LBS.ByteString +encode_TokenTagging oprot record = T.serializeVal oprot $ from_TokenTagging record +to_TokenTagging :: T.ThriftVal -> TokenTagging +to_TokenTagging (T.TStruct fields) = TokenTagging{ + tokenTagging_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val119) -> (case _val119 of {T.TStruct _val120 -> (Uuid_Types.to_UUID (T.TStruct _val120)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + tokenTagging_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val119) -> (case _val119 of {T.TStruct _val121 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val121)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + tokenTagging_taggedTokenList = P.maybe (P.error "Missing required field: taggedTokenList") (\(_,_val119) -> (case _val119 of {T.TList _ _val122 -> (Vector.fromList $ P.map (\_v123 -> (case _v123 of {T.TStruct _val124 -> (to_TaggedToken (T.TStruct _val124)); _ -> P.error "wrong type"})) _val122); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + tokenTagging_taggingType = P.maybe (P.Nothing) (\(_,_val119) -> P.Just (case _val119 of {T.TString _val125 -> E.decodeUtf8 _val125; _ -> P.error "wrong type"})) (Map.lookup (4) fields) } -to_Parse _ = P.error "not a struct" -read_Parse :: (T.Transport t, T.Protocol p) => p t -> P.IO Parse -read_Parse iprot = to_Parse <$> T.readVal iprot (T.T_STRUCT typemap_Parse) -decode_Parse :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Parse -decode_Parse iprot bs = to_Parse $ T.deserializeVal iprot (T.T_STRUCT typemap_Parse) bs -typemap_Parse :: T.TypeMap -typemap_Parse = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("constituentList",(T.T_LIST (T.T_STRUCT typemap_Constituent))))] -default_Parse :: Parse -default_Parse = Parse{ - parse_uuid = Uuid_Types.default_UUID, - parse_metadata = Metadata_Types.default_AnnotationMetadata, - parse_constituentList = Vector.empty} +to_TokenTagging _ = P.error "not a struct" +read_TokenTagging :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenTagging +read_TokenTagging iprot = to_TokenTagging <$> T.readVal iprot (T.T_STRUCT typemap_TokenTagging) +decode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenTagging +decode_TokenTagging iprot bs = to_TokenTagging $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenTagging) bs +typemap_TokenTagging :: T.TypeMap +typemap_TokenTagging = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("taggedTokenList",(T.T_LIST (T.T_STRUCT typemap_TaggedToken)))),(4,("taggingType",T.T_STRING))] +default_TokenTagging :: TokenTagging +default_TokenTagging = TokenTagging{ + tokenTagging_uuid = Uuid_Types.default_UUID, + tokenTagging_metadata = Metadata_Types.default_AnnotationMetadata, + tokenTagging_taggedTokenList = Vector.empty, + tokenTagging_taggingType = P.Nothing} data LatticePath = LatticePath { latticePath_weight :: P.Maybe P.Double , latticePath_tokenList :: (Vector.Vector Token) } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) @@ -583,8 +595,8 @@ ] from_LatticePath :: LatticePath -> T.ThriftVal from_LatticePath record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v122 -> (1, ("weight",T.TDouble _v122))) <$> latticePath_weight record - , (\_v122 -> P.Just (2, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v124 -> from_Token _v124) $ Vector.toList _v122))) $ latticePath_tokenList record + [ (\_v128 -> (1, ("weight",T.TDouble _v128))) <$> latticePath_weight record + , (\_v128 -> P.Just (2, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v130 -> from_Token _v130) $ Vector.toList _v128))) $ latticePath_tokenList record ] write_LatticePath :: (T.Protocol p, T.Transport t) => p t -> LatticePath -> P.IO () write_LatticePath oprot record = T.writeVal oprot $ from_LatticePath record @@ -592,8 +604,8 @@ encode_LatticePath oprot record = T.serializeVal oprot $ from_LatticePath record to_LatticePath :: T.ThriftVal -> LatticePath to_LatticePath (T.TStruct fields) = LatticePath{ - latticePath_weight = P.maybe (P.Nothing) (\(_,_val126) -> P.Just (case _val126 of {T.TDouble _val127 -> _val127; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - latticePath_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val126) -> (case _val126 of {T.TList _ _val128 -> (Vector.fromList $ P.map (\_v129 -> (case _v129 of {T.TStruct _val130 -> (to_Token (T.TStruct _val130)); _ -> P.error "wrong type"})) _val128); _ -> P.error "wrong type"})) (Map.lookup (2) fields) + latticePath_weight = P.maybe (P.Nothing) (\(_,_val132) -> P.Just (case _val132 of {T.TDouble _val133 -> _val133; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + latticePath_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val132) -> (case _val132 of {T.TList _ _val134 -> (Vector.fromList $ P.map (\_v135 -> (case _v135 of {T.TStruct _val136 -> (to_Token (T.TStruct _val136)); _ -> P.error "wrong type"})) _val134); _ -> P.error "wrong type"})) (Map.lookup (2) fields) } to_LatticePath _ = P.error "not a struct" read_LatticePath :: (T.Transport t, T.Protocol p) => p t -> P.IO LatticePath @@ -627,10 +639,10 @@ ] from_Arc :: Arc -> T.ThriftVal from_Arc record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v133 -> (1, ("src",T.TI32 _v133))) <$> arc_src record - , (\_v133 -> (2, ("dst",T.TI32 _v133))) <$> arc_dst record - , (\_v133 -> (3, ("token",from_Token _v133))) <$> arc_token record - , (\_v133 -> (4, ("weight",T.TDouble _v133))) <$> arc_weight record + [ (\_v139 -> (1, ("src",T.TI32 _v139))) <$> arc_src record + , (\_v139 -> (2, ("dst",T.TI32 _v139))) <$> arc_dst record + , (\_v139 -> (3, ("token",from_Token _v139))) <$> arc_token record + , (\_v139 -> (4, ("weight",T.TDouble _v139))) <$> arc_weight record ] write_Arc :: (T.Protocol p, T.Transport t) => p t -> Arc -> P.IO () write_Arc oprot record = T.writeVal oprot $ from_Arc record @@ -638,10 +650,10 @@ encode_Arc oprot record = T.serializeVal oprot $ from_Arc record to_Arc :: T.ThriftVal -> Arc to_Arc (T.TStruct fields) = Arc{ - arc_src = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TI32 _val136 -> _val136; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - arc_dst = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TI32 _val137 -> _val137; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - arc_token = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TStruct _val138 -> (to_Token (T.TStruct _val138)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - arc_weight = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TDouble _val139 -> _val139; _ -> P.error "wrong type"})) (Map.lookup (4) fields) + arc_src = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TI32 _val142 -> _val142; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + arc_dst = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TI32 _val143 -> _val143; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + arc_token = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TStruct _val144 -> (to_Token (T.TStruct _val144)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + arc_weight = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TDouble _val145 -> _val145; _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_Arc _ = P.error "not a struct" read_Arc :: (T.Transport t, T.Protocol p) => p t -> P.IO Arc @@ -677,10 +689,10 @@ ] from_TokenLattice :: TokenLattice -> T.ThriftVal from_TokenLattice record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v142 -> (1, ("startState",T.TI32 _v142))) <$> tokenLattice_startState record - , (\_v142 -> (2, ("endState",T.TI32 _v142))) <$> tokenLattice_endState record - , (\_v142 -> P.Just (3, ("arcList",T.TList (T.T_STRUCT typemap_Arc) $ P.map (\_v144 -> from_Arc _v144) $ Vector.toList _v142))) $ tokenLattice_arcList record - , (\_v142 -> (4, ("cachedBestPath",from_LatticePath _v142))) <$> tokenLattice_cachedBestPath record + [ (\_v148 -> (1, ("startState",T.TI32 _v148))) <$> tokenLattice_startState record + , (\_v148 -> (2, ("endState",T.TI32 _v148))) <$> tokenLattice_endState record + , (\_v148 -> P.Just (3, ("arcList",T.TList (T.T_STRUCT typemap_Arc) $ P.map (\_v150 -> from_Arc _v150) $ Vector.toList _v148))) $ tokenLattice_arcList record + , (\_v148 -> (4, ("cachedBestPath",from_LatticePath _v148))) <$> tokenLattice_cachedBestPath record ] write_TokenLattice :: (T.Protocol p, T.Transport t) => p t -> TokenLattice -> P.IO () write_TokenLattice oprot record = T.writeVal oprot $ from_TokenLattice record @@ -688,10 +700,10 @@ encode_TokenLattice oprot record = T.serializeVal oprot $ from_TokenLattice record to_TokenLattice :: T.ThriftVal -> TokenLattice to_TokenLattice (T.TStruct fields) = TokenLattice{ - tokenLattice_startState = P.maybe (tokenLattice_startState default_TokenLattice) (\(_,_val146) -> P.Just (case _val146 of {T.TI32 _val147 -> _val147; _ -> P.error "wrong type"})) (Map.lookup (1) fields), - tokenLattice_endState = P.maybe (tokenLattice_endState default_TokenLattice) (\(_,_val146) -> P.Just (case _val146 of {T.TI32 _val148 -> _val148; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - tokenLattice_arcList = P.maybe (P.error "Missing required field: arcList") (\(_,_val146) -> (case _val146 of {T.TList _ _val149 -> (Vector.fromList $ P.map (\_v150 -> (case _v150 of {T.TStruct _val151 -> (to_Arc (T.TStruct _val151)); _ -> P.error "wrong type"})) _val149); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - tokenLattice_cachedBestPath = P.maybe (P.Nothing) (\(_,_val146) -> P.Just (case _val146 of {T.TStruct _val152 -> (to_LatticePath (T.TStruct _val152)); _ -> P.error "wrong type"})) (Map.lookup (4) fields) + tokenLattice_startState = P.maybe (tokenLattice_startState default_TokenLattice) (\(_,_val152) -> P.Just (case _val152 of {T.TI32 _val153 -> _val153; _ -> P.error "wrong type"})) (Map.lookup (1) fields), + tokenLattice_endState = P.maybe (tokenLattice_endState default_TokenLattice) (\(_,_val152) -> P.Just (case _val152 of {T.TI32 _val154 -> _val154; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + tokenLattice_arcList = P.maybe (P.error "Missing required field: arcList") (\(_,_val152) -> (case _val152 of {T.TList _ _val155 -> (Vector.fromList $ P.map (\_v156 -> (case _v156 of {T.TStruct _val157 -> (to_Arc (T.TStruct _val157)); _ -> P.error "wrong type"})) _val155); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + tokenLattice_cachedBestPath = P.maybe (P.Nothing) (\(_,_val152) -> P.Just (case _val152 of {T.TStruct _val158 -> (to_LatticePath (T.TStruct _val158)); _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_TokenLattice _ = P.error "not a struct" read_TokenLattice :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenLattice @@ -718,7 +730,7 @@ ] from_TokenList :: TokenList -> T.ThriftVal from_TokenList record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v155 -> P.Just (1, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v157 -> from_Token _v157) $ Vector.toList _v155))) $ tokenList_tokenList record + [ (\_v161 -> P.Just (1, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v163 -> from_Token _v163) $ Vector.toList _v161))) $ tokenList_tokenList record ] write_TokenList :: (T.Protocol p, T.Transport t) => p t -> TokenList -> P.IO () write_TokenList oprot record = T.writeVal oprot $ from_TokenList record @@ -726,7 +738,7 @@ encode_TokenList oprot record = T.serializeVal oprot $ from_TokenList record to_TokenList :: T.ThriftVal -> TokenList to_TokenList (T.TStruct fields) = TokenList{ - tokenList_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val159) -> (case _val159 of {T.TList _ _val160 -> (Vector.fromList $ P.map (\_v161 -> (case _v161 of {T.TStruct _val162 -> (to_Token (T.TStruct _val162)); _ -> P.error "wrong type"})) _val160); _ -> P.error "wrong type"})) (Map.lookup (1) fields) + tokenList_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val165) -> (case _val165 of {T.TList _ _val166 -> (Vector.fromList $ P.map (\_v167 -> (case _v167 of {T.TStruct _val168 -> (to_Token (T.TStruct _val168)); _ -> P.error "wrong type"})) _val166); _ -> P.error "wrong type"})) (Map.lookup (1) fields) } to_TokenList _ = P.error "not a struct" read_TokenList :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenList @@ -759,10 +771,10 @@ ] from_SpanLink :: SpanLink -> T.ThriftVal from_SpanLink record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v165 -> P.Just (1, ("tokens",from_TokenRefSequence _v165))) $ spanLink_tokens record - , (\_v165 -> (2, ("concreteTarget",Uuid_Types.from_UUID _v165))) <$> spanLink_concreteTarget record - , (\_v165 -> (3, ("externalTarget",T.TString $ E.encodeUtf8 _v165))) <$> spanLink_externalTarget record - , (\_v165 -> P.Just (4, ("linkType",T.TString $ E.encodeUtf8 _v165))) $ spanLink_linkType record + [ (\_v171 -> P.Just (1, ("tokens",from_TokenRefSequence _v171))) $ spanLink_tokens record + , (\_v171 -> (2, ("concreteTarget",Uuid_Types.from_UUID _v171))) <$> spanLink_concreteTarget record + , (\_v171 -> (3, ("externalTarget",T.TString $ E.encodeUtf8 _v171))) <$> spanLink_externalTarget record + , (\_v171 -> P.Just (4, ("linkType",T.TString $ E.encodeUtf8 _v171))) $ spanLink_linkType record ] write_SpanLink :: (T.Protocol p, T.Transport t) => p t -> SpanLink -> P.IO () write_SpanLink oprot record = T.writeVal oprot $ from_SpanLink record @@ -770,10 +782,10 @@ encode_SpanLink oprot record = T.serializeVal oprot $ from_SpanLink record to_SpanLink :: T.ThriftVal -> SpanLink to_SpanLink (T.TStruct fields) = SpanLink{ - spanLink_tokens = P.maybe (P.error "Missing required field: tokens") (\(_,_val167) -> (case _val167 of {T.TStruct _val168 -> (to_TokenRefSequence (T.TStruct _val168)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - spanLink_concreteTarget = P.maybe (P.Nothing) (\(_,_val167) -> P.Just (case _val167 of {T.TStruct _val169 -> (Uuid_Types.to_UUID (T.TStruct _val169)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - spanLink_externalTarget = P.maybe (P.Nothing) (\(_,_val167) -> P.Just (case _val167 of {T.TString _val170 -> E.decodeUtf8 _val170; _ -> P.error "wrong type"})) (Map.lookup (3) fields), - spanLink_linkType = P.maybe (P.error "Missing required field: linkType") (\(_,_val167) -> (case _val167 of {T.TString _val171 -> E.decodeUtf8 _val171; _ -> P.error "wrong type"})) (Map.lookup (4) fields) + spanLink_tokens = P.maybe (P.error "Missing required field: tokens") (\(_,_val173) -> (case _val173 of {T.TStruct _val174 -> (to_TokenRefSequence (T.TStruct _val174)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + spanLink_concreteTarget = P.maybe (P.Nothing) (\(_,_val173) -> P.Just (case _val173 of {T.TStruct _val175 -> (Uuid_Types.to_UUID (T.TStruct _val175)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + spanLink_externalTarget = P.maybe (P.Nothing) (\(_,_val173) -> P.Just (case _val173 of {T.TString _val176 -> E.decodeUtf8 _val176; _ -> P.error "wrong type"})) (Map.lookup (3) fields), + spanLink_linkType = P.maybe (P.error "Missing required field: linkType") (\(_,_val173) -> (case _val173 of {T.TString _val177 -> E.decodeUtf8 _val177; _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_SpanLink _ = P.error "not a struct" read_SpanLink :: (T.Transport t, T.Protocol p) => p t -> P.IO SpanLink @@ -824,15 +836,15 @@ ] from_Tokenization :: Tokenization -> T.ThriftVal from_Tokenization record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v174 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v174))) $ tokenization_uuid record - , (\_v174 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v174))) $ tokenization_metadata record - , (\_v174 -> (3, ("tokenList",from_TokenList _v174))) <$> tokenization_tokenList record - , (\_v174 -> (4, ("lattice",from_TokenLattice _v174))) <$> tokenization_lattice record - , (\_v174 -> P.Just (5, ("kind",T.TI32 $ P.fromIntegral $ P.fromEnum _v174))) $ tokenization_kind record - , (\_v174 -> (6, ("tokenTaggingList",T.TList (T.T_STRUCT typemap_TokenTagging) $ P.map (\_v176 -> from_TokenTagging _v176) $ Vector.toList _v174))) <$> tokenization_tokenTaggingList record - , (\_v174 -> (7, ("parseList",T.TList (T.T_STRUCT typemap_Parse) $ P.map (\_v178 -> from_Parse _v178) $ Vector.toList _v174))) <$> tokenization_parseList record - , (\_v174 -> (8, ("dependencyParseList",T.TList (T.T_STRUCT typemap_DependencyParse) $ P.map (\_v180 -> from_DependencyParse _v180) $ Vector.toList _v174))) <$> tokenization_dependencyParseList record - , (\_v174 -> (9, ("spanLinkList",T.TList (T.T_STRUCT typemap_SpanLink) $ P.map (\_v182 -> from_SpanLink _v182) $ Vector.toList _v174))) <$> tokenization_spanLinkList record + [ (\_v180 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v180))) $ tokenization_uuid record + , (\_v180 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v180))) $ tokenization_metadata record + , (\_v180 -> (3, ("tokenList",from_TokenList _v180))) <$> tokenization_tokenList record + , (\_v180 -> (4, ("lattice",from_TokenLattice _v180))) <$> tokenization_lattice record + , (\_v180 -> P.Just (5, ("kind",T.TI32 $ P.fromIntegral $ P.fromEnum _v180))) $ tokenization_kind record + , (\_v180 -> (6, ("tokenTaggingList",T.TList (T.T_STRUCT typemap_TokenTagging) $ P.map (\_v182 -> from_TokenTagging _v182) $ Vector.toList _v180))) <$> tokenization_tokenTaggingList record + , (\_v180 -> (7, ("parseList",T.TList (T.T_STRUCT typemap_Parse) $ P.map (\_v184 -> from_Parse _v184) $ Vector.toList _v180))) <$> tokenization_parseList record + , (\_v180 -> (8, ("dependencyParseList",T.TList (T.T_STRUCT typemap_DependencyParse) $ P.map (\_v186 -> from_DependencyParse _v186) $ Vector.toList _v180))) <$> tokenization_dependencyParseList record + , (\_v180 -> (9, ("spanLinkList",T.TList (T.T_STRUCT typemap_SpanLink) $ P.map (\_v188 -> from_SpanLink _v188) $ Vector.toList _v180))) <$> tokenization_spanLinkList record ] write_Tokenization :: (T.Protocol p, T.Transport t) => p t -> Tokenization -> P.IO () write_Tokenization oprot record = T.writeVal oprot $ from_Tokenization record @@ -840,15 +852,15 @@ encode_Tokenization oprot record = T.serializeVal oprot $ from_Tokenization record to_Tokenization :: T.ThriftVal -> Tokenization to_Tokenization (T.TStruct fields) = Tokenization{ - tokenization_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val184) -> (case _val184 of {T.TStruct _val185 -> (Uuid_Types.to_UUID (T.TStruct _val185)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - tokenization_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val184) -> (case _val184 of {T.TStruct _val186 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val186)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - tokenization_tokenList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TStruct _val187 -> (to_TokenList (T.TStruct _val187)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - tokenization_lattice = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TStruct _val188 -> (to_TokenLattice (T.TStruct _val188)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), - tokenization_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val184) -> (case _val184 of {T.TI32 _val189 -> P.toEnum $ P.fromIntegral _val189; _ -> P.error "wrong type"})) (Map.lookup (5) fields), - tokenization_tokenTaggingList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val190 -> (Vector.fromList $ P.map (\_v191 -> (case _v191 of {T.TStruct _val192 -> (to_TokenTagging (T.TStruct _val192)); _ -> P.error "wrong type"})) _val190); _ -> P.error "wrong type"})) (Map.lookup (6) fields), - tokenization_parseList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val193 -> (Vector.fromList $ P.map (\_v194 -> (case _v194 of {T.TStruct _val195 -> (to_Parse (T.TStruct _val195)); _ -> P.error "wrong type"})) _val193); _ -> P.error "wrong type"})) (Map.lookup (7) fields), - tokenization_dependencyParseList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val196 -> (Vector.fromList $ P.map (\_v197 -> (case _v197 of {T.TStruct _val198 -> (to_DependencyParse (T.TStruct _val198)); _ -> P.error "wrong type"})) _val196); _ -> P.error "wrong type"})) (Map.lookup (8) fields), - tokenization_spanLinkList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val199 -> (Vector.fromList $ P.map (\_v200 -> (case _v200 of {T.TStruct _val201 -> (to_SpanLink (T.TStruct _val201)); _ -> P.error "wrong type"})) _val199); _ -> P.error "wrong type"})) (Map.lookup (9) fields) + tokenization_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val190) -> (case _val190 of {T.TStruct _val191 -> (Uuid_Types.to_UUID (T.TStruct _val191)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + tokenization_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val190) -> (case _val190 of {T.TStruct _val192 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val192)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + tokenization_tokenList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TStruct _val193 -> (to_TokenList (T.TStruct _val193)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + tokenization_lattice = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TStruct _val194 -> (to_TokenLattice (T.TStruct _val194)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + tokenization_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val190) -> (case _val190 of {T.TI32 _val195 -> P.toEnum $ P.fromIntegral _val195; _ -> P.error "wrong type"})) (Map.lookup (5) fields), + tokenization_tokenTaggingList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val196 -> (Vector.fromList $ P.map (\_v197 -> (case _v197 of {T.TStruct _val198 -> (to_TokenTagging (T.TStruct _val198)); _ -> P.error "wrong type"})) _val196); _ -> P.error "wrong type"})) (Map.lookup (6) fields), + tokenization_parseList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val199 -> (Vector.fromList $ P.map (\_v200 -> (case _v200 of {T.TStruct _val201 -> (to_Parse (T.TStruct _val201)); _ -> P.error "wrong type"})) _val199); _ -> P.error "wrong type"})) (Map.lookup (7) fields), + tokenization_dependencyParseList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val202 -> (Vector.fromList $ P.map (\_v203 -> (case _v203 of {T.TStruct _val204 -> (to_DependencyParse (T.TStruct _val204)); _ -> P.error "wrong type"})) _val202); _ -> P.error "wrong type"})) (Map.lookup (8) fields), + tokenization_spanLinkList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val205 -> (Vector.fromList $ P.map (\_v206 -> (case _v206 of {T.TStruct _val207 -> (to_SpanLink (T.TStruct _val207)); _ -> P.error "wrong type"})) _val205); _ -> P.error "wrong type"})) (Map.lookup (9) fields) } to_Tokenization _ = P.error "not a struct" read_Tokenization :: (T.Transport t, T.Protocol p) => p t -> P.IO Tokenization @@ -892,11 +904,11 @@ ] from_Sentence :: Sentence -> T.ThriftVal from_Sentence record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v204 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v204))) $ sentence_uuid record - , (\_v204 -> (2, ("tokenization",from_Tokenization _v204))) <$> sentence_tokenization record - , (\_v204 -> (3, ("textSpan",Spans_Types.from_TextSpan _v204))) <$> sentence_textSpan record - , (\_v204 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v204))) <$> sentence_rawTextSpan record - , (\_v204 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v204))) <$> sentence_audioSpan record + [ (\_v210 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v210))) $ sentence_uuid record + , (\_v210 -> (2, ("tokenization",from_Tokenization _v210))) <$> sentence_tokenization record + , (\_v210 -> (3, ("textSpan",Spans_Types.from_TextSpan _v210))) <$> sentence_textSpan record + , (\_v210 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v210))) <$> sentence_rawTextSpan record + , (\_v210 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v210))) <$> sentence_audioSpan record ] write_Sentence :: (T.Protocol p, T.Transport t) => p t -> Sentence -> P.IO () write_Sentence oprot record = T.writeVal oprot $ from_Sentence record @@ -904,11 +916,11 @@ encode_Sentence oprot record = T.serializeVal oprot $ from_Sentence record to_Sentence :: T.ThriftVal -> Sentence to_Sentence (T.TStruct fields) = Sentence{ - sentence_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val206) -> (case _val206 of {T.TStruct _val207 -> (Uuid_Types.to_UUID (T.TStruct _val207)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - sentence_tokenization = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val208 -> (to_Tokenization (T.TStruct _val208)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - sentence_textSpan = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val209 -> (Spans_Types.to_TextSpan (T.TStruct _val209)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - sentence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val210 -> (Spans_Types.to_TextSpan (T.TStruct _val210)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), - sentence_audioSpan = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val211 -> (Spans_Types.to_AudioSpan (T.TStruct _val211)); _ -> P.error "wrong type"})) (Map.lookup (5) fields) + sentence_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val212) -> (case _val212 of {T.TStruct _val213 -> (Uuid_Types.to_UUID (T.TStruct _val213)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + sentence_tokenization = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val214 -> (to_Tokenization (T.TStruct _val214)); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + sentence_textSpan = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val215 -> (Spans_Types.to_TextSpan (T.TStruct _val215)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + sentence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val216 -> (Spans_Types.to_TextSpan (T.TStruct _val216)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + sentence_audioSpan = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val217 -> (Spans_Types.to_AudioSpan (T.TStruct _val217)); _ -> P.error "wrong type"})) (Map.lookup (5) fields) } to_Sentence _ = P.error "not a struct" read_Sentence :: (T.Transport t, T.Protocol p) => p t -> P.IO Sentence @@ -960,15 +972,15 @@ ] from_Section :: Section -> T.ThriftVal from_Section record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v214 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v214))) $ section_uuid record - , (\_v214 -> (2, ("sentenceList",T.TList (T.T_STRUCT typemap_Sentence) $ P.map (\_v216 -> from_Sentence _v216) $ Vector.toList _v214))) <$> section_sentenceList record - , (\_v214 -> (3, ("textSpan",Spans_Types.from_TextSpan _v214))) <$> section_textSpan record - , (\_v214 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v214))) <$> section_rawTextSpan record - , (\_v214 -> P.Just (5, ("kind",T.TString $ E.encodeUtf8 _v214))) $ section_kind record - , (\_v214 -> (6, ("label",T.TString $ E.encodeUtf8 _v214))) <$> section_label record - , (\_v214 -> (7, ("numberList",T.TList T.T_I32 $ P.map (\_v218 -> T.TI32 _v218) $ Vector.toList _v214))) <$> section_numberList record - , (\_v214 -> (8, ("lidList",T.TList (T.T_STRUCT Language_Types.typemap_LanguageIdentification) $ P.map (\_v220 -> Language_Types.from_LanguageIdentification _v220) $ Vector.toList _v214))) <$> section_lidList record - , (\_v214 -> (9, ("audioSpan",Spans_Types.from_AudioSpan _v214))) <$> section_audioSpan record + [ (\_v220 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v220))) $ section_uuid record + , (\_v220 -> (2, ("sentenceList",T.TList (T.T_STRUCT typemap_Sentence) $ P.map (\_v222 -> from_Sentence _v222) $ Vector.toList _v220))) <$> section_sentenceList record + , (\_v220 -> (3, ("textSpan",Spans_Types.from_TextSpan _v220))) <$> section_textSpan record + , (\_v220 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v220))) <$> section_rawTextSpan record + , (\_v220 -> P.Just (5, ("kind",T.TString $ E.encodeUtf8 _v220))) $ section_kind record + , (\_v220 -> (6, ("label",T.TString $ E.encodeUtf8 _v220))) <$> section_label record + , (\_v220 -> (7, ("numberList",T.TList T.T_I32 $ P.map (\_v224 -> T.TI32 _v224) $ Vector.toList _v220))) <$> section_numberList record + , (\_v220 -> (8, ("lidList",T.TList (T.T_STRUCT Language_Types.typemap_LanguageIdentification) $ P.map (\_v226 -> Language_Types.from_LanguageIdentification _v226) $ Vector.toList _v220))) <$> section_lidList record + , (\_v220 -> (9, ("audioSpan",Spans_Types.from_AudioSpan _v220))) <$> section_audioSpan record ] write_Section :: (T.Protocol p, T.Transport t) => p t -> Section -> P.IO () write_Section oprot record = T.writeVal oprot $ from_Section record @@ -976,15 +988,15 @@ encode_Section oprot record = T.serializeVal oprot $ from_Section record to_Section :: T.ThriftVal -> Section to_Section (T.TStruct fields) = Section{ - section_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val222) -> (case _val222 of {T.TStruct _val223 -> (Uuid_Types.to_UUID (T.TStruct _val223)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - section_sentenceList = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TList _ _val224 -> (Vector.fromList $ P.map (\_v225 -> (case _v225 of {T.TStruct _val226 -> (to_Sentence (T.TStruct _val226)); _ -> P.error "wrong type"})) _val224); _ -> P.error "wrong type"})) (Map.lookup (2) fields), - section_textSpan = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TStruct _val227 -> (Spans_Types.to_TextSpan (T.TStruct _val227)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), - section_rawTextSpan = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TStruct _val228 -> (Spans_Types.to_TextSpan (T.TStruct _val228)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), - section_audioSpan = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TStruct _val229 -> (Spans_Types.to_AudioSpan (T.TStruct _val229)); _ -> P.error "wrong type"})) (Map.lookup (9) fields), - section_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val222) -> (case _val222 of {T.TString _val230 -> E.decodeUtf8 _val230; _ -> P.error "wrong type"})) (Map.lookup (5) fields), - section_label = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TString _val231 -> E.decodeUtf8 _val231; _ -> P.error "wrong type"})) (Map.lookup (6) fields), - section_numberList = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TList _ _val232 -> (Vector.fromList $ P.map (\_v233 -> (case _v233 of {T.TI32 _val234 -> _val234; _ -> P.error "wrong type"})) _val232); _ -> P.error "wrong type"})) (Map.lookup (7) fields), - section_lidList = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TList _ _val235 -> (Vector.fromList $ P.map (\_v236 -> (case _v236 of {T.TStruct _val237 -> (Language_Types.to_LanguageIdentification (T.TStruct _val237)); _ -> P.error "wrong type"})) _val235); _ -> P.error "wrong type"})) (Map.lookup (8) fields) + section_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val228) -> (case _val228 of {T.TStruct _val229 -> (Uuid_Types.to_UUID (T.TStruct _val229)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + section_sentenceList = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TList _ _val230 -> (Vector.fromList $ P.map (\_v231 -> (case _v231 of {T.TStruct _val232 -> (to_Sentence (T.TStruct _val232)); _ -> P.error "wrong type"})) _val230); _ -> P.error "wrong type"})) (Map.lookup (2) fields), + section_textSpan = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TStruct _val233 -> (Spans_Types.to_TextSpan (T.TStruct _val233)); _ -> P.error "wrong type"})) (Map.lookup (3) fields), + section_rawTextSpan = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TStruct _val234 -> (Spans_Types.to_TextSpan (T.TStruct _val234)); _ -> P.error "wrong type"})) (Map.lookup (4) fields), + section_audioSpan = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TStruct _val235 -> (Spans_Types.to_AudioSpan (T.TStruct _val235)); _ -> P.error "wrong type"})) (Map.lookup (9) fields), + section_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val228) -> (case _val228 of {T.TString _val236 -> E.decodeUtf8 _val236; _ -> P.error "wrong type"})) (Map.lookup (5) fields), + section_label = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TString _val237 -> E.decodeUtf8 _val237; _ -> P.error "wrong type"})) (Map.lookup (6) fields), + section_numberList = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TList _ _val238 -> (Vector.fromList $ P.map (\_v239 -> (case _v239 of {T.TI32 _val240 -> _val240; _ -> P.error "wrong type"})) _val238); _ -> P.error "wrong type"})) (Map.lookup (7) fields), + section_lidList = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TList _ _val241 -> (Vector.fromList $ P.map (\_v242 -> (case _v242 of {T.TStruct _val243 -> (Language_Types.to_LanguageIdentification (T.TStruct _val243)); _ -> P.error "wrong type"})) _val241); _ -> P.error "wrong type"})) (Map.lookup (8) fields) } to_Section _ = P.error "not a struct" read_Section :: (T.Transport t, T.Protocol p) => p t -> P.IO Section diff --git a/src/Data/Concrete/Autogen/Summarization_Types.hs b/src/Data/Concrete/Autogen/Summarization_Types.hs --- a/src/Data/Concrete/Autogen/Summarization_Types.hs +++ b/src/Data/Concrete/Autogen/Summarization_Types.hs @@ -120,44 +120,6 @@ summarizationRequest_sourceType = P.Nothing, summarizationRequest_sourceIds = P.Nothing, summarizationRequest_sourceCommunication = P.Nothing} -data Summary = Summary { summary_summaryCommunication :: P.Maybe Communication_Types.Communication - , summary_concepts :: P.Maybe (Vector.Vector SummaryConcept) - } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) -instance H.Hashable Summary where - hashWithSalt salt record = salt `H.hashWithSalt` summary_summaryCommunication record `H.hashWithSalt` summary_concepts record -instance QC.Arbitrary Summary where - arbitrary = M.liftM Summary (M.liftM P.Just QC.arbitrary) - `M.ap`(M.liftM P.Just QC.arbitrary) - shrink obj | obj == default_Summary = [] - | P.otherwise = M.catMaybes - [ if obj == default_Summary{summary_summaryCommunication = summary_summaryCommunication obj} then P.Nothing else P.Just $ default_Summary{summary_summaryCommunication = summary_summaryCommunication obj} - , if obj == default_Summary{summary_concepts = summary_concepts obj} then P.Nothing else P.Just $ default_Summary{summary_concepts = summary_concepts obj} - ] -from_Summary :: Summary -> T.ThriftVal -from_Summary record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v21 -> (1, ("summaryCommunication",Communication_Types.from_Communication _v21))) <$> summary_summaryCommunication record - , (\_v21 -> (2, ("concepts",T.TList (T.T_STRUCT typemap_SummaryConcept) $ P.map (\_v23 -> from_SummaryConcept _v23) $ Vector.toList _v21))) <$> summary_concepts record - ] -write_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> P.IO () -write_Summary oprot record = T.writeVal oprot $ from_Summary record -encode_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> LBS.ByteString -encode_Summary oprot record = T.serializeVal oprot $ from_Summary record -to_Summary :: T.ThriftVal -> Summary -to_Summary (T.TStruct fields) = Summary{ - summary_summaryCommunication = P.maybe (P.Nothing) (\(_,_val25) -> P.Just (case _val25 of {T.TStruct _val26 -> (Communication_Types.to_Communication (T.TStruct _val26)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - summary_concepts = P.maybe (P.Nothing) (\(_,_val25) -> P.Just (case _val25 of {T.TList _ _val27 -> (Vector.fromList $ P.map (\_v28 -> (case _v28 of {T.TStruct _val29 -> (to_SummaryConcept (T.TStruct _val29)); _ -> P.error "wrong type"})) _val27); _ -> P.error "wrong type"})) (Map.lookup (2) fields) - } -to_Summary _ = P.error "not a struct" -read_Summary :: (T.Transport t, T.Protocol p) => p t -> P.IO Summary -read_Summary iprot = to_Summary <$> T.readVal iprot (T.T_STRUCT typemap_Summary) -decode_Summary :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Summary -decode_Summary iprot bs = to_Summary $ T.deserializeVal iprot (T.T_STRUCT typemap_Summary) bs -typemap_Summary :: T.TypeMap -typemap_Summary = Map.fromList [(1,("summaryCommunication",(T.T_STRUCT Communication_Types.typemap_Communication))),(2,("concepts",(T.T_LIST (T.T_STRUCT typemap_SummaryConcept))))] -default_Summary :: Summary -default_Summary = Summary{ - summary_summaryCommunication = P.Nothing, - summary_concepts = P.Nothing} data SummaryConcept = SummaryConcept { summaryConcept_tokens :: P.Maybe Structure_Types.TokenRefSequence , summaryConcept_concept :: P.Maybe LT.Text , summaryConcept_confidence :: P.Maybe P.Double @@ -179,10 +141,10 @@ ] from_SummaryConcept :: SummaryConcept -> T.ThriftVal from_SummaryConcept record = T.TStruct $ Map.fromList $ M.catMaybes - [ (\_v32 -> (1, ("tokens",Structure_Types.from_TokenRefSequence _v32))) <$> summaryConcept_tokens record - , (\_v32 -> (2, ("concept",T.TString $ E.encodeUtf8 _v32))) <$> summaryConcept_concept record - , (\_v32 -> (3, ("confidence",T.TDouble _v32))) <$> summaryConcept_confidence record - , (\_v32 -> (4, ("utility",T.TDouble _v32))) <$> summaryConcept_utility record + [ (\_v21 -> (1, ("tokens",Structure_Types.from_TokenRefSequence _v21))) <$> summaryConcept_tokens record + , (\_v21 -> (2, ("concept",T.TString $ E.encodeUtf8 _v21))) <$> summaryConcept_concept record + , (\_v21 -> (3, ("confidence",T.TDouble _v21))) <$> summaryConcept_confidence record + , (\_v21 -> (4, ("utility",T.TDouble _v21))) <$> summaryConcept_utility record ] write_SummaryConcept :: (T.Protocol p, T.Transport t) => p t -> SummaryConcept -> P.IO () write_SummaryConcept oprot record = T.writeVal oprot $ from_SummaryConcept record @@ -190,10 +152,10 @@ encode_SummaryConcept oprot record = T.serializeVal oprot $ from_SummaryConcept record to_SummaryConcept :: T.ThriftVal -> SummaryConcept to_SummaryConcept (T.TStruct fields) = SummaryConcept{ - summaryConcept_tokens = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TStruct _val35 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val35)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), - summaryConcept_concept = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TString _val36 -> E.decodeUtf8 _val36; _ -> P.error "wrong type"})) (Map.lookup (2) fields), - summaryConcept_confidence = P.maybe (summaryConcept_confidence default_SummaryConcept) (\(_,_val34) -> P.Just (case _val34 of {T.TDouble _val37 -> _val37; _ -> P.error "wrong type"})) (Map.lookup (3) fields), - summaryConcept_utility = P.maybe (summaryConcept_utility default_SummaryConcept) (\(_,_val34) -> P.Just (case _val34 of {T.TDouble _val38 -> _val38; _ -> P.error "wrong type"})) (Map.lookup (4) fields) + summaryConcept_tokens = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val24 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val24)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + summaryConcept_concept = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TString _val25 -> E.decodeUtf8 _val25; _ -> P.error "wrong type"})) (Map.lookup (2) fields), + summaryConcept_confidence = P.maybe (summaryConcept_confidence default_SummaryConcept) (\(_,_val23) -> P.Just (case _val23 of {T.TDouble _val26 -> _val26; _ -> P.error "wrong type"})) (Map.lookup (3) fields), + summaryConcept_utility = P.maybe (summaryConcept_utility default_SummaryConcept) (\(_,_val23) -> P.Just (case _val23 of {T.TDouble _val27 -> _val27; _ -> P.error "wrong type"})) (Map.lookup (4) fields) } to_SummaryConcept _ = P.error "not a struct" read_SummaryConcept :: (T.Transport t, T.Protocol p) => p t -> P.IO SummaryConcept @@ -208,6 +170,44 @@ summaryConcept_concept = P.Nothing, summaryConcept_confidence = P.Just (1), summaryConcept_utility = P.Just (1)} +data Summary = Summary { summary_summaryCommunication :: P.Maybe Communication_Types.Communication + , summary_concepts :: P.Maybe (Vector.Vector SummaryConcept) + } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) +instance H.Hashable Summary where + hashWithSalt salt record = salt `H.hashWithSalt` summary_summaryCommunication record `H.hashWithSalt` summary_concepts record +instance QC.Arbitrary Summary where + arbitrary = M.liftM Summary (M.liftM P.Just QC.arbitrary) + `M.ap`(M.liftM P.Just QC.arbitrary) + shrink obj | obj == default_Summary = [] + | P.otherwise = M.catMaybes + [ if obj == default_Summary{summary_summaryCommunication = summary_summaryCommunication obj} then P.Nothing else P.Just $ default_Summary{summary_summaryCommunication = summary_summaryCommunication obj} + , if obj == default_Summary{summary_concepts = summary_concepts obj} then P.Nothing else P.Just $ default_Summary{summary_concepts = summary_concepts obj} + ] +from_Summary :: Summary -> T.ThriftVal +from_Summary record = T.TStruct $ Map.fromList $ M.catMaybes + [ (\_v30 -> (1, ("summaryCommunication",Communication_Types.from_Communication _v30))) <$> summary_summaryCommunication record + , (\_v30 -> (2, ("concepts",T.TList (T.T_STRUCT typemap_SummaryConcept) $ P.map (\_v32 -> from_SummaryConcept _v32) $ Vector.toList _v30))) <$> summary_concepts record + ] +write_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> P.IO () +write_Summary oprot record = T.writeVal oprot $ from_Summary record +encode_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> LBS.ByteString +encode_Summary oprot record = T.serializeVal oprot $ from_Summary record +to_Summary :: T.ThriftVal -> Summary +to_Summary (T.TStruct fields) = Summary{ + summary_summaryCommunication = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TStruct _val35 -> (Communication_Types.to_Communication (T.TStruct _val35)); _ -> P.error "wrong type"})) (Map.lookup (1) fields), + summary_concepts = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TList _ _val36 -> (Vector.fromList $ P.map (\_v37 -> (case _v37 of {T.TStruct _val38 -> (to_SummaryConcept (T.TStruct _val38)); _ -> P.error "wrong type"})) _val36); _ -> P.error "wrong type"})) (Map.lookup (2) fields) + } +to_Summary _ = P.error "not a struct" +read_Summary :: (T.Transport t, T.Protocol p) => p t -> P.IO Summary +read_Summary iprot = to_Summary <$> T.readVal iprot (T.T_STRUCT typemap_Summary) +decode_Summary :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Summary +decode_Summary iprot bs = to_Summary $ T.deserializeVal iprot (T.T_STRUCT typemap_Summary) bs +typemap_Summary :: T.TypeMap +typemap_Summary = Map.fromList [(1,("summaryCommunication",(T.T_STRUCT Communication_Types.typemap_Communication))),(2,("concepts",(T.T_LIST (T.T_STRUCT typemap_SummaryConcept))))] +default_Summary :: Summary +default_Summary = Summary{ + summary_summaryCommunication = P.Nothing, + summary_concepts = P.Nothing} data SummarizationCapability = SummarizationCapability { summarizationCapability_type :: SummarySourceType , summarizationCapability_lang :: LT.Text } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)