{-# 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 FeedbackService where
import Prelude (($), (.), (>>=), (==), (++))
import qualified Prelude as P
import qualified Control.Exception as X
import qualified Control.Monad as M ( liftM, ap, when )
import Data.Functor ( (<$>) )
import qualified Data.ByteString.Lazy as LBS
import qualified Data.Hashable as H
import qualified Data.Int as I
import qualified Data.Maybe as M (catMaybes)
import qualified Data.Text.Lazy.Encoding as E ( decodeUtf8, encodeUtf8 )
import qualified Data.Text.Lazy as LT
import qualified GHC.Generics as G (Generic)
import qualified Data.Typeable as TY ( Typeable )
import qualified Data.HashMap.Strict as Map
import qualified Data.HashSet as Set
import qualified Data.Vector as Vector
import qualified Test.QuickCheck.Arbitrary as QC ( Arbitrary(..) )
import qualified Test.QuickCheck as QC ( elements )

import qualified Thrift as T
import qualified Thrift.Types as T
import qualified Thrift.Arbitraries as T

import qualified Communication_Types
import qualified Services_Types
import qualified Structure_Types
import qualified Uuid_Types
import qualified Metadata_Types
import qualified Entities_Types


import qualified Service
import Search_Types
import qualified FeedbackService_Iface as Iface
-- HELPER FUNCTIONS AND STRUCTURES --

data StartFeedback_args = StartFeedback_args  { startFeedback_args_results :: SearchResult
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable StartFeedback_args where
  hashWithSalt salt record = salt   `H.hashWithSalt` startFeedback_args_results record  
instance QC.Arbitrary StartFeedback_args where 
  arbitrary = M.liftM StartFeedback_args (QC.arbitrary)
  shrink obj | obj == default_StartFeedback_args = []
             | P.otherwise = M.catMaybes
    [ if obj == default_StartFeedback_args{startFeedback_args_results = startFeedback_args_results obj} then P.Nothing else P.Just $ default_StartFeedback_args{startFeedback_args_results = startFeedback_args_results obj}
    ]
from_StartFeedback_args :: StartFeedback_args -> T.ThriftVal
from_StartFeedback_args record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v173 -> P.Just (1, ("results",from_SearchResult _v173))) $ startFeedback_args_results record
  ]
write_StartFeedback_args :: (T.Protocol p, T.Transport t) => p t -> StartFeedback_args -> P.IO ()
write_StartFeedback_args oprot record = T.writeVal oprot $ from_StartFeedback_args record
encode_StartFeedback_args :: (T.Protocol p, T.Transport t) => p t -> StartFeedback_args -> LBS.ByteString
encode_StartFeedback_args oprot record = T.serializeVal oprot $ from_StartFeedback_args record
to_StartFeedback_args :: T.ThriftVal -> StartFeedback_args
to_StartFeedback_args (T.TStruct fields) = StartFeedback_args{
  startFeedback_args_results = P.maybe (startFeedback_args_results default_StartFeedback_args) (\(_,_val175) -> (case _val175 of {T.TStruct _val176 -> (to_SearchResult (T.TStruct _val176)); _ -> P.error "wrong type"})) (Map.lookup (1) fields)
  }
to_StartFeedback_args _ = P.error "not a struct"
read_StartFeedback_args :: (T.Transport t, T.Protocol p) => p t -> P.IO StartFeedback_args
read_StartFeedback_args iprot = to_StartFeedback_args <$> T.readVal iprot (T.T_STRUCT typemap_StartFeedback_args)
decode_StartFeedback_args :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> StartFeedback_args
decode_StartFeedback_args iprot bs = to_StartFeedback_args $ T.deserializeVal iprot (T.T_STRUCT typemap_StartFeedback_args) bs
typemap_StartFeedback_args :: T.TypeMap
typemap_StartFeedback_args = Map.fromList [(1,("results",(T.T_STRUCT typemap_SearchResult)))]
default_StartFeedback_args :: StartFeedback_args
default_StartFeedback_args = StartFeedback_args{
  startFeedback_args_results = default_SearchResult}
data StartFeedback_result = StartFeedback_result  { startFeedback_result_ex :: P.Maybe Services_Types.ServicesException
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable StartFeedback_result where
  hashWithSalt salt record = salt   `H.hashWithSalt` startFeedback_result_ex record  
instance QC.Arbitrary StartFeedback_result where 
  arbitrary = M.liftM StartFeedback_result (M.liftM P.Just QC.arbitrary)
  shrink obj | obj == default_StartFeedback_result = []
             | P.otherwise = M.catMaybes
    [ if obj == default_StartFeedback_result{startFeedback_result_ex = startFeedback_result_ex obj} then P.Nothing else P.Just $ default_StartFeedback_result{startFeedback_result_ex = startFeedback_result_ex obj}
    ]
from_StartFeedback_result :: StartFeedback_result -> T.ThriftVal
from_StartFeedback_result record = T.TStruct $ Map.fromList 
  (let exns = M.catMaybes [ (\_v179 -> (1, ("ex",Services_Types.from_ServicesException _v179))) <$> startFeedback_result_ex record]
  in if P.not (P.null exns) then exns else M.catMaybes
    [ (\_v179 -> (1, ("ex",Services_Types.from_ServicesException _v179))) <$> startFeedback_result_ex record
    ]
    )
write_StartFeedback_result :: (T.Protocol p, T.Transport t) => p t -> StartFeedback_result -> P.IO ()
write_StartFeedback_result oprot record = T.writeVal oprot $ from_StartFeedback_result record
encode_StartFeedback_result :: (T.Protocol p, T.Transport t) => p t -> StartFeedback_result -> LBS.ByteString
encode_StartFeedback_result oprot record = T.serializeVal oprot $ from_StartFeedback_result record
to_StartFeedback_result :: T.ThriftVal -> StartFeedback_result
to_StartFeedback_result (T.TStruct fields) = StartFeedback_result{
  startFeedback_result_ex = P.maybe (P.Nothing) (\(_,_val181) -> P.Just (case _val181 of {T.TStruct _val182 -> (Services_Types.to_ServicesException (T.TStruct _val182)); _ -> P.error "wrong type"})) (Map.lookup (1) fields)
  }
to_StartFeedback_result _ = P.error "not a struct"
read_StartFeedback_result :: (T.Transport t, T.Protocol p) => p t -> P.IO StartFeedback_result
read_StartFeedback_result iprot = to_StartFeedback_result <$> T.readVal iprot (T.T_STRUCT typemap_StartFeedback_result)
decode_StartFeedback_result :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> StartFeedback_result
decode_StartFeedback_result iprot bs = to_StartFeedback_result $ T.deserializeVal iprot (T.T_STRUCT typemap_StartFeedback_result) bs
typemap_StartFeedback_result :: T.TypeMap
typemap_StartFeedback_result = Map.fromList [(1,("ex",(T.T_STRUCT Services_Types.typemap_ServicesException)))]
default_StartFeedback_result :: StartFeedback_result
default_StartFeedback_result = StartFeedback_result{
  startFeedback_result_ex = P.Nothing}
data AddCommunicationFeedback_args = AddCommunicationFeedback_args  { addCommunicationFeedback_args_searchResultsId :: Uuid_Types.UUID
  , addCommunicationFeedback_args_communicationId :: LT.Text
  , addCommunicationFeedback_args_feedback :: SearchFeedback
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable AddCommunicationFeedback_args where
  hashWithSalt salt record = salt   `H.hashWithSalt` addCommunicationFeedback_args_searchResultsId record   `H.hashWithSalt` addCommunicationFeedback_args_communicationId record   `H.hashWithSalt` addCommunicationFeedback_args_feedback record  
instance QC.Arbitrary AddCommunicationFeedback_args where 
  arbitrary = M.liftM AddCommunicationFeedback_args (QC.arbitrary)
          `M.ap`(QC.arbitrary)
          `M.ap`(QC.arbitrary)
  shrink obj | obj == default_AddCommunicationFeedback_args = []
             | P.otherwise = M.catMaybes
    [ if obj == default_AddCommunicationFeedback_args{addCommunicationFeedback_args_searchResultsId = addCommunicationFeedback_args_searchResultsId obj} then P.Nothing else P.Just $ default_AddCommunicationFeedback_args{addCommunicationFeedback_args_searchResultsId = addCommunicationFeedback_args_searchResultsId obj}
    , if obj == default_AddCommunicationFeedback_args{addCommunicationFeedback_args_communicationId = addCommunicationFeedback_args_communicationId obj} then P.Nothing else P.Just $ default_AddCommunicationFeedback_args{addCommunicationFeedback_args_communicationId = addCommunicationFeedback_args_communicationId obj}
    , if obj == default_AddCommunicationFeedback_args{addCommunicationFeedback_args_feedback = addCommunicationFeedback_args_feedback obj} then P.Nothing else P.Just $ default_AddCommunicationFeedback_args{addCommunicationFeedback_args_feedback = addCommunicationFeedback_args_feedback obj}
    ]
from_AddCommunicationFeedback_args :: AddCommunicationFeedback_args -> T.ThriftVal
from_AddCommunicationFeedback_args record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v185 -> P.Just (1, ("searchResultsId",Uuid_Types.from_UUID _v185))) $ addCommunicationFeedback_args_searchResultsId record
  , (\_v185 -> P.Just (2, ("communicationId",T.TString $ E.encodeUtf8 _v185))) $ addCommunicationFeedback_args_communicationId record
  , (\_v185 -> P.Just (3, ("feedback",T.TI32 $ P.fromIntegral $ P.fromEnum _v185))) $ addCommunicationFeedback_args_feedback record
  ]
write_AddCommunicationFeedback_args :: (T.Protocol p, T.Transport t) => p t -> AddCommunicationFeedback_args -> P.IO ()
write_AddCommunicationFeedback_args oprot record = T.writeVal oprot $ from_AddCommunicationFeedback_args record
encode_AddCommunicationFeedback_args :: (T.Protocol p, T.Transport t) => p t -> AddCommunicationFeedback_args -> LBS.ByteString
encode_AddCommunicationFeedback_args oprot record = T.serializeVal oprot $ from_AddCommunicationFeedback_args record
to_AddCommunicationFeedback_args :: T.ThriftVal -> AddCommunicationFeedback_args
to_AddCommunicationFeedback_args (T.TStruct fields) = AddCommunicationFeedback_args{
  addCommunicationFeedback_args_searchResultsId = P.maybe (addCommunicationFeedback_args_searchResultsId default_AddCommunicationFeedback_args) (\(_,_val187) -> (case _val187 of {T.TStruct _val188 -> (Uuid_Types.to_UUID (T.TStruct _val188)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),
  addCommunicationFeedback_args_communicationId = P.maybe (addCommunicationFeedback_args_communicationId default_AddCommunicationFeedback_args) (\(_,_val187) -> (case _val187 of {T.TString _val189 -> E.decodeUtf8 _val189; _ -> P.error "wrong type"})) (Map.lookup (2) fields),
  addCommunicationFeedback_args_feedback = P.maybe (addCommunicationFeedback_args_feedback default_AddCommunicationFeedback_args) (\(_,_val187) -> (case _val187 of {T.TI32 _val190 -> P.toEnum $ P.fromIntegral _val190; _ -> P.error "wrong type"})) (Map.lookup (3) fields)
  }
to_AddCommunicationFeedback_args _ = P.error "not a struct"
read_AddCommunicationFeedback_args :: (T.Transport t, T.Protocol p) => p t -> P.IO AddCommunicationFeedback_args
read_AddCommunicationFeedback_args iprot = to_AddCommunicationFeedback_args <$> T.readVal iprot (T.T_STRUCT typemap_AddCommunicationFeedback_args)
decode_AddCommunicationFeedback_args :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> AddCommunicationFeedback_args
decode_AddCommunicationFeedback_args iprot bs = to_AddCommunicationFeedback_args $ T.deserializeVal iprot (T.T_STRUCT typemap_AddCommunicationFeedback_args) bs
typemap_AddCommunicationFeedback_args :: T.TypeMap
typemap_AddCommunicationFeedback_args = Map.fromList [(1,("searchResultsId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("communicationId",T.T_STRING)),(3,("feedback",T.T_I32))]
default_AddCommunicationFeedback_args :: AddCommunicationFeedback_args
default_AddCommunicationFeedback_args = AddCommunicationFeedback_args{
  addCommunicationFeedback_args_searchResultsId = Uuid_Types.default_UUID,
  addCommunicationFeedback_args_communicationId = "",
  addCommunicationFeedback_args_feedback = (P.toEnum 0)}
data AddCommunicationFeedback_result = AddCommunicationFeedback_result  { addCommunicationFeedback_result_ex :: P.Maybe Services_Types.ServicesException
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable AddCommunicationFeedback_result where
  hashWithSalt salt record = salt   `H.hashWithSalt` addCommunicationFeedback_result_ex record  
instance QC.Arbitrary AddCommunicationFeedback_result where 
  arbitrary = M.liftM AddCommunicationFeedback_result (M.liftM P.Just QC.arbitrary)
  shrink obj | obj == default_AddCommunicationFeedback_result = []
             | P.otherwise = M.catMaybes
    [ if obj == default_AddCommunicationFeedback_result{addCommunicationFeedback_result_ex = addCommunicationFeedback_result_ex obj} then P.Nothing else P.Just $ default_AddCommunicationFeedback_result{addCommunicationFeedback_result_ex = addCommunicationFeedback_result_ex obj}
    ]
from_AddCommunicationFeedback_result :: AddCommunicationFeedback_result -> T.ThriftVal
from_AddCommunicationFeedback_result record = T.TStruct $ Map.fromList 
  (let exns = M.catMaybes [ (\_v193 -> (1, ("ex",Services_Types.from_ServicesException _v193))) <$> addCommunicationFeedback_result_ex record]
  in if P.not (P.null exns) then exns else M.catMaybes
    [ (\_v193 -> (1, ("ex",Services_Types.from_ServicesException _v193))) <$> addCommunicationFeedback_result_ex record
    ]
    )
write_AddCommunicationFeedback_result :: (T.Protocol p, T.Transport t) => p t -> AddCommunicationFeedback_result -> P.IO ()
write_AddCommunicationFeedback_result oprot record = T.writeVal oprot $ from_AddCommunicationFeedback_result record
encode_AddCommunicationFeedback_result :: (T.Protocol p, T.Transport t) => p t -> AddCommunicationFeedback_result -> LBS.ByteString
encode_AddCommunicationFeedback_result oprot record = T.serializeVal oprot $ from_AddCommunicationFeedback_result record
to_AddCommunicationFeedback_result :: T.ThriftVal -> AddCommunicationFeedback_result
to_AddCommunicationFeedback_result (T.TStruct fields) = AddCommunicationFeedback_result{
  addCommunicationFeedback_result_ex = P.maybe (P.Nothing) (\(_,_val195) -> P.Just (case _val195 of {T.TStruct _val196 -> (Services_Types.to_ServicesException (T.TStruct _val196)); _ -> P.error "wrong type"})) (Map.lookup (1) fields)
  }
to_AddCommunicationFeedback_result _ = P.error "not a struct"
read_AddCommunicationFeedback_result :: (T.Transport t, T.Protocol p) => p t -> P.IO AddCommunicationFeedback_result
read_AddCommunicationFeedback_result iprot = to_AddCommunicationFeedback_result <$> T.readVal iprot (T.T_STRUCT typemap_AddCommunicationFeedback_result)
decode_AddCommunicationFeedback_result :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> AddCommunicationFeedback_result
decode_AddCommunicationFeedback_result iprot bs = to_AddCommunicationFeedback_result $ T.deserializeVal iprot (T.T_STRUCT typemap_AddCommunicationFeedback_result) bs
typemap_AddCommunicationFeedback_result :: T.TypeMap
typemap_AddCommunicationFeedback_result = Map.fromList [(1,("ex",(T.T_STRUCT Services_Types.typemap_ServicesException)))]
default_AddCommunicationFeedback_result :: AddCommunicationFeedback_result
default_AddCommunicationFeedback_result = AddCommunicationFeedback_result{
  addCommunicationFeedback_result_ex = P.Nothing}
data AddSentenceFeedback_args = AddSentenceFeedback_args  { addSentenceFeedback_args_searchResultsId :: Uuid_Types.UUID
  , addSentenceFeedback_args_communicationId :: LT.Text
  , addSentenceFeedback_args_sentenceId :: Uuid_Types.UUID
  , addSentenceFeedback_args_feedback :: SearchFeedback
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable AddSentenceFeedback_args where
  hashWithSalt salt record = salt   `H.hashWithSalt` addSentenceFeedback_args_searchResultsId record   `H.hashWithSalt` addSentenceFeedback_args_communicationId record   `H.hashWithSalt` addSentenceFeedback_args_sentenceId record   `H.hashWithSalt` addSentenceFeedback_args_feedback record  
instance QC.Arbitrary AddSentenceFeedback_args where 
  arbitrary = M.liftM AddSentenceFeedback_args (QC.arbitrary)
          `M.ap`(QC.arbitrary)
          `M.ap`(QC.arbitrary)
          `M.ap`(QC.arbitrary)
  shrink obj | obj == default_AddSentenceFeedback_args = []
             | P.otherwise = M.catMaybes
    [ if obj == default_AddSentenceFeedback_args{addSentenceFeedback_args_searchResultsId = addSentenceFeedback_args_searchResultsId obj} then P.Nothing else P.Just $ default_AddSentenceFeedback_args{addSentenceFeedback_args_searchResultsId = addSentenceFeedback_args_searchResultsId obj}
    , if obj == default_AddSentenceFeedback_args{addSentenceFeedback_args_communicationId = addSentenceFeedback_args_communicationId obj} then P.Nothing else P.Just $ default_AddSentenceFeedback_args{addSentenceFeedback_args_communicationId = addSentenceFeedback_args_communicationId obj}
    , if obj == default_AddSentenceFeedback_args{addSentenceFeedback_args_sentenceId = addSentenceFeedback_args_sentenceId obj} then P.Nothing else P.Just $ default_AddSentenceFeedback_args{addSentenceFeedback_args_sentenceId = addSentenceFeedback_args_sentenceId obj}
    , if obj == default_AddSentenceFeedback_args{addSentenceFeedback_args_feedback = addSentenceFeedback_args_feedback obj} then P.Nothing else P.Just $ default_AddSentenceFeedback_args{addSentenceFeedback_args_feedback = addSentenceFeedback_args_feedback obj}
    ]
from_AddSentenceFeedback_args :: AddSentenceFeedback_args -> T.ThriftVal
from_AddSentenceFeedback_args record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v199 -> P.Just (1, ("searchResultsId",Uuid_Types.from_UUID _v199))) $ addSentenceFeedback_args_searchResultsId record
  , (\_v199 -> P.Just (2, ("communicationId",T.TString $ E.encodeUtf8 _v199))) $ addSentenceFeedback_args_communicationId record
  , (\_v199 -> P.Just (3, ("sentenceId",Uuid_Types.from_UUID _v199))) $ addSentenceFeedback_args_sentenceId record
  , (\_v199 -> P.Just (4, ("feedback",T.TI32 $ P.fromIntegral $ P.fromEnum _v199))) $ addSentenceFeedback_args_feedback record
  ]
write_AddSentenceFeedback_args :: (T.Protocol p, T.Transport t) => p t -> AddSentenceFeedback_args -> P.IO ()
write_AddSentenceFeedback_args oprot record = T.writeVal oprot $ from_AddSentenceFeedback_args record
encode_AddSentenceFeedback_args :: (T.Protocol p, T.Transport t) => p t -> AddSentenceFeedback_args -> LBS.ByteString
encode_AddSentenceFeedback_args oprot record = T.serializeVal oprot $ from_AddSentenceFeedback_args record
to_AddSentenceFeedback_args :: T.ThriftVal -> AddSentenceFeedback_args
to_AddSentenceFeedback_args (T.TStruct fields) = AddSentenceFeedback_args{
  addSentenceFeedback_args_searchResultsId = P.maybe (addSentenceFeedback_args_searchResultsId default_AddSentenceFeedback_args) (\(_,_val201) -> (case _val201 of {T.TStruct _val202 -> (Uuid_Types.to_UUID (T.TStruct _val202)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),
  addSentenceFeedback_args_communicationId = P.maybe (addSentenceFeedback_args_communicationId default_AddSentenceFeedback_args) (\(_,_val201) -> (case _val201 of {T.TString _val203 -> E.decodeUtf8 _val203; _ -> P.error "wrong type"})) (Map.lookup (2) fields),
  addSentenceFeedback_args_sentenceId = P.maybe (addSentenceFeedback_args_sentenceId default_AddSentenceFeedback_args) (\(_,_val201) -> (case _val201 of {T.TStruct _val204 -> (Uuid_Types.to_UUID (T.TStruct _val204)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),
  addSentenceFeedback_args_feedback = P.maybe (addSentenceFeedback_args_feedback default_AddSentenceFeedback_args) (\(_,_val201) -> (case _val201 of {T.TI32 _val205 -> P.toEnum $ P.fromIntegral _val205; _ -> P.error "wrong type"})) (Map.lookup (4) fields)
  }
to_AddSentenceFeedback_args _ = P.error "not a struct"
read_AddSentenceFeedback_args :: (T.Transport t, T.Protocol p) => p t -> P.IO AddSentenceFeedback_args
read_AddSentenceFeedback_args iprot = to_AddSentenceFeedback_args <$> T.readVal iprot (T.T_STRUCT typemap_AddSentenceFeedback_args)
decode_AddSentenceFeedback_args :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> AddSentenceFeedback_args
decode_AddSentenceFeedback_args iprot bs = to_AddSentenceFeedback_args $ T.deserializeVal iprot (T.T_STRUCT typemap_AddSentenceFeedback_args) bs
typemap_AddSentenceFeedback_args :: T.TypeMap
typemap_AddSentenceFeedback_args = Map.fromList [(1,("searchResultsId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("communicationId",T.T_STRING)),(3,("sentenceId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("feedback",T.T_I32))]
default_AddSentenceFeedback_args :: AddSentenceFeedback_args
default_AddSentenceFeedback_args = AddSentenceFeedback_args{
  addSentenceFeedback_args_searchResultsId = Uuid_Types.default_UUID,
  addSentenceFeedback_args_communicationId = "",
  addSentenceFeedback_args_sentenceId = Uuid_Types.default_UUID,
  addSentenceFeedback_args_feedback = (P.toEnum 0)}
data AddSentenceFeedback_result = AddSentenceFeedback_result  { addSentenceFeedback_result_ex :: P.Maybe Services_Types.ServicesException
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable AddSentenceFeedback_result where
  hashWithSalt salt record = salt   `H.hashWithSalt` addSentenceFeedback_result_ex record  
instance QC.Arbitrary AddSentenceFeedback_result where 
  arbitrary = M.liftM AddSentenceFeedback_result (M.liftM P.Just QC.arbitrary)
  shrink obj | obj == default_AddSentenceFeedback_result = []
             | P.otherwise = M.catMaybes
    [ if obj == default_AddSentenceFeedback_result{addSentenceFeedback_result_ex = addSentenceFeedback_result_ex obj} then P.Nothing else P.Just $ default_AddSentenceFeedback_result{addSentenceFeedback_result_ex = addSentenceFeedback_result_ex obj}
    ]
from_AddSentenceFeedback_result :: AddSentenceFeedback_result -> T.ThriftVal
from_AddSentenceFeedback_result record = T.TStruct $ Map.fromList 
  (let exns = M.catMaybes [ (\_v208 -> (1, ("ex",Services_Types.from_ServicesException _v208))) <$> addSentenceFeedback_result_ex record]
  in if P.not (P.null exns) then exns else M.catMaybes
    [ (\_v208 -> (1, ("ex",Services_Types.from_ServicesException _v208))) <$> addSentenceFeedback_result_ex record
    ]
    )
write_AddSentenceFeedback_result :: (T.Protocol p, T.Transport t) => p t -> AddSentenceFeedback_result -> P.IO ()
write_AddSentenceFeedback_result oprot record = T.writeVal oprot $ from_AddSentenceFeedback_result record
encode_AddSentenceFeedback_result :: (T.Protocol p, T.Transport t) => p t -> AddSentenceFeedback_result -> LBS.ByteString
encode_AddSentenceFeedback_result oprot record = T.serializeVal oprot $ from_AddSentenceFeedback_result record
to_AddSentenceFeedback_result :: T.ThriftVal -> AddSentenceFeedback_result
to_AddSentenceFeedback_result (T.TStruct fields) = AddSentenceFeedback_result{
  addSentenceFeedback_result_ex = P.maybe (P.Nothing) (\(_,_val210) -> P.Just (case _val210 of {T.TStruct _val211 -> (Services_Types.to_ServicesException (T.TStruct _val211)); _ -> P.error "wrong type"})) (Map.lookup (1) fields)
  }
to_AddSentenceFeedback_result _ = P.error "not a struct"
read_AddSentenceFeedback_result :: (T.Transport t, T.Protocol p) => p t -> P.IO AddSentenceFeedback_result
read_AddSentenceFeedback_result iprot = to_AddSentenceFeedback_result <$> T.readVal iprot (T.T_STRUCT typemap_AddSentenceFeedback_result)
decode_AddSentenceFeedback_result :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> AddSentenceFeedback_result
decode_AddSentenceFeedback_result iprot bs = to_AddSentenceFeedback_result $ T.deserializeVal iprot (T.T_STRUCT typemap_AddSentenceFeedback_result) bs
typemap_AddSentenceFeedback_result :: T.TypeMap
typemap_AddSentenceFeedback_result = Map.fromList [(1,("ex",(T.T_STRUCT Services_Types.typemap_ServicesException)))]
default_AddSentenceFeedback_result :: AddSentenceFeedback_result
default_AddSentenceFeedback_result = AddSentenceFeedback_result{
  addSentenceFeedback_result_ex = P.Nothing}
process_startFeedback (seqid, iprot, oprot, handler) = do
  args <- read_StartFeedback_args iprot
  (X.catch
    (X.catch
      (do
        Iface.startFeedback handler (startFeedback_args_results args)
        let res = default_StartFeedback_result
        T.writeMessageBegin oprot ("startFeedback", T.M_REPLY, seqid)
        write_StartFeedback_result oprot res
        T.writeMessageEnd oprot
        T.tFlush (T.getTransport oprot))
      (\e  -> do
        let res = default_StartFeedback_result{startFeedback_result_ex = P.Just e}
        T.writeMessageBegin oprot ("startFeedback", T.M_REPLY, seqid)
        write_StartFeedback_result oprot res
        T.writeMessageEnd oprot
        T.tFlush (T.getTransport oprot)))
    ((\_ -> do
      T.writeMessageBegin oprot ("startFeedback", T.M_EXCEPTION, seqid)
      T.writeAppExn oprot (T.AppExn T.AE_UNKNOWN "")
      T.writeMessageEnd oprot
      T.tFlush (T.getTransport oprot)) :: X.SomeException -> P.IO ()))
process_addCommunicationFeedback (seqid, iprot, oprot, handler) = do
  args <- read_AddCommunicationFeedback_args iprot
  (X.catch
    (X.catch
      (do
        Iface.addCommunicationFeedback handler (addCommunicationFeedback_args_searchResultsId args) (addCommunicationFeedback_args_communicationId args) (addCommunicationFeedback_args_feedback args)
        let res = default_AddCommunicationFeedback_result
        T.writeMessageBegin oprot ("addCommunicationFeedback", T.M_REPLY, seqid)
        write_AddCommunicationFeedback_result oprot res
        T.writeMessageEnd oprot
        T.tFlush (T.getTransport oprot))
      (\e  -> do
        let res = default_AddCommunicationFeedback_result{addCommunicationFeedback_result_ex = P.Just e}
        T.writeMessageBegin oprot ("addCommunicationFeedback", T.M_REPLY, seqid)
        write_AddCommunicationFeedback_result oprot res
        T.writeMessageEnd oprot
        T.tFlush (T.getTransport oprot)))
    ((\_ -> do
      T.writeMessageBegin oprot ("addCommunicationFeedback", T.M_EXCEPTION, seqid)
      T.writeAppExn oprot (T.AppExn T.AE_UNKNOWN "")
      T.writeMessageEnd oprot
      T.tFlush (T.getTransport oprot)) :: X.SomeException -> P.IO ()))
process_addSentenceFeedback (seqid, iprot, oprot, handler) = do
  args <- read_AddSentenceFeedback_args iprot
  (X.catch
    (X.catch
      (do
        Iface.addSentenceFeedback handler (addSentenceFeedback_args_searchResultsId args) (addSentenceFeedback_args_communicationId args) (addSentenceFeedback_args_sentenceId args) (addSentenceFeedback_args_feedback args)
        let res = default_AddSentenceFeedback_result
        T.writeMessageBegin oprot ("addSentenceFeedback", T.M_REPLY, seqid)
        write_AddSentenceFeedback_result oprot res
        T.writeMessageEnd oprot
        T.tFlush (T.getTransport oprot))
      (\e  -> do
        let res = default_AddSentenceFeedback_result{addSentenceFeedback_result_ex = P.Just e}
        T.writeMessageBegin oprot ("addSentenceFeedback", T.M_REPLY, seqid)
        write_AddSentenceFeedback_result oprot res
        T.writeMessageEnd oprot
        T.tFlush (T.getTransport oprot)))
    ((\_ -> do
      T.writeMessageBegin oprot ("addSentenceFeedback", T.M_EXCEPTION, seqid)
      T.writeAppExn oprot (T.AppExn T.AE_UNKNOWN "")
      T.writeMessageEnd oprot
      T.tFlush (T.getTransport oprot)) :: X.SomeException -> P.IO ()))
proc_ handler (iprot,oprot) (name,typ,seqid) = case name of
  "startFeedback" -> process_startFeedback (seqid,iprot,oprot,handler)
  "addCommunicationFeedback" -> process_addCommunicationFeedback (seqid,iprot,oprot,handler)
  "addSentenceFeedback" -> process_addSentenceFeedback (seqid,iprot,oprot,handler)
  _ -> Service.proc_ handler (iprot,oprot) (name,typ,seqid)
process handler (iprot, oprot) = do
  (name, typ, seqid) <- T.readMessageBegin iprot
  proc_ handler (iprot,oprot) (name,typ,seqid)
  T.readMessageEnd iprot
  P.return P.True