{-# 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.Access_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.Communication_Types as Communication_Types
import Data.Concrete.Autogen.Services_Types as Services_Types


data FetchResult = FetchResult  { fetchResult_communications :: (Vector.Vector Communication_Types.Communication)
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable FetchResult where
  hashWithSalt salt record = salt   `H.hashWithSalt` fetchResult_communications record  
instance QC.Arbitrary FetchResult where 
  arbitrary = M.liftM FetchResult (QC.arbitrary)
  shrink obj | obj == default_FetchResult = []
             | P.otherwise = M.catMaybes
    [ if obj == default_FetchResult{fetchResult_communications = fetchResult_communications obj} then P.Nothing else P.Just $ default_FetchResult{fetchResult_communications = fetchResult_communications obj}
    ]
from_FetchResult :: FetchResult -> T.ThriftVal
from_FetchResult record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v2 -> P.Just (1, ("communications",T.TList (T.T_STRUCT Communication_Types.typemap_Communication) $ P.map (\_v4 -> Communication_Types.from_Communication _v4) $ Vector.toList _v2))) $ fetchResult_communications record
  ]
write_FetchResult :: (T.Protocol p, T.Transport t) => p t -> FetchResult -> P.IO ()
write_FetchResult oprot record = T.writeVal oprot $ from_FetchResult record
encode_FetchResult :: (T.Protocol p, T.Transport t) => p t -> FetchResult -> LBS.ByteString
encode_FetchResult oprot record = T.serializeVal oprot $ from_FetchResult record
to_FetchResult :: T.ThriftVal -> FetchResult
to_FetchResult (T.TStruct fields) = FetchResult{
  fetchResult_communications = P.maybe (P.error "Missing required field: communications") (\(_,_val6) -> (case _val6 of {T.TList _ _val7 -> (Vector.fromList $ P.map (\_v8 -> (case _v8 of {T.TStruct _val9 -> (Communication_Types.to_Communication (T.TStruct _val9)); _ -> P.error "wrong type"})) _val7); _ -> P.error "wrong type"})) (Map.lookup (1) fields)
  }
to_FetchResult _ = P.error "not a struct"
read_FetchResult :: (T.Transport t, T.Protocol p) => p t -> P.IO FetchResult
read_FetchResult iprot = to_FetchResult <$> T.readVal iprot (T.T_STRUCT typemap_FetchResult)
decode_FetchResult :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> FetchResult
decode_FetchResult iprot bs = to_FetchResult $ T.deserializeVal iprot (T.T_STRUCT typemap_FetchResult) bs
typemap_FetchResult :: T.TypeMap
typemap_FetchResult = Map.fromList [(1,("communications",(T.T_LIST (T.T_STRUCT Communication_Types.typemap_Communication))))]
default_FetchResult :: FetchResult
default_FetchResult = FetchResult{
  fetchResult_communications = Vector.empty}
data FetchRequest = FetchRequest  { fetchRequest_communicationIds :: (Vector.Vector LT.Text)
  , fetchRequest_auths :: P.Maybe LT.Text
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable FetchRequest where
  hashWithSalt salt record = salt   `H.hashWithSalt` fetchRequest_communicationIds record   `H.hashWithSalt` fetchRequest_auths record  
instance QC.Arbitrary FetchRequest where 
  arbitrary = M.liftM FetchRequest (QC.arbitrary)
          `M.ap`(M.liftM P.Just QC.arbitrary)
  shrink obj | obj == default_FetchRequest = []
             | P.otherwise = M.catMaybes
    [ if obj == default_FetchRequest{fetchRequest_communicationIds = fetchRequest_communicationIds obj} then P.Nothing else P.Just $ default_FetchRequest{fetchRequest_communicationIds = fetchRequest_communicationIds obj}
    , if obj == default_FetchRequest{fetchRequest_auths = fetchRequest_auths obj} then P.Nothing else P.Just $ default_FetchRequest{fetchRequest_auths = fetchRequest_auths obj}
    ]
from_FetchRequest :: FetchRequest -> T.ThriftVal
from_FetchRequest record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v12 -> P.Just (1, ("communicationIds",T.TList T.T_STRING $ P.map (\_v14 -> T.TString $ E.encodeUtf8 _v14) $ Vector.toList _v12))) $ fetchRequest_communicationIds record
  , (\_v12 -> (2, ("auths",T.TString $ E.encodeUtf8 _v12))) <$> fetchRequest_auths record
  ]
write_FetchRequest :: (T.Protocol p, T.Transport t) => p t -> FetchRequest -> P.IO ()
write_FetchRequest oprot record = T.writeVal oprot $ from_FetchRequest record
encode_FetchRequest :: (T.Protocol p, T.Transport t) => p t -> FetchRequest -> LBS.ByteString
encode_FetchRequest oprot record = T.serializeVal oprot $ from_FetchRequest record
to_FetchRequest :: T.ThriftVal -> FetchRequest
to_FetchRequest (T.TStruct fields) = FetchRequest{
  fetchRequest_communicationIds = P.maybe (P.error "Missing required field: communicationIds") (\(_,_val16) -> (case _val16 of {T.TList _ _val17 -> (Vector.fromList $ P.map (\_v18 -> (case _v18 of {T.TString _val19 -> E.decodeUtf8 _val19; _ -> P.error "wrong type"})) _val17); _ -> P.error "wrong type"})) (Map.lookup (1) fields),
  fetchRequest_auths = P.maybe (P.Nothing) (\(_,_val16) -> P.Just (case _val16 of {T.TString _val20 -> E.decodeUtf8 _val20; _ -> P.error "wrong type"})) (Map.lookup (2) fields)
  }
to_FetchRequest _ = P.error "not a struct"
read_FetchRequest :: (T.Transport t, T.Protocol p) => p t -> P.IO FetchRequest
read_FetchRequest iprot = to_FetchRequest <$> T.readVal iprot (T.T_STRUCT typemap_FetchRequest)
decode_FetchRequest :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> FetchRequest
decode_FetchRequest iprot bs = to_FetchRequest $ T.deserializeVal iprot (T.T_STRUCT typemap_FetchRequest) bs
typemap_FetchRequest :: T.TypeMap
typemap_FetchRequest = Map.fromList [(1,("communicationIds",(T.T_LIST T.T_STRING))),(2,("auths",T.T_STRING))]
default_FetchRequest :: FetchRequest
default_FetchRequest = FetchRequest{
  fetchRequest_communicationIds = Vector.empty,
  fetchRequest_auths = P.Nothing}