{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-missing-fields #-}
{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-----------------------------------------------------------------
-- Autogenerated by Thrift Compiler (0.9.3)                      --
--                                                             --
-- DO NOT EDIT UNLESS YOU ARE SURE YOU KNOW WHAT YOU ARE DOING --
-----------------------------------------------------------------

module Spans_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


data TextSpan = TextSpan  { textSpan_start :: I.Int32
  , textSpan_ending :: I.Int32
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable TextSpan where
  hashWithSalt salt record = salt   `H.hashWithSalt` textSpan_start record   `H.hashWithSalt` textSpan_ending record  
instance QC.Arbitrary TextSpan where 
  arbitrary = M.liftM TextSpan (QC.arbitrary)
          `M.ap`(QC.arbitrary)
  shrink obj | obj == default_TextSpan = []
             | P.otherwise = M.catMaybes
    [ if obj == default_TextSpan{textSpan_start = textSpan_start obj} then P.Nothing else P.Just $ default_TextSpan{textSpan_start = textSpan_start obj}
    , if obj == default_TextSpan{textSpan_ending = textSpan_ending obj} then P.Nothing else P.Just $ default_TextSpan{textSpan_ending = textSpan_ending obj}
    ]
from_TextSpan :: TextSpan -> T.ThriftVal
from_TextSpan record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v2 -> P.Just (1, ("start",T.TI32 _v2))) $ textSpan_start record
  , (\_v2 -> P.Just (2, ("ending",T.TI32 _v2))) $ textSpan_ending record
  ]
write_TextSpan :: (T.Protocol p, T.Transport t) => p t -> TextSpan -> P.IO ()
write_TextSpan oprot record = T.writeVal oprot $ from_TextSpan record
encode_TextSpan :: (T.Protocol p, T.Transport t) => p t -> TextSpan -> LBS.ByteString
encode_TextSpan oprot record = T.serializeVal oprot $ from_TextSpan record
to_TextSpan :: T.ThriftVal -> TextSpan
to_TextSpan (T.TStruct fields) = TextSpan{
  textSpan_start = P.maybe (P.error "Missing required field: start") (\(_,_val4) -> (case _val4 of {T.TI32 _val5 -> _val5; _ -> P.error "wrong type"})) (Map.lookup (1) fields),
  textSpan_ending = P.maybe (P.error "Missing required field: ending") (\(_,_val4) -> (case _val4 of {T.TI32 _val6 -> _val6; _ -> P.error "wrong type"})) (Map.lookup (2) fields)
  }
to_TextSpan _ = P.error "not a struct"
read_TextSpan :: (T.Transport t, T.Protocol p) => p t -> P.IO TextSpan
read_TextSpan iprot = to_TextSpan <$> T.readVal iprot (T.T_STRUCT typemap_TextSpan)
decode_TextSpan :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TextSpan
decode_TextSpan iprot bs = to_TextSpan $ T.deserializeVal iprot (T.T_STRUCT typemap_TextSpan) bs
typemap_TextSpan :: T.TypeMap
typemap_TextSpan = Map.fromList [(1,("start",T.T_I32)),(2,("ending",T.T_I32))]
default_TextSpan :: TextSpan
default_TextSpan = TextSpan{
  textSpan_start = 0,
  textSpan_ending = 0}
data AudioSpan = AudioSpan  { audioSpan_start :: I.Int64
  , audioSpan_ending :: I.Int64
  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)
instance H.Hashable AudioSpan where
  hashWithSalt salt record = salt   `H.hashWithSalt` audioSpan_start record   `H.hashWithSalt` audioSpan_ending record  
instance QC.Arbitrary AudioSpan where 
  arbitrary = M.liftM AudioSpan (QC.arbitrary)
          `M.ap`(QC.arbitrary)
  shrink obj | obj == default_AudioSpan = []
             | P.otherwise = M.catMaybes
    [ if obj == default_AudioSpan{audioSpan_start = audioSpan_start obj} then P.Nothing else P.Just $ default_AudioSpan{audioSpan_start = audioSpan_start obj}
    , if obj == default_AudioSpan{audioSpan_ending = audioSpan_ending obj} then P.Nothing else P.Just $ default_AudioSpan{audioSpan_ending = audioSpan_ending obj}
    ]
from_AudioSpan :: AudioSpan -> T.ThriftVal
from_AudioSpan record = T.TStruct $ Map.fromList $ M.catMaybes
  [ (\_v9 -> P.Just (1, ("start",T.TI64 _v9))) $ audioSpan_start record
  , (\_v9 -> P.Just (2, ("ending",T.TI64 _v9))) $ audioSpan_ending record
  ]
write_AudioSpan :: (T.Protocol p, T.Transport t) => p t -> AudioSpan -> P.IO ()
write_AudioSpan oprot record = T.writeVal oprot $ from_AudioSpan record
encode_AudioSpan :: (T.Protocol p, T.Transport t) => p t -> AudioSpan -> LBS.ByteString
encode_AudioSpan oprot record = T.serializeVal oprot $ from_AudioSpan record
to_AudioSpan :: T.ThriftVal -> AudioSpan
to_AudioSpan (T.TStruct fields) = AudioSpan{
  audioSpan_start = P.maybe (P.error "Missing required field: start") (\(_,_val11) -> (case _val11 of {T.TI64 _val12 -> _val12; _ -> P.error "wrong type"})) (Map.lookup (1) fields),
  audioSpan_ending = P.maybe (P.error "Missing required field: ending") (\(_,_val11) -> (case _val11 of {T.TI64 _val13 -> _val13; _ -> P.error "wrong type"})) (Map.lookup (2) fields)
  }
to_AudioSpan _ = P.error "not a struct"
read_AudioSpan :: (T.Transport t, T.Protocol p) => p t -> P.IO AudioSpan
read_AudioSpan iprot = to_AudioSpan <$> T.readVal iprot (T.T_STRUCT typemap_AudioSpan)
decode_AudioSpan :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> AudioSpan
decode_AudioSpan iprot bs = to_AudioSpan $ T.deserializeVal iprot (T.T_STRUCT typemap_AudioSpan) bs
typemap_AudioSpan :: T.TypeMap
typemap_AudioSpan = Map.fromList [(1,("start",T.T_I64)),(2,("ending",T.T_I64))]
default_AudioSpan :: AudioSpan
default_AudioSpan = AudioSpan{
  audioSpan_start = 0,
  audioSpan_ending = 0}