module Database.Cassandra.Thrift.Cassandra where
import Thrift
import Data.Typeable ( Typeable )
import Control.Exception
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.ByteString.Lazy
import Data.Int
import Data.Word
import Prelude ((==), String, Eq, Show, Ord, Maybe(..), (&&), (||), return, IO, Enum, fromIntegral, fromEnum, toEnum, Bool(..), (++), ($), Double, (), length)
import Database.Cassandra.Thrift.Cassandra_Types
import qualified Database.Cassandra.Thrift.Cassandra_Iface as Iface
data Login_args = Login_args{f_Login_args_auth_request :: Maybe AuthenticationRequest} deriving (Show,Eq,Ord,Typeable)
write_Login_args oprot record = do
writeStructBegin oprot "Login_args"
case f_Login_args_auth_request record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("auth_request",T_STRUCT,1)
write_AuthenticationRequest oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Login_args_fields iprot record = do
(_,_t184,_id185) <- readFieldBegin iprot
if _t184 == T_STOP then return record else
case _id185 of
1 -> if _t184 == T_STRUCT then do
s <- (read_AuthenticationRequest iprot)
read_Login_args_fields iprot record{f_Login_args_auth_request=Just s}
else do
skip iprot _t184
read_Login_args_fields iprot record
_ -> do
skip iprot _t184
readFieldEnd iprot
read_Login_args_fields iprot record
read_Login_args iprot = do
_ <- readStructBegin iprot
record <- read_Login_args_fields iprot (Login_args{f_Login_args_auth_request=Nothing})
readStructEnd iprot
return record
data Login_result = Login_result{f_Login_result_authnx :: Maybe AuthenticationException,f_Login_result_authzx :: Maybe AuthorizationException} deriving (Show,Eq,Ord,Typeable)
write_Login_result oprot record = do
writeStructBegin oprot "Login_result"
case f_Login_result_authnx record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("authnx",T_STRUCT,1)
write_AuthenticationException oprot _v
writeFieldEnd oprot}
case f_Login_result_authzx record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("authzx",T_STRUCT,2)
write_AuthorizationException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Login_result_fields iprot record = do
(_,_t189,_id190) <- readFieldBegin iprot
if _t189 == T_STOP then return record else
case _id190 of
1 -> if _t189 == T_STRUCT then do
s <- (read_AuthenticationException iprot)
read_Login_result_fields iprot record{f_Login_result_authnx=Just s}
else do
skip iprot _t189
read_Login_result_fields iprot record
2 -> if _t189 == T_STRUCT then do
s <- (read_AuthorizationException iprot)
read_Login_result_fields iprot record{f_Login_result_authzx=Just s}
else do
skip iprot _t189
read_Login_result_fields iprot record
_ -> do
skip iprot _t189
readFieldEnd iprot
read_Login_result_fields iprot record
read_Login_result iprot = do
_ <- readStructBegin iprot
record <- read_Login_result_fields iprot (Login_result{f_Login_result_authnx=Nothing,f_Login_result_authzx=Nothing})
readStructEnd iprot
return record
data Set_keyspace_args = Set_keyspace_args{f_Set_keyspace_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Set_keyspace_args oprot record = do
writeStructBegin oprot "Set_keyspace_args"
case f_Set_keyspace_args_keyspace record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keyspace",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Set_keyspace_args_fields iprot record = do
(_,_t194,_id195) <- readFieldBegin iprot
if _t194 == T_STOP then return record else
case _id195 of
1 -> if _t194 == T_STRING then do
s <- readString iprot
read_Set_keyspace_args_fields iprot record{f_Set_keyspace_args_keyspace=Just s}
else do
skip iprot _t194
read_Set_keyspace_args_fields iprot record
_ -> do
skip iprot _t194
readFieldEnd iprot
read_Set_keyspace_args_fields iprot record
read_Set_keyspace_args iprot = do
_ <- readStructBegin iprot
record <- read_Set_keyspace_args_fields iprot (Set_keyspace_args{f_Set_keyspace_args_keyspace=Nothing})
readStructEnd iprot
return record
data Set_keyspace_result = Set_keyspace_result{f_Set_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Set_keyspace_result oprot record = do
writeStructBegin oprot "Set_keyspace_result"
case f_Set_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Set_keyspace_result_fields iprot record = do
(_,_t199,_id200) <- readFieldBegin iprot
if _t199 == T_STOP then return record else
case _id200 of
1 -> if _t199 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Set_keyspace_result_fields iprot record{f_Set_keyspace_result_ire=Just s}
else do
skip iprot _t199
read_Set_keyspace_result_fields iprot record
_ -> do
skip iprot _t199
readFieldEnd iprot
read_Set_keyspace_result_fields iprot record
read_Set_keyspace_result iprot = do
_ <- readStructBegin iprot
record <- read_Set_keyspace_result_fields iprot (Set_keyspace_result{f_Set_keyspace_result_ire=Nothing})
readStructEnd iprot
return record
data Get_args = Get_args{f_Get_args_key :: Maybe ByteString,f_Get_args_column_path :: Maybe ColumnPath,f_Get_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_args oprot record = do
writeStructBegin oprot "Get_args"
case f_Get_args_key record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("key",T_STRING,1)
writeBinary oprot _v
writeFieldEnd oprot}
case f_Get_args_column_path record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_path",T_STRUCT,2)
write_ColumnPath oprot _v
writeFieldEnd oprot}
case f_Get_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,3)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_args_fields iprot record = do
(_,_t204,_id205) <- readFieldBegin iprot
if _t204 == T_STOP then return record else
case _id205 of
1 -> if _t204 == T_STRING then do
s <- readBinary iprot
read_Get_args_fields iprot record{f_Get_args_key=Just s}
else do
skip iprot _t204
read_Get_args_fields iprot record
2 -> if _t204 == T_STRUCT then do
s <- (read_ColumnPath iprot)
read_Get_args_fields iprot record{f_Get_args_column_path=Just s}
else do
skip iprot _t204
read_Get_args_fields iprot record
3 -> if _t204 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Get_args_fields iprot record{f_Get_args_consistency_level=Just s}
else do
skip iprot _t204
read_Get_args_fields iprot record
_ -> do
skip iprot _t204
readFieldEnd iprot
read_Get_args_fields iprot record
read_Get_args iprot = do
_ <- readStructBegin iprot
record <- read_Get_args_fields iprot (Get_args{f_Get_args_key=Nothing,f_Get_args_column_path=Nothing,f_Get_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Get_result = Get_result{f_Get_result_success :: Maybe ColumnOrSuperColumn,f_Get_result_ire :: Maybe InvalidRequestException,f_Get_result_nfe :: Maybe NotFoundException,f_Get_result_ue :: Maybe UnavailableException,f_Get_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_result oprot record = do
writeStructBegin oprot "Get_result"
case f_Get_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRUCT,0)
write_ColumnOrSuperColumn oprot _v
writeFieldEnd oprot}
case f_Get_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Get_result_nfe record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("nfe",T_STRUCT,2)
write_NotFoundException oprot _v
writeFieldEnd oprot}
case f_Get_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,3)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Get_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,4)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_result_fields iprot record = do
(_,_t209,_id210) <- readFieldBegin iprot
if _t209 == T_STOP then return record else
case _id210 of
0 -> if _t209 == T_STRUCT then do
s <- (read_ColumnOrSuperColumn iprot)
read_Get_result_fields iprot record{f_Get_result_success=Just s}
else do
skip iprot _t209
read_Get_result_fields iprot record
1 -> if _t209 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Get_result_fields iprot record{f_Get_result_ire=Just s}
else do
skip iprot _t209
read_Get_result_fields iprot record
2 -> if _t209 == T_STRUCT then do
s <- (read_NotFoundException iprot)
read_Get_result_fields iprot record{f_Get_result_nfe=Just s}
else do
skip iprot _t209
read_Get_result_fields iprot record
3 -> if _t209 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Get_result_fields iprot record{f_Get_result_ue=Just s}
else do
skip iprot _t209
read_Get_result_fields iprot record
4 -> if _t209 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Get_result_fields iprot record{f_Get_result_te=Just s}
else do
skip iprot _t209
read_Get_result_fields iprot record
_ -> do
skip iprot _t209
readFieldEnd iprot
read_Get_result_fields iprot record
read_Get_result iprot = do
_ <- readStructBegin iprot
record <- read_Get_result_fields iprot (Get_result{f_Get_result_success=Nothing,f_Get_result_ire=Nothing,f_Get_result_nfe=Nothing,f_Get_result_ue=Nothing,f_Get_result_te=Nothing})
readStructEnd iprot
return record
data Get_slice_args = Get_slice_args{f_Get_slice_args_key :: Maybe ByteString,f_Get_slice_args_column_parent :: Maybe ColumnParent,f_Get_slice_args_predicate :: Maybe SlicePredicate,f_Get_slice_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_slice_args oprot record = do
writeStructBegin oprot "Get_slice_args"
case f_Get_slice_args_key record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("key",T_STRING,1)
writeBinary oprot _v
writeFieldEnd oprot}
case f_Get_slice_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,2)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Get_slice_args_predicate record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("predicate",T_STRUCT,3)
write_SlicePredicate oprot _v
writeFieldEnd oprot}
case f_Get_slice_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_slice_args_fields iprot record = do
(_,_t214,_id215) <- readFieldBegin iprot
if _t214 == T_STOP then return record else
case _id215 of
1 -> if _t214 == T_STRING then do
s <- readBinary iprot
read_Get_slice_args_fields iprot record{f_Get_slice_args_key=Just s}
else do
skip iprot _t214
read_Get_slice_args_fields iprot record
2 -> if _t214 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Get_slice_args_fields iprot record{f_Get_slice_args_column_parent=Just s}
else do
skip iprot _t214
read_Get_slice_args_fields iprot record
3 -> if _t214 == T_STRUCT then do
s <- (read_SlicePredicate iprot)
read_Get_slice_args_fields iprot record{f_Get_slice_args_predicate=Just s}
else do
skip iprot _t214
read_Get_slice_args_fields iprot record
4 -> if _t214 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Get_slice_args_fields iprot record{f_Get_slice_args_consistency_level=Just s}
else do
skip iprot _t214
read_Get_slice_args_fields iprot record
_ -> do
skip iprot _t214
readFieldEnd iprot
read_Get_slice_args_fields iprot record
read_Get_slice_args iprot = do
_ <- readStructBegin iprot
record <- read_Get_slice_args_fields iprot (Get_slice_args{f_Get_slice_args_key=Nothing,f_Get_slice_args_column_parent=Nothing,f_Get_slice_args_predicate=Nothing,f_Get_slice_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Get_slice_result = Get_slice_result{f_Get_slice_result_success :: Maybe [ColumnOrSuperColumn],f_Get_slice_result_ire :: Maybe InvalidRequestException,f_Get_slice_result_ue :: Maybe UnavailableException,f_Get_slice_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_slice_result oprot record = do
writeStructBegin oprot "Get_slice_result"
case f_Get_slice_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_LIST,0)
(let {f [] = return (); f (_viter218:t) = do {write_ColumnOrSuperColumn oprot _viter218;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Get_slice_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Get_slice_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Get_slice_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_slice_result_fields iprot record = do
(_,_t220,_id221) <- readFieldBegin iprot
if _t220 == T_STOP then return record else
case _id221 of
0 -> if _t220 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- (read_ColumnOrSuperColumn iprot);r <- f (n1); return $ v:r}} in do {(_etype225,_size222) <- readListBegin iprot; f _size222})
read_Get_slice_result_fields iprot record{f_Get_slice_result_success=Just s}
else do
skip iprot _t220
read_Get_slice_result_fields iprot record
1 -> if _t220 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Get_slice_result_fields iprot record{f_Get_slice_result_ire=Just s}
else do
skip iprot _t220
read_Get_slice_result_fields iprot record
2 -> if _t220 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Get_slice_result_fields iprot record{f_Get_slice_result_ue=Just s}
else do
skip iprot _t220
read_Get_slice_result_fields iprot record
3 -> if _t220 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Get_slice_result_fields iprot record{f_Get_slice_result_te=Just s}
else do
skip iprot _t220
read_Get_slice_result_fields iprot record
_ -> do
skip iprot _t220
readFieldEnd iprot
read_Get_slice_result_fields iprot record
read_Get_slice_result iprot = do
_ <- readStructBegin iprot
record <- read_Get_slice_result_fields iprot (Get_slice_result{f_Get_slice_result_success=Nothing,f_Get_slice_result_ire=Nothing,f_Get_slice_result_ue=Nothing,f_Get_slice_result_te=Nothing})
readStructEnd iprot
return record
data Get_count_args = Get_count_args{f_Get_count_args_key :: Maybe ByteString,f_Get_count_args_column_parent :: Maybe ColumnParent,f_Get_count_args_predicate :: Maybe SlicePredicate,f_Get_count_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_count_args oprot record = do
writeStructBegin oprot "Get_count_args"
case f_Get_count_args_key record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("key",T_STRING,1)
writeBinary oprot _v
writeFieldEnd oprot}
case f_Get_count_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,2)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Get_count_args_predicate record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("predicate",T_STRUCT,3)
write_SlicePredicate oprot _v
writeFieldEnd oprot}
case f_Get_count_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_count_args_fields iprot record = do
(_,_t230,_id231) <- readFieldBegin iprot
if _t230 == T_STOP then return record else
case _id231 of
1 -> if _t230 == T_STRING then do
s <- readBinary iprot
read_Get_count_args_fields iprot record{f_Get_count_args_key=Just s}
else do
skip iprot _t230
read_Get_count_args_fields iprot record
2 -> if _t230 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Get_count_args_fields iprot record{f_Get_count_args_column_parent=Just s}
else do
skip iprot _t230
read_Get_count_args_fields iprot record
3 -> if _t230 == T_STRUCT then do
s <- (read_SlicePredicate iprot)
read_Get_count_args_fields iprot record{f_Get_count_args_predicate=Just s}
else do
skip iprot _t230
read_Get_count_args_fields iprot record
4 -> if _t230 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Get_count_args_fields iprot record{f_Get_count_args_consistency_level=Just s}
else do
skip iprot _t230
read_Get_count_args_fields iprot record
_ -> do
skip iprot _t230
readFieldEnd iprot
read_Get_count_args_fields iprot record
read_Get_count_args iprot = do
_ <- readStructBegin iprot
record <- read_Get_count_args_fields iprot (Get_count_args{f_Get_count_args_key=Nothing,f_Get_count_args_column_parent=Nothing,f_Get_count_args_predicate=Nothing,f_Get_count_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Get_count_result = Get_count_result{f_Get_count_result_success :: Maybe Int32,f_Get_count_result_ire :: Maybe InvalidRequestException,f_Get_count_result_ue :: Maybe UnavailableException,f_Get_count_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_count_result oprot record = do
writeStructBegin oprot "Get_count_result"
case f_Get_count_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_I32,0)
writeI32 oprot _v
writeFieldEnd oprot}
case f_Get_count_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Get_count_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Get_count_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_count_result_fields iprot record = do
(_,_t235,_id236) <- readFieldBegin iprot
if _t235 == T_STOP then return record else
case _id236 of
0 -> if _t235 == T_I32 then do
s <- readI32 iprot
read_Get_count_result_fields iprot record{f_Get_count_result_success=Just s}
else do
skip iprot _t235
read_Get_count_result_fields iprot record
1 -> if _t235 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Get_count_result_fields iprot record{f_Get_count_result_ire=Just s}
else do
skip iprot _t235
read_Get_count_result_fields iprot record
2 -> if _t235 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Get_count_result_fields iprot record{f_Get_count_result_ue=Just s}
else do
skip iprot _t235
read_Get_count_result_fields iprot record
3 -> if _t235 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Get_count_result_fields iprot record{f_Get_count_result_te=Just s}
else do
skip iprot _t235
read_Get_count_result_fields iprot record
_ -> do
skip iprot _t235
readFieldEnd iprot
read_Get_count_result_fields iprot record
read_Get_count_result iprot = do
_ <- readStructBegin iprot
record <- read_Get_count_result_fields iprot (Get_count_result{f_Get_count_result_success=Nothing,f_Get_count_result_ire=Nothing,f_Get_count_result_ue=Nothing,f_Get_count_result_te=Nothing})
readStructEnd iprot
return record
data Multiget_slice_args = Multiget_slice_args{f_Multiget_slice_args_keys :: Maybe [ByteString],f_Multiget_slice_args_column_parent :: Maybe ColumnParent,f_Multiget_slice_args_predicate :: Maybe SlicePredicate,f_Multiget_slice_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Multiget_slice_args oprot record = do
writeStructBegin oprot "Multiget_slice_args"
case f_Multiget_slice_args_keys record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keys",T_LIST,1)
(let {f [] = return (); f (_viter239:t) = do {writeBinary oprot _viter239;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Multiget_slice_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,2)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Multiget_slice_args_predicate record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("predicate",T_STRUCT,3)
write_SlicePredicate oprot _v
writeFieldEnd oprot}
case f_Multiget_slice_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Multiget_slice_args_fields iprot record = do
(_,_t241,_id242) <- readFieldBegin iprot
if _t241 == T_STOP then return record else
case _id242 of
1 -> if _t241 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- readBinary iprot;r <- f (n1); return $ v:r}} in do {(_etype246,_size243) <- readListBegin iprot; f _size243})
read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_keys=Just s}
else do
skip iprot _t241
read_Multiget_slice_args_fields iprot record
2 -> if _t241 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_column_parent=Just s}
else do
skip iprot _t241
read_Multiget_slice_args_fields iprot record
3 -> if _t241 == T_STRUCT then do
s <- (read_SlicePredicate iprot)
read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_predicate=Just s}
else do
skip iprot _t241
read_Multiget_slice_args_fields iprot record
4 -> if _t241 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Multiget_slice_args_fields iprot record{f_Multiget_slice_args_consistency_level=Just s}
else do
skip iprot _t241
read_Multiget_slice_args_fields iprot record
_ -> do
skip iprot _t241
readFieldEnd iprot
read_Multiget_slice_args_fields iprot record
read_Multiget_slice_args iprot = do
_ <- readStructBegin iprot
record <- read_Multiget_slice_args_fields iprot (Multiget_slice_args{f_Multiget_slice_args_keys=Nothing,f_Multiget_slice_args_column_parent=Nothing,f_Multiget_slice_args_predicate=Nothing,f_Multiget_slice_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Multiget_slice_result = Multiget_slice_result{f_Multiget_slice_result_success :: Maybe (Map.Map ByteString [ColumnOrSuperColumn]),f_Multiget_slice_result_ire :: Maybe InvalidRequestException,f_Multiget_slice_result_ue :: Maybe UnavailableException,f_Multiget_slice_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Multiget_slice_result oprot record = do
writeStructBegin oprot "Multiget_slice_result"
case f_Multiget_slice_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_MAP,0)
(let {f [] = return (); f ((_kiter250,_viter251):t) = do {do {writeBinary oprot _kiter250;(let {f [] = return (); f (_viter252:t) = do {write_ColumnOrSuperColumn oprot _viter252;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _viter251); f _viter251;writeListEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_LIST,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
writeFieldEnd oprot}
case f_Multiget_slice_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Multiget_slice_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Multiget_slice_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Multiget_slice_result_fields iprot record = do
(_,_t254,_id255) <- readFieldBegin iprot
if _t254 == T_STOP then return record else
case _id255 of
0 -> if _t254 == T_MAP then do
s <- (let {f 0 = return []; f n = do {k <- readBinary iprot; v <- (let {f 0 = return []; f n = do {v <- (read_ColumnOrSuperColumn iprot);r <- f (n1); return $ v:r}} in do {(_etype264,_size261) <- readListBegin iprot; f _size261});r <- f (n1); return $ (k,v):r}} in do {(_ktype257,_vtype258,_size256) <- readMapBegin iprot; l <- f _size256; return $ Map.fromList l})
read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_success=Just s}
else do
skip iprot _t254
read_Multiget_slice_result_fields iprot record
1 -> if _t254 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_ire=Just s}
else do
skip iprot _t254
read_Multiget_slice_result_fields iprot record
2 -> if _t254 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_ue=Just s}
else do
skip iprot _t254
read_Multiget_slice_result_fields iprot record
3 -> if _t254 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Multiget_slice_result_fields iprot record{f_Multiget_slice_result_te=Just s}
else do
skip iprot _t254
read_Multiget_slice_result_fields iprot record
_ -> do
skip iprot _t254
readFieldEnd iprot
read_Multiget_slice_result_fields iprot record
read_Multiget_slice_result iprot = do
_ <- readStructBegin iprot
record <- read_Multiget_slice_result_fields iprot (Multiget_slice_result{f_Multiget_slice_result_success=Nothing,f_Multiget_slice_result_ire=Nothing,f_Multiget_slice_result_ue=Nothing,f_Multiget_slice_result_te=Nothing})
readStructEnd iprot
return record
data Multiget_count_args = Multiget_count_args{f_Multiget_count_args_keys :: Maybe [ByteString],f_Multiget_count_args_column_parent :: Maybe ColumnParent,f_Multiget_count_args_predicate :: Maybe SlicePredicate,f_Multiget_count_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Multiget_count_args oprot record = do
writeStructBegin oprot "Multiget_count_args"
case f_Multiget_count_args_keys record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keys",T_LIST,1)
(let {f [] = return (); f (_viter268:t) = do {writeBinary oprot _viter268;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Multiget_count_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,2)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Multiget_count_args_predicate record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("predicate",T_STRUCT,3)
write_SlicePredicate oprot _v
writeFieldEnd oprot}
case f_Multiget_count_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Multiget_count_args_fields iprot record = do
(_,_t270,_id271) <- readFieldBegin iprot
if _t270 == T_STOP then return record else
case _id271 of
1 -> if _t270 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- readBinary iprot;r <- f (n1); return $ v:r}} in do {(_etype275,_size272) <- readListBegin iprot; f _size272})
read_Multiget_count_args_fields iprot record{f_Multiget_count_args_keys=Just s}
else do
skip iprot _t270
read_Multiget_count_args_fields iprot record
2 -> if _t270 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Multiget_count_args_fields iprot record{f_Multiget_count_args_column_parent=Just s}
else do
skip iprot _t270
read_Multiget_count_args_fields iprot record
3 -> if _t270 == T_STRUCT then do
s <- (read_SlicePredicate iprot)
read_Multiget_count_args_fields iprot record{f_Multiget_count_args_predicate=Just s}
else do
skip iprot _t270
read_Multiget_count_args_fields iprot record
4 -> if _t270 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Multiget_count_args_fields iprot record{f_Multiget_count_args_consistency_level=Just s}
else do
skip iprot _t270
read_Multiget_count_args_fields iprot record
_ -> do
skip iprot _t270
readFieldEnd iprot
read_Multiget_count_args_fields iprot record
read_Multiget_count_args iprot = do
_ <- readStructBegin iprot
record <- read_Multiget_count_args_fields iprot (Multiget_count_args{f_Multiget_count_args_keys=Nothing,f_Multiget_count_args_column_parent=Nothing,f_Multiget_count_args_predicate=Nothing,f_Multiget_count_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Multiget_count_result = Multiget_count_result{f_Multiget_count_result_success :: Maybe (Map.Map ByteString Int32),f_Multiget_count_result_ire :: Maybe InvalidRequestException,f_Multiget_count_result_ue :: Maybe UnavailableException,f_Multiget_count_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Multiget_count_result oprot record = do
writeStructBegin oprot "Multiget_count_result"
case f_Multiget_count_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_MAP,0)
(let {f [] = return (); f ((_kiter279,_viter280):t) = do {do {writeBinary oprot _kiter279;writeI32 oprot _viter280};f t}} in do {writeMapBegin oprot (T_STRING,T_I32,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
writeFieldEnd oprot}
case f_Multiget_count_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Multiget_count_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Multiget_count_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Multiget_count_result_fields iprot record = do
(_,_t282,_id283) <- readFieldBegin iprot
if _t282 == T_STOP then return record else
case _id283 of
0 -> if _t282 == T_MAP then do
s <- (let {f 0 = return []; f n = do {k <- readBinary iprot; v <- readI32 iprot;r <- f (n1); return $ (k,v):r}} in do {(_ktype285,_vtype286,_size284) <- readMapBegin iprot; l <- f _size284; return $ Map.fromList l})
read_Multiget_count_result_fields iprot record{f_Multiget_count_result_success=Just s}
else do
skip iprot _t282
read_Multiget_count_result_fields iprot record
1 -> if _t282 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Multiget_count_result_fields iprot record{f_Multiget_count_result_ire=Just s}
else do
skip iprot _t282
read_Multiget_count_result_fields iprot record
2 -> if _t282 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Multiget_count_result_fields iprot record{f_Multiget_count_result_ue=Just s}
else do
skip iprot _t282
read_Multiget_count_result_fields iprot record
3 -> if _t282 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Multiget_count_result_fields iprot record{f_Multiget_count_result_te=Just s}
else do
skip iprot _t282
read_Multiget_count_result_fields iprot record
_ -> do
skip iprot _t282
readFieldEnd iprot
read_Multiget_count_result_fields iprot record
read_Multiget_count_result iprot = do
_ <- readStructBegin iprot
record <- read_Multiget_count_result_fields iprot (Multiget_count_result{f_Multiget_count_result_success=Nothing,f_Multiget_count_result_ire=Nothing,f_Multiget_count_result_ue=Nothing,f_Multiget_count_result_te=Nothing})
readStructEnd iprot
return record
data Get_range_slices_args = Get_range_slices_args{f_Get_range_slices_args_column_parent :: Maybe ColumnParent,f_Get_range_slices_args_predicate :: Maybe SlicePredicate,f_Get_range_slices_args_range :: Maybe KeyRange,f_Get_range_slices_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_range_slices_args oprot record = do
writeStructBegin oprot "Get_range_slices_args"
case f_Get_range_slices_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,1)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Get_range_slices_args_predicate record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("predicate",T_STRUCT,2)
write_SlicePredicate oprot _v
writeFieldEnd oprot}
case f_Get_range_slices_args_range record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("range",T_STRUCT,3)
write_KeyRange oprot _v
writeFieldEnd oprot}
case f_Get_range_slices_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_range_slices_args_fields iprot record = do
(_,_t292,_id293) <- readFieldBegin iprot
if _t292 == T_STOP then return record else
case _id293 of
1 -> if _t292 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_column_parent=Just s}
else do
skip iprot _t292
read_Get_range_slices_args_fields iprot record
2 -> if _t292 == T_STRUCT then do
s <- (read_SlicePredicate iprot)
read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_predicate=Just s}
else do
skip iprot _t292
read_Get_range_slices_args_fields iprot record
3 -> if _t292 == T_STRUCT then do
s <- (read_KeyRange iprot)
read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_range=Just s}
else do
skip iprot _t292
read_Get_range_slices_args_fields iprot record
4 -> if _t292 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Get_range_slices_args_fields iprot record{f_Get_range_slices_args_consistency_level=Just s}
else do
skip iprot _t292
read_Get_range_slices_args_fields iprot record
_ -> do
skip iprot _t292
readFieldEnd iprot
read_Get_range_slices_args_fields iprot record
read_Get_range_slices_args iprot = do
_ <- readStructBegin iprot
record <- read_Get_range_slices_args_fields iprot (Get_range_slices_args{f_Get_range_slices_args_column_parent=Nothing,f_Get_range_slices_args_predicate=Nothing,f_Get_range_slices_args_range=Nothing,f_Get_range_slices_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Get_range_slices_result = Get_range_slices_result{f_Get_range_slices_result_success :: Maybe [KeySlice],f_Get_range_slices_result_ire :: Maybe InvalidRequestException,f_Get_range_slices_result_ue :: Maybe UnavailableException,f_Get_range_slices_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_range_slices_result oprot record = do
writeStructBegin oprot "Get_range_slices_result"
case f_Get_range_slices_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_LIST,0)
(let {f [] = return (); f (_viter296:t) = do {write_KeySlice oprot _viter296;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Get_range_slices_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Get_range_slices_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Get_range_slices_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_range_slices_result_fields iprot record = do
(_,_t298,_id299) <- readFieldBegin iprot
if _t298 == T_STOP then return record else
case _id299 of
0 -> if _t298 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- (read_KeySlice iprot);r <- f (n1); return $ v:r}} in do {(_etype303,_size300) <- readListBegin iprot; f _size300})
read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_success=Just s}
else do
skip iprot _t298
read_Get_range_slices_result_fields iprot record
1 -> if _t298 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_ire=Just s}
else do
skip iprot _t298
read_Get_range_slices_result_fields iprot record
2 -> if _t298 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_ue=Just s}
else do
skip iprot _t298
read_Get_range_slices_result_fields iprot record
3 -> if _t298 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Get_range_slices_result_fields iprot record{f_Get_range_slices_result_te=Just s}
else do
skip iprot _t298
read_Get_range_slices_result_fields iprot record
_ -> do
skip iprot _t298
readFieldEnd iprot
read_Get_range_slices_result_fields iprot record
read_Get_range_slices_result iprot = do
_ <- readStructBegin iprot
record <- read_Get_range_slices_result_fields iprot (Get_range_slices_result{f_Get_range_slices_result_success=Nothing,f_Get_range_slices_result_ire=Nothing,f_Get_range_slices_result_ue=Nothing,f_Get_range_slices_result_te=Nothing})
readStructEnd iprot
return record
data Get_indexed_slices_args = Get_indexed_slices_args{f_Get_indexed_slices_args_column_parent :: Maybe ColumnParent,f_Get_indexed_slices_args_index_clause :: Maybe IndexClause,f_Get_indexed_slices_args_column_predicate :: Maybe SlicePredicate,f_Get_indexed_slices_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Get_indexed_slices_args oprot record = do
writeStructBegin oprot "Get_indexed_slices_args"
case f_Get_indexed_slices_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,1)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Get_indexed_slices_args_index_clause record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("index_clause",T_STRUCT,2)
write_IndexClause oprot _v
writeFieldEnd oprot}
case f_Get_indexed_slices_args_column_predicate record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_predicate",T_STRUCT,3)
write_SlicePredicate oprot _v
writeFieldEnd oprot}
case f_Get_indexed_slices_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_indexed_slices_args_fields iprot record = do
(_,_t308,_id309) <- readFieldBegin iprot
if _t308 == T_STOP then return record else
case _id309 of
1 -> if _t308 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_column_parent=Just s}
else do
skip iprot _t308
read_Get_indexed_slices_args_fields iprot record
2 -> if _t308 == T_STRUCT then do
s <- (read_IndexClause iprot)
read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_index_clause=Just s}
else do
skip iprot _t308
read_Get_indexed_slices_args_fields iprot record
3 -> if _t308 == T_STRUCT then do
s <- (read_SlicePredicate iprot)
read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_column_predicate=Just s}
else do
skip iprot _t308
read_Get_indexed_slices_args_fields iprot record
4 -> if _t308 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Get_indexed_slices_args_fields iprot record{f_Get_indexed_slices_args_consistency_level=Just s}
else do
skip iprot _t308
read_Get_indexed_slices_args_fields iprot record
_ -> do
skip iprot _t308
readFieldEnd iprot
read_Get_indexed_slices_args_fields iprot record
read_Get_indexed_slices_args iprot = do
_ <- readStructBegin iprot
record <- read_Get_indexed_slices_args_fields iprot (Get_indexed_slices_args{f_Get_indexed_slices_args_column_parent=Nothing,f_Get_indexed_slices_args_index_clause=Nothing,f_Get_indexed_slices_args_column_predicate=Nothing,f_Get_indexed_slices_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Get_indexed_slices_result = Get_indexed_slices_result{f_Get_indexed_slices_result_success :: Maybe [KeySlice],f_Get_indexed_slices_result_ire :: Maybe InvalidRequestException,f_Get_indexed_slices_result_ue :: Maybe UnavailableException,f_Get_indexed_slices_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Get_indexed_slices_result oprot record = do
writeStructBegin oprot "Get_indexed_slices_result"
case f_Get_indexed_slices_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_LIST,0)
(let {f [] = return (); f (_viter312:t) = do {write_KeySlice oprot _viter312;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Get_indexed_slices_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Get_indexed_slices_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Get_indexed_slices_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Get_indexed_slices_result_fields iprot record = do
(_,_t314,_id315) <- readFieldBegin iprot
if _t314 == T_STOP then return record else
case _id315 of
0 -> if _t314 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- (read_KeySlice iprot);r <- f (n1); return $ v:r}} in do {(_etype319,_size316) <- readListBegin iprot; f _size316})
read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_success=Just s}
else do
skip iprot _t314
read_Get_indexed_slices_result_fields iprot record
1 -> if _t314 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_ire=Just s}
else do
skip iprot _t314
read_Get_indexed_slices_result_fields iprot record
2 -> if _t314 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_ue=Just s}
else do
skip iprot _t314
read_Get_indexed_slices_result_fields iprot record
3 -> if _t314 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Get_indexed_slices_result_fields iprot record{f_Get_indexed_slices_result_te=Just s}
else do
skip iprot _t314
read_Get_indexed_slices_result_fields iprot record
_ -> do
skip iprot _t314
readFieldEnd iprot
read_Get_indexed_slices_result_fields iprot record
read_Get_indexed_slices_result iprot = do
_ <- readStructBegin iprot
record <- read_Get_indexed_slices_result_fields iprot (Get_indexed_slices_result{f_Get_indexed_slices_result_success=Nothing,f_Get_indexed_slices_result_ire=Nothing,f_Get_indexed_slices_result_ue=Nothing,f_Get_indexed_slices_result_te=Nothing})
readStructEnd iprot
return record
data Insert_args = Insert_args{f_Insert_args_key :: Maybe ByteString,f_Insert_args_column_parent :: Maybe ColumnParent,f_Insert_args_column :: Maybe Column,f_Insert_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Insert_args oprot record = do
writeStructBegin oprot "Insert_args"
case f_Insert_args_key record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("key",T_STRING,1)
writeBinary oprot _v
writeFieldEnd oprot}
case f_Insert_args_column_parent record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_parent",T_STRUCT,2)
write_ColumnParent oprot _v
writeFieldEnd oprot}
case f_Insert_args_column record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column",T_STRUCT,3)
write_Column oprot _v
writeFieldEnd oprot}
case f_Insert_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Insert_args_fields iprot record = do
(_,_t324,_id325) <- readFieldBegin iprot
if _t324 == T_STOP then return record else
case _id325 of
1 -> if _t324 == T_STRING then do
s <- readBinary iprot
read_Insert_args_fields iprot record{f_Insert_args_key=Just s}
else do
skip iprot _t324
read_Insert_args_fields iprot record
2 -> if _t324 == T_STRUCT then do
s <- (read_ColumnParent iprot)
read_Insert_args_fields iprot record{f_Insert_args_column_parent=Just s}
else do
skip iprot _t324
read_Insert_args_fields iprot record
3 -> if _t324 == T_STRUCT then do
s <- (read_Column iprot)
read_Insert_args_fields iprot record{f_Insert_args_column=Just s}
else do
skip iprot _t324
read_Insert_args_fields iprot record
4 -> if _t324 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Insert_args_fields iprot record{f_Insert_args_consistency_level=Just s}
else do
skip iprot _t324
read_Insert_args_fields iprot record
_ -> do
skip iprot _t324
readFieldEnd iprot
read_Insert_args_fields iprot record
read_Insert_args iprot = do
_ <- readStructBegin iprot
record <- read_Insert_args_fields iprot (Insert_args{f_Insert_args_key=Nothing,f_Insert_args_column_parent=Nothing,f_Insert_args_column=Nothing,f_Insert_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Insert_result = Insert_result{f_Insert_result_ire :: Maybe InvalidRequestException,f_Insert_result_ue :: Maybe UnavailableException,f_Insert_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Insert_result oprot record = do
writeStructBegin oprot "Insert_result"
case f_Insert_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Insert_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Insert_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Insert_result_fields iprot record = do
(_,_t329,_id330) <- readFieldBegin iprot
if _t329 == T_STOP then return record else
case _id330 of
1 -> if _t329 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Insert_result_fields iprot record{f_Insert_result_ire=Just s}
else do
skip iprot _t329
read_Insert_result_fields iprot record
2 -> if _t329 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Insert_result_fields iprot record{f_Insert_result_ue=Just s}
else do
skip iprot _t329
read_Insert_result_fields iprot record
3 -> if _t329 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Insert_result_fields iprot record{f_Insert_result_te=Just s}
else do
skip iprot _t329
read_Insert_result_fields iprot record
_ -> do
skip iprot _t329
readFieldEnd iprot
read_Insert_result_fields iprot record
read_Insert_result iprot = do
_ <- readStructBegin iprot
record <- read_Insert_result_fields iprot (Insert_result{f_Insert_result_ire=Nothing,f_Insert_result_ue=Nothing,f_Insert_result_te=Nothing})
readStructEnd iprot
return record
data Remove_args = Remove_args{f_Remove_args_key :: Maybe ByteString,f_Remove_args_column_path :: Maybe ColumnPath,f_Remove_args_timestamp :: Maybe Int64,f_Remove_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Remove_args oprot record = do
writeStructBegin oprot "Remove_args"
case f_Remove_args_key record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("key",T_STRING,1)
writeBinary oprot _v
writeFieldEnd oprot}
case f_Remove_args_column_path record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_path",T_STRUCT,2)
write_ColumnPath oprot _v
writeFieldEnd oprot}
case f_Remove_args_timestamp record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("timestamp",T_I64,3)
writeI64 oprot _v
writeFieldEnd oprot}
case f_Remove_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,4)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Remove_args_fields iprot record = do
(_,_t334,_id335) <- readFieldBegin iprot
if _t334 == T_STOP then return record else
case _id335 of
1 -> if _t334 == T_STRING then do
s <- readBinary iprot
read_Remove_args_fields iprot record{f_Remove_args_key=Just s}
else do
skip iprot _t334
read_Remove_args_fields iprot record
2 -> if _t334 == T_STRUCT then do
s <- (read_ColumnPath iprot)
read_Remove_args_fields iprot record{f_Remove_args_column_path=Just s}
else do
skip iprot _t334
read_Remove_args_fields iprot record
3 -> if _t334 == T_I64 then do
s <- readI64 iprot
read_Remove_args_fields iprot record{f_Remove_args_timestamp=Just s}
else do
skip iprot _t334
read_Remove_args_fields iprot record
4 -> if _t334 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Remove_args_fields iprot record{f_Remove_args_consistency_level=Just s}
else do
skip iprot _t334
read_Remove_args_fields iprot record
_ -> do
skip iprot _t334
readFieldEnd iprot
read_Remove_args_fields iprot record
read_Remove_args iprot = do
_ <- readStructBegin iprot
record <- read_Remove_args_fields iprot (Remove_args{f_Remove_args_key=Nothing,f_Remove_args_column_path=Nothing,f_Remove_args_timestamp=Nothing,f_Remove_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Remove_result = Remove_result{f_Remove_result_ire :: Maybe InvalidRequestException,f_Remove_result_ue :: Maybe UnavailableException,f_Remove_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Remove_result oprot record = do
writeStructBegin oprot "Remove_result"
case f_Remove_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Remove_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Remove_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Remove_result_fields iprot record = do
(_,_t339,_id340) <- readFieldBegin iprot
if _t339 == T_STOP then return record else
case _id340 of
1 -> if _t339 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Remove_result_fields iprot record{f_Remove_result_ire=Just s}
else do
skip iprot _t339
read_Remove_result_fields iprot record
2 -> if _t339 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Remove_result_fields iprot record{f_Remove_result_ue=Just s}
else do
skip iprot _t339
read_Remove_result_fields iprot record
3 -> if _t339 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Remove_result_fields iprot record{f_Remove_result_te=Just s}
else do
skip iprot _t339
read_Remove_result_fields iprot record
_ -> do
skip iprot _t339
readFieldEnd iprot
read_Remove_result_fields iprot record
read_Remove_result iprot = do
_ <- readStructBegin iprot
record <- read_Remove_result_fields iprot (Remove_result{f_Remove_result_ire=Nothing,f_Remove_result_ue=Nothing,f_Remove_result_te=Nothing})
readStructEnd iprot
return record
data Batch_mutate_args = Batch_mutate_args{f_Batch_mutate_args_mutation_map :: Maybe (Map.Map ByteString (Map.Map String [Mutation])),f_Batch_mutate_args_consistency_level :: Maybe ConsistencyLevel} deriving (Show,Eq,Ord,Typeable)
write_Batch_mutate_args oprot record = do
writeStructBegin oprot "Batch_mutate_args"
case f_Batch_mutate_args_mutation_map record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("mutation_map",T_MAP,1)
(let {f [] = return (); f ((_kiter343,_viter344):t) = do {do {writeBinary oprot _kiter343;(let {f [] = return (); f ((_kiter345,_viter346):t) = do {do {writeString oprot _kiter345;(let {f [] = return (); f (_viter347:t) = do {write_Mutation oprot _viter347;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _viter346); f _viter346;writeListEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_LIST,fromIntegral $ Map.size _viter344); f (Map.toList _viter344);writeMapEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_MAP,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
writeFieldEnd oprot}
case f_Batch_mutate_args_consistency_level record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("consistency_level",T_I32,2)
writeI32 oprot (fromIntegral $ fromEnum _v)
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Batch_mutate_args_fields iprot record = do
(_,_t349,_id350) <- readFieldBegin iprot
if _t349 == T_STOP then return record else
case _id350 of
1 -> if _t349 == T_MAP then do
s <- (let {f 0 = return []; f n = do {k <- readBinary iprot; v <- (let {f 0 = return []; f n = do {k <- readString iprot; v <- (let {f 0 = return []; f n = do {v <- (read_Mutation iprot);r <- f (n1); return $ v:r}} in do {(_etype364,_size361) <- readListBegin iprot; f _size361});r <- f (n1); return $ (k,v):r}} in do {(_ktype357,_vtype358,_size356) <- readMapBegin iprot; l <- f _size356; return $ Map.fromList l});r <- f (n1); return $ (k,v):r}} in do {(_ktype352,_vtype353,_size351) <- readMapBegin iprot; l <- f _size351; return $ Map.fromList l})
read_Batch_mutate_args_fields iprot record{f_Batch_mutate_args_mutation_map=Just s}
else do
skip iprot _t349
read_Batch_mutate_args_fields iprot record
2 -> if _t349 == T_I32 then do
s <- (do {i <- readI32 iprot; return $ toEnum $ fromIntegral i})
read_Batch_mutate_args_fields iprot record{f_Batch_mutate_args_consistency_level=Just s}
else do
skip iprot _t349
read_Batch_mutate_args_fields iprot record
_ -> do
skip iprot _t349
readFieldEnd iprot
read_Batch_mutate_args_fields iprot record
read_Batch_mutate_args iprot = do
_ <- readStructBegin iprot
record <- read_Batch_mutate_args_fields iprot (Batch_mutate_args{f_Batch_mutate_args_mutation_map=Nothing,f_Batch_mutate_args_consistency_level=Nothing})
readStructEnd iprot
return record
data Batch_mutate_result = Batch_mutate_result{f_Batch_mutate_result_ire :: Maybe InvalidRequestException,f_Batch_mutate_result_ue :: Maybe UnavailableException,f_Batch_mutate_result_te :: Maybe TimedOutException} deriving (Show,Eq,Ord,Typeable)
write_Batch_mutate_result oprot record = do
writeStructBegin oprot "Batch_mutate_result"
case f_Batch_mutate_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Batch_mutate_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
case f_Batch_mutate_result_te record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("te",T_STRUCT,3)
write_TimedOutException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Batch_mutate_result_fields iprot record = do
(_,_t369,_id370) <- readFieldBegin iprot
if _t369 == T_STOP then return record else
case _id370 of
1 -> if _t369 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Batch_mutate_result_fields iprot record{f_Batch_mutate_result_ire=Just s}
else do
skip iprot _t369
read_Batch_mutate_result_fields iprot record
2 -> if _t369 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Batch_mutate_result_fields iprot record{f_Batch_mutate_result_ue=Just s}
else do
skip iprot _t369
read_Batch_mutate_result_fields iprot record
3 -> if _t369 == T_STRUCT then do
s <- (read_TimedOutException iprot)
read_Batch_mutate_result_fields iprot record{f_Batch_mutate_result_te=Just s}
else do
skip iprot _t369
read_Batch_mutate_result_fields iprot record
_ -> do
skip iprot _t369
readFieldEnd iprot
read_Batch_mutate_result_fields iprot record
read_Batch_mutate_result iprot = do
_ <- readStructBegin iprot
record <- read_Batch_mutate_result_fields iprot (Batch_mutate_result{f_Batch_mutate_result_ire=Nothing,f_Batch_mutate_result_ue=Nothing,f_Batch_mutate_result_te=Nothing})
readStructEnd iprot
return record
data Truncate_args = Truncate_args{f_Truncate_args_cfname :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Truncate_args oprot record = do
writeStructBegin oprot "Truncate_args"
case f_Truncate_args_cfname record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("cfname",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Truncate_args_fields iprot record = do
(_,_t374,_id375) <- readFieldBegin iprot
if _t374 == T_STOP then return record else
case _id375 of
1 -> if _t374 == T_STRING then do
s <- readString iprot
read_Truncate_args_fields iprot record{f_Truncate_args_cfname=Just s}
else do
skip iprot _t374
read_Truncate_args_fields iprot record
_ -> do
skip iprot _t374
readFieldEnd iprot
read_Truncate_args_fields iprot record
read_Truncate_args iprot = do
_ <- readStructBegin iprot
record <- read_Truncate_args_fields iprot (Truncate_args{f_Truncate_args_cfname=Nothing})
readStructEnd iprot
return record
data Truncate_result = Truncate_result{f_Truncate_result_ire :: Maybe InvalidRequestException,f_Truncate_result_ue :: Maybe UnavailableException} deriving (Show,Eq,Ord,Typeable)
write_Truncate_result oprot record = do
writeStructBegin oprot "Truncate_result"
case f_Truncate_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
case f_Truncate_result_ue record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ue",T_STRUCT,2)
write_UnavailableException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Truncate_result_fields iprot record = do
(_,_t379,_id380) <- readFieldBegin iprot
if _t379 == T_STOP then return record else
case _id380 of
1 -> if _t379 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Truncate_result_fields iprot record{f_Truncate_result_ire=Just s}
else do
skip iprot _t379
read_Truncate_result_fields iprot record
2 -> if _t379 == T_STRUCT then do
s <- (read_UnavailableException iprot)
read_Truncate_result_fields iprot record{f_Truncate_result_ue=Just s}
else do
skip iprot _t379
read_Truncate_result_fields iprot record
_ -> do
skip iprot _t379
readFieldEnd iprot
read_Truncate_result_fields iprot record
read_Truncate_result iprot = do
_ <- readStructBegin iprot
record <- read_Truncate_result_fields iprot (Truncate_result{f_Truncate_result_ire=Nothing,f_Truncate_result_ue=Nothing})
readStructEnd iprot
return record
data Describe_schema_versions_args = Describe_schema_versions_args deriving (Show,Eq,Ord,Typeable)
write_Describe_schema_versions_args oprot record = do
writeStructBegin oprot "Describe_schema_versions_args"
writeFieldStop oprot
writeStructEnd oprot
read_Describe_schema_versions_args_fields iprot record = do
(_,_t384,_id385) <- readFieldBegin iprot
if _t384 == T_STOP then return record else
case _id385 of
_ -> do
skip iprot _t384
readFieldEnd iprot
read_Describe_schema_versions_args_fields iprot record
read_Describe_schema_versions_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_schema_versions_args_fields iprot (Describe_schema_versions_args{})
readStructEnd iprot
return record
data Describe_schema_versions_result = Describe_schema_versions_result{f_Describe_schema_versions_result_success :: Maybe (Map.Map String [String]),f_Describe_schema_versions_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_schema_versions_result oprot record = do
writeStructBegin oprot "Describe_schema_versions_result"
case f_Describe_schema_versions_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_MAP,0)
(let {f [] = return (); f ((_kiter388,_viter389):t) = do {do {writeString oprot _kiter388;(let {f [] = return (); f (_viter390:t) = do {writeString oprot _viter390;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _viter389); f _viter389;writeListEnd oprot})};f t}} in do {writeMapBegin oprot (T_STRING,T_LIST,fromIntegral $ Map.size _v); f (Map.toList _v);writeMapEnd oprot})
writeFieldEnd oprot}
case f_Describe_schema_versions_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_schema_versions_result_fields iprot record = do
(_,_t392,_id393) <- readFieldBegin iprot
if _t392 == T_STOP then return record else
case _id393 of
0 -> if _t392 == T_MAP then do
s <- (let {f 0 = return []; f n = do {k <- readString iprot; v <- (let {f 0 = return []; f n = do {v <- readString iprot;r <- f (n1); return $ v:r}} in do {(_etype402,_size399) <- readListBegin iprot; f _size399});r <- f (n1); return $ (k,v):r}} in do {(_ktype395,_vtype396,_size394) <- readMapBegin iprot; l <- f _size394; return $ Map.fromList l})
read_Describe_schema_versions_result_fields iprot record{f_Describe_schema_versions_result_success=Just s}
else do
skip iprot _t392
read_Describe_schema_versions_result_fields iprot record
1 -> if _t392 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Describe_schema_versions_result_fields iprot record{f_Describe_schema_versions_result_ire=Just s}
else do
skip iprot _t392
read_Describe_schema_versions_result_fields iprot record
_ -> do
skip iprot _t392
readFieldEnd iprot
read_Describe_schema_versions_result_fields iprot record
read_Describe_schema_versions_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_schema_versions_result_fields iprot (Describe_schema_versions_result{f_Describe_schema_versions_result_success=Nothing,f_Describe_schema_versions_result_ire=Nothing})
readStructEnd iprot
return record
data Describe_keyspaces_args = Describe_keyspaces_args deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspaces_args oprot record = do
writeStructBegin oprot "Describe_keyspaces_args"
writeFieldStop oprot
writeStructEnd oprot
read_Describe_keyspaces_args_fields iprot record = do
(_,_t407,_id408) <- readFieldBegin iprot
if _t407 == T_STOP then return record else
case _id408 of
_ -> do
skip iprot _t407
readFieldEnd iprot
read_Describe_keyspaces_args_fields iprot record
read_Describe_keyspaces_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_keyspaces_args_fields iprot (Describe_keyspaces_args{})
readStructEnd iprot
return record
data Describe_keyspaces_result = Describe_keyspaces_result{f_Describe_keyspaces_result_success :: Maybe [KsDef],f_Describe_keyspaces_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspaces_result oprot record = do
writeStructBegin oprot "Describe_keyspaces_result"
case f_Describe_keyspaces_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_LIST,0)
(let {f [] = return (); f (_viter411:t) = do {write_KsDef oprot _viter411;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Describe_keyspaces_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_keyspaces_result_fields iprot record = do
(_,_t413,_id414) <- readFieldBegin iprot
if _t413 == T_STOP then return record else
case _id414 of
0 -> if _t413 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- (read_KsDef iprot);r <- f (n1); return $ v:r}} in do {(_etype418,_size415) <- readListBegin iprot; f _size415})
read_Describe_keyspaces_result_fields iprot record{f_Describe_keyspaces_result_success=Just s}
else do
skip iprot _t413
read_Describe_keyspaces_result_fields iprot record
1 -> if _t413 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Describe_keyspaces_result_fields iprot record{f_Describe_keyspaces_result_ire=Just s}
else do
skip iprot _t413
read_Describe_keyspaces_result_fields iprot record
_ -> do
skip iprot _t413
readFieldEnd iprot
read_Describe_keyspaces_result_fields iprot record
read_Describe_keyspaces_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_keyspaces_result_fields iprot (Describe_keyspaces_result{f_Describe_keyspaces_result_success=Nothing,f_Describe_keyspaces_result_ire=Nothing})
readStructEnd iprot
return record
data Describe_cluster_name_args = Describe_cluster_name_args deriving (Show,Eq,Ord,Typeable)
write_Describe_cluster_name_args oprot record = do
writeStructBegin oprot "Describe_cluster_name_args"
writeFieldStop oprot
writeStructEnd oprot
read_Describe_cluster_name_args_fields iprot record = do
(_,_t423,_id424) <- readFieldBegin iprot
if _t423 == T_STOP then return record else
case _id424 of
_ -> do
skip iprot _t423
readFieldEnd iprot
read_Describe_cluster_name_args_fields iprot record
read_Describe_cluster_name_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_cluster_name_args_fields iprot (Describe_cluster_name_args{})
readStructEnd iprot
return record
data Describe_cluster_name_result = Describe_cluster_name_result{f_Describe_cluster_name_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_cluster_name_result oprot record = do
writeStructBegin oprot "Describe_cluster_name_result"
case f_Describe_cluster_name_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_cluster_name_result_fields iprot record = do
(_,_t428,_id429) <- readFieldBegin iprot
if _t428 == T_STOP then return record else
case _id429 of
0 -> if _t428 == T_STRING then do
s <- readString iprot
read_Describe_cluster_name_result_fields iprot record{f_Describe_cluster_name_result_success=Just s}
else do
skip iprot _t428
read_Describe_cluster_name_result_fields iprot record
_ -> do
skip iprot _t428
readFieldEnd iprot
read_Describe_cluster_name_result_fields iprot record
read_Describe_cluster_name_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_cluster_name_result_fields iprot (Describe_cluster_name_result{f_Describe_cluster_name_result_success=Nothing})
readStructEnd iprot
return record
data Describe_version_args = Describe_version_args deriving (Show,Eq,Ord,Typeable)
write_Describe_version_args oprot record = do
writeStructBegin oprot "Describe_version_args"
writeFieldStop oprot
writeStructEnd oprot
read_Describe_version_args_fields iprot record = do
(_,_t433,_id434) <- readFieldBegin iprot
if _t433 == T_STOP then return record else
case _id434 of
_ -> do
skip iprot _t433
readFieldEnd iprot
read_Describe_version_args_fields iprot record
read_Describe_version_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_version_args_fields iprot (Describe_version_args{})
readStructEnd iprot
return record
data Describe_version_result = Describe_version_result{f_Describe_version_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_version_result oprot record = do
writeStructBegin oprot "Describe_version_result"
case f_Describe_version_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_version_result_fields iprot record = do
(_,_t438,_id439) <- readFieldBegin iprot
if _t438 == T_STOP then return record else
case _id439 of
0 -> if _t438 == T_STRING then do
s <- readString iprot
read_Describe_version_result_fields iprot record{f_Describe_version_result_success=Just s}
else do
skip iprot _t438
read_Describe_version_result_fields iprot record
_ -> do
skip iprot _t438
readFieldEnd iprot
read_Describe_version_result_fields iprot record
read_Describe_version_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_version_result_fields iprot (Describe_version_result{f_Describe_version_result_success=Nothing})
readStructEnd iprot
return record
data Describe_ring_args = Describe_ring_args{f_Describe_ring_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_ring_args oprot record = do
writeStructBegin oprot "Describe_ring_args"
case f_Describe_ring_args_keyspace record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keyspace",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_ring_args_fields iprot record = do
(_,_t443,_id444) <- readFieldBegin iprot
if _t443 == T_STOP then return record else
case _id444 of
1 -> if _t443 == T_STRING then do
s <- readString iprot
read_Describe_ring_args_fields iprot record{f_Describe_ring_args_keyspace=Just s}
else do
skip iprot _t443
read_Describe_ring_args_fields iprot record
_ -> do
skip iprot _t443
readFieldEnd iprot
read_Describe_ring_args_fields iprot record
read_Describe_ring_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_ring_args_fields iprot (Describe_ring_args{f_Describe_ring_args_keyspace=Nothing})
readStructEnd iprot
return record
data Describe_ring_result = Describe_ring_result{f_Describe_ring_result_success :: Maybe [TokenRange],f_Describe_ring_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_ring_result oprot record = do
writeStructBegin oprot "Describe_ring_result"
case f_Describe_ring_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_LIST,0)
(let {f [] = return (); f (_viter447:t) = do {write_TokenRange oprot _viter447;f t}} in do {writeListBegin oprot (T_STRUCT,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
case f_Describe_ring_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_ring_result_fields iprot record = do
(_,_t449,_id450) <- readFieldBegin iprot
if _t449 == T_STOP then return record else
case _id450 of
0 -> if _t449 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- (read_TokenRange iprot);r <- f (n1); return $ v:r}} in do {(_etype454,_size451) <- readListBegin iprot; f _size451})
read_Describe_ring_result_fields iprot record{f_Describe_ring_result_success=Just s}
else do
skip iprot _t449
read_Describe_ring_result_fields iprot record
1 -> if _t449 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Describe_ring_result_fields iprot record{f_Describe_ring_result_ire=Just s}
else do
skip iprot _t449
read_Describe_ring_result_fields iprot record
_ -> do
skip iprot _t449
readFieldEnd iprot
read_Describe_ring_result_fields iprot record
read_Describe_ring_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_ring_result_fields iprot (Describe_ring_result{f_Describe_ring_result_success=Nothing,f_Describe_ring_result_ire=Nothing})
readStructEnd iprot
return record
data Describe_partitioner_args = Describe_partitioner_args deriving (Show,Eq,Ord,Typeable)
write_Describe_partitioner_args oprot record = do
writeStructBegin oprot "Describe_partitioner_args"
writeFieldStop oprot
writeStructEnd oprot
read_Describe_partitioner_args_fields iprot record = do
(_,_t459,_id460) <- readFieldBegin iprot
if _t459 == T_STOP then return record else
case _id460 of
_ -> do
skip iprot _t459
readFieldEnd iprot
read_Describe_partitioner_args_fields iprot record
read_Describe_partitioner_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_partitioner_args_fields iprot (Describe_partitioner_args{})
readStructEnd iprot
return record
data Describe_partitioner_result = Describe_partitioner_result{f_Describe_partitioner_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_partitioner_result oprot record = do
writeStructBegin oprot "Describe_partitioner_result"
case f_Describe_partitioner_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_partitioner_result_fields iprot record = do
(_,_t464,_id465) <- readFieldBegin iprot
if _t464 == T_STOP then return record else
case _id465 of
0 -> if _t464 == T_STRING then do
s <- readString iprot
read_Describe_partitioner_result_fields iprot record{f_Describe_partitioner_result_success=Just s}
else do
skip iprot _t464
read_Describe_partitioner_result_fields iprot record
_ -> do
skip iprot _t464
readFieldEnd iprot
read_Describe_partitioner_result_fields iprot record
read_Describe_partitioner_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_partitioner_result_fields iprot (Describe_partitioner_result{f_Describe_partitioner_result_success=Nothing})
readStructEnd iprot
return record
data Describe_snitch_args = Describe_snitch_args deriving (Show,Eq,Ord,Typeable)
write_Describe_snitch_args oprot record = do
writeStructBegin oprot "Describe_snitch_args"
writeFieldStop oprot
writeStructEnd oprot
read_Describe_snitch_args_fields iprot record = do
(_,_t469,_id470) <- readFieldBegin iprot
if _t469 == T_STOP then return record else
case _id470 of
_ -> do
skip iprot _t469
readFieldEnd iprot
read_Describe_snitch_args_fields iprot record
read_Describe_snitch_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_snitch_args_fields iprot (Describe_snitch_args{})
readStructEnd iprot
return record
data Describe_snitch_result = Describe_snitch_result{f_Describe_snitch_result_success :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_snitch_result oprot record = do
writeStructBegin oprot "Describe_snitch_result"
case f_Describe_snitch_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_snitch_result_fields iprot record = do
(_,_t474,_id475) <- readFieldBegin iprot
if _t474 == T_STOP then return record else
case _id475 of
0 -> if _t474 == T_STRING then do
s <- readString iprot
read_Describe_snitch_result_fields iprot record{f_Describe_snitch_result_success=Just s}
else do
skip iprot _t474
read_Describe_snitch_result_fields iprot record
_ -> do
skip iprot _t474
readFieldEnd iprot
read_Describe_snitch_result_fields iprot record
read_Describe_snitch_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_snitch_result_fields iprot (Describe_snitch_result{f_Describe_snitch_result_success=Nothing})
readStructEnd iprot
return record
data Describe_keyspace_args = Describe_keyspace_args{f_Describe_keyspace_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspace_args oprot record = do
writeStructBegin oprot "Describe_keyspace_args"
case f_Describe_keyspace_args_keyspace record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keyspace",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_keyspace_args_fields iprot record = do
(_,_t479,_id480) <- readFieldBegin iprot
if _t479 == T_STOP then return record else
case _id480 of
1 -> if _t479 == T_STRING then do
s <- readString iprot
read_Describe_keyspace_args_fields iprot record{f_Describe_keyspace_args_keyspace=Just s}
else do
skip iprot _t479
read_Describe_keyspace_args_fields iprot record
_ -> do
skip iprot _t479
readFieldEnd iprot
read_Describe_keyspace_args_fields iprot record
read_Describe_keyspace_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_keyspace_args_fields iprot (Describe_keyspace_args{f_Describe_keyspace_args_keyspace=Nothing})
readStructEnd iprot
return record
data Describe_keyspace_result = Describe_keyspace_result{f_Describe_keyspace_result_success :: Maybe KsDef,f_Describe_keyspace_result_nfe :: Maybe NotFoundException,f_Describe_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_Describe_keyspace_result oprot record = do
writeStructBegin oprot "Describe_keyspace_result"
case f_Describe_keyspace_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRUCT,0)
write_KsDef oprot _v
writeFieldEnd oprot}
case f_Describe_keyspace_result_nfe record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("nfe",T_STRUCT,1)
write_NotFoundException oprot _v
writeFieldEnd oprot}
case f_Describe_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,2)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_keyspace_result_fields iprot record = do
(_,_t484,_id485) <- readFieldBegin iprot
if _t484 == T_STOP then return record else
case _id485 of
0 -> if _t484 == T_STRUCT then do
s <- (read_KsDef iprot)
read_Describe_keyspace_result_fields iprot record{f_Describe_keyspace_result_success=Just s}
else do
skip iprot _t484
read_Describe_keyspace_result_fields iprot record
1 -> if _t484 == T_STRUCT then do
s <- (read_NotFoundException iprot)
read_Describe_keyspace_result_fields iprot record{f_Describe_keyspace_result_nfe=Just s}
else do
skip iprot _t484
read_Describe_keyspace_result_fields iprot record
2 -> if _t484 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_Describe_keyspace_result_fields iprot record{f_Describe_keyspace_result_ire=Just s}
else do
skip iprot _t484
read_Describe_keyspace_result_fields iprot record
_ -> do
skip iprot _t484
readFieldEnd iprot
read_Describe_keyspace_result_fields iprot record
read_Describe_keyspace_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_keyspace_result_fields iprot (Describe_keyspace_result{f_Describe_keyspace_result_success=Nothing,f_Describe_keyspace_result_nfe=Nothing,f_Describe_keyspace_result_ire=Nothing})
readStructEnd iprot
return record
data Describe_splits_args = Describe_splits_args{f_Describe_splits_args_cfName :: Maybe String,f_Describe_splits_args_start_token :: Maybe String,f_Describe_splits_args_end_token :: Maybe String,f_Describe_splits_args_keys_per_split :: Maybe Int32} deriving (Show,Eq,Ord,Typeable)
write_Describe_splits_args oprot record = do
writeStructBegin oprot "Describe_splits_args"
case f_Describe_splits_args_cfName record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("cfName",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
case f_Describe_splits_args_start_token record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("start_token",T_STRING,2)
writeString oprot _v
writeFieldEnd oprot}
case f_Describe_splits_args_end_token record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("end_token",T_STRING,3)
writeString oprot _v
writeFieldEnd oprot}
case f_Describe_splits_args_keys_per_split record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keys_per_split",T_I32,4)
writeI32 oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_splits_args_fields iprot record = do
(_,_t489,_id490) <- readFieldBegin iprot
if _t489 == T_STOP then return record else
case _id490 of
1 -> if _t489 == T_STRING then do
s <- readString iprot
read_Describe_splits_args_fields iprot record{f_Describe_splits_args_cfName=Just s}
else do
skip iprot _t489
read_Describe_splits_args_fields iprot record
2 -> if _t489 == T_STRING then do
s <- readString iprot
read_Describe_splits_args_fields iprot record{f_Describe_splits_args_start_token=Just s}
else do
skip iprot _t489
read_Describe_splits_args_fields iprot record
3 -> if _t489 == T_STRING then do
s <- readString iprot
read_Describe_splits_args_fields iprot record{f_Describe_splits_args_end_token=Just s}
else do
skip iprot _t489
read_Describe_splits_args_fields iprot record
4 -> if _t489 == T_I32 then do
s <- readI32 iprot
read_Describe_splits_args_fields iprot record{f_Describe_splits_args_keys_per_split=Just s}
else do
skip iprot _t489
read_Describe_splits_args_fields iprot record
_ -> do
skip iprot _t489
readFieldEnd iprot
read_Describe_splits_args_fields iprot record
read_Describe_splits_args iprot = do
_ <- readStructBegin iprot
record <- read_Describe_splits_args_fields iprot (Describe_splits_args{f_Describe_splits_args_cfName=Nothing,f_Describe_splits_args_start_token=Nothing,f_Describe_splits_args_end_token=Nothing,f_Describe_splits_args_keys_per_split=Nothing})
readStructEnd iprot
return record
data Describe_splits_result = Describe_splits_result{f_Describe_splits_result_success :: Maybe [String]} deriving (Show,Eq,Ord,Typeable)
write_Describe_splits_result oprot record = do
writeStructBegin oprot "Describe_splits_result"
case f_Describe_splits_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_LIST,0)
(let {f [] = return (); f (_viter493:t) = do {writeString oprot _viter493;f t}} in do {writeListBegin oprot (T_STRING,fromIntegral $ Prelude.length _v); f _v;writeListEnd oprot})
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_Describe_splits_result_fields iprot record = do
(_,_t495,_id496) <- readFieldBegin iprot
if _t495 == T_STOP then return record else
case _id496 of
0 -> if _t495 == T_LIST then do
s <- (let {f 0 = return []; f n = do {v <- readString iprot;r <- f (n1); return $ v:r}} in do {(_etype500,_size497) <- readListBegin iprot; f _size497})
read_Describe_splits_result_fields iprot record{f_Describe_splits_result_success=Just s}
else do
skip iprot _t495
read_Describe_splits_result_fields iprot record
_ -> do
skip iprot _t495
readFieldEnd iprot
read_Describe_splits_result_fields iprot record
read_Describe_splits_result iprot = do
_ <- readStructBegin iprot
record <- read_Describe_splits_result_fields iprot (Describe_splits_result{f_Describe_splits_result_success=Nothing})
readStructEnd iprot
return record
data System_add_column_family_args = System_add_column_family_args{f_System_add_column_family_args_cf_def :: Maybe CfDef} deriving (Show,Eq,Ord,Typeable)
write_System_add_column_family_args oprot record = do
writeStructBegin oprot "System_add_column_family_args"
case f_System_add_column_family_args_cf_def record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("cf_def",T_STRUCT,1)
write_CfDef oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_add_column_family_args_fields iprot record = do
(_,_t505,_id506) <- readFieldBegin iprot
if _t505 == T_STOP then return record else
case _id506 of
1 -> if _t505 == T_STRUCT then do
s <- (read_CfDef iprot)
read_System_add_column_family_args_fields iprot record{f_System_add_column_family_args_cf_def=Just s}
else do
skip iprot _t505
read_System_add_column_family_args_fields iprot record
_ -> do
skip iprot _t505
readFieldEnd iprot
read_System_add_column_family_args_fields iprot record
read_System_add_column_family_args iprot = do
_ <- readStructBegin iprot
record <- read_System_add_column_family_args_fields iprot (System_add_column_family_args{f_System_add_column_family_args_cf_def=Nothing})
readStructEnd iprot
return record
data System_add_column_family_result = System_add_column_family_result{f_System_add_column_family_result_success :: Maybe String,f_System_add_column_family_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_System_add_column_family_result oprot record = do
writeStructBegin oprot "System_add_column_family_result"
case f_System_add_column_family_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
case f_System_add_column_family_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_add_column_family_result_fields iprot record = do
(_,_t510,_id511) <- readFieldBegin iprot
if _t510 == T_STOP then return record else
case _id511 of
0 -> if _t510 == T_STRING then do
s <- readString iprot
read_System_add_column_family_result_fields iprot record{f_System_add_column_family_result_success=Just s}
else do
skip iprot _t510
read_System_add_column_family_result_fields iprot record
1 -> if _t510 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_System_add_column_family_result_fields iprot record{f_System_add_column_family_result_ire=Just s}
else do
skip iprot _t510
read_System_add_column_family_result_fields iprot record
_ -> do
skip iprot _t510
readFieldEnd iprot
read_System_add_column_family_result_fields iprot record
read_System_add_column_family_result iprot = do
_ <- readStructBegin iprot
record <- read_System_add_column_family_result_fields iprot (System_add_column_family_result{f_System_add_column_family_result_success=Nothing,f_System_add_column_family_result_ire=Nothing})
readStructEnd iprot
return record
data System_drop_column_family_args = System_drop_column_family_args{f_System_drop_column_family_args_column_family :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_System_drop_column_family_args oprot record = do
writeStructBegin oprot "System_drop_column_family_args"
case f_System_drop_column_family_args_column_family record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("column_family",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_drop_column_family_args_fields iprot record = do
(_,_t515,_id516) <- readFieldBegin iprot
if _t515 == T_STOP then return record else
case _id516 of
1 -> if _t515 == T_STRING then do
s <- readString iprot
read_System_drop_column_family_args_fields iprot record{f_System_drop_column_family_args_column_family=Just s}
else do
skip iprot _t515
read_System_drop_column_family_args_fields iprot record
_ -> do
skip iprot _t515
readFieldEnd iprot
read_System_drop_column_family_args_fields iprot record
read_System_drop_column_family_args iprot = do
_ <- readStructBegin iprot
record <- read_System_drop_column_family_args_fields iprot (System_drop_column_family_args{f_System_drop_column_family_args_column_family=Nothing})
readStructEnd iprot
return record
data System_drop_column_family_result = System_drop_column_family_result{f_System_drop_column_family_result_success :: Maybe String,f_System_drop_column_family_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_System_drop_column_family_result oprot record = do
writeStructBegin oprot "System_drop_column_family_result"
case f_System_drop_column_family_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
case f_System_drop_column_family_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_drop_column_family_result_fields iprot record = do
(_,_t520,_id521) <- readFieldBegin iprot
if _t520 == T_STOP then return record else
case _id521 of
0 -> if _t520 == T_STRING then do
s <- readString iprot
read_System_drop_column_family_result_fields iprot record{f_System_drop_column_family_result_success=Just s}
else do
skip iprot _t520
read_System_drop_column_family_result_fields iprot record
1 -> if _t520 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_System_drop_column_family_result_fields iprot record{f_System_drop_column_family_result_ire=Just s}
else do
skip iprot _t520
read_System_drop_column_family_result_fields iprot record
_ -> do
skip iprot _t520
readFieldEnd iprot
read_System_drop_column_family_result_fields iprot record
read_System_drop_column_family_result iprot = do
_ <- readStructBegin iprot
record <- read_System_drop_column_family_result_fields iprot (System_drop_column_family_result{f_System_drop_column_family_result_success=Nothing,f_System_drop_column_family_result_ire=Nothing})
readStructEnd iprot
return record
data System_add_keyspace_args = System_add_keyspace_args{f_System_add_keyspace_args_ks_def :: Maybe KsDef} deriving (Show,Eq,Ord,Typeable)
write_System_add_keyspace_args oprot record = do
writeStructBegin oprot "System_add_keyspace_args"
case f_System_add_keyspace_args_ks_def record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ks_def",T_STRUCT,1)
write_KsDef oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_add_keyspace_args_fields iprot record = do
(_,_t525,_id526) <- readFieldBegin iprot
if _t525 == T_STOP then return record else
case _id526 of
1 -> if _t525 == T_STRUCT then do
s <- (read_KsDef iprot)
read_System_add_keyspace_args_fields iprot record{f_System_add_keyspace_args_ks_def=Just s}
else do
skip iprot _t525
read_System_add_keyspace_args_fields iprot record
_ -> do
skip iprot _t525
readFieldEnd iprot
read_System_add_keyspace_args_fields iprot record
read_System_add_keyspace_args iprot = do
_ <- readStructBegin iprot
record <- read_System_add_keyspace_args_fields iprot (System_add_keyspace_args{f_System_add_keyspace_args_ks_def=Nothing})
readStructEnd iprot
return record
data System_add_keyspace_result = System_add_keyspace_result{f_System_add_keyspace_result_success :: Maybe String,f_System_add_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_System_add_keyspace_result oprot record = do
writeStructBegin oprot "System_add_keyspace_result"
case f_System_add_keyspace_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
case f_System_add_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_add_keyspace_result_fields iprot record = do
(_,_t530,_id531) <- readFieldBegin iprot
if _t530 == T_STOP then return record else
case _id531 of
0 -> if _t530 == T_STRING then do
s <- readString iprot
read_System_add_keyspace_result_fields iprot record{f_System_add_keyspace_result_success=Just s}
else do
skip iprot _t530
read_System_add_keyspace_result_fields iprot record
1 -> if _t530 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_System_add_keyspace_result_fields iprot record{f_System_add_keyspace_result_ire=Just s}
else do
skip iprot _t530
read_System_add_keyspace_result_fields iprot record
_ -> do
skip iprot _t530
readFieldEnd iprot
read_System_add_keyspace_result_fields iprot record
read_System_add_keyspace_result iprot = do
_ <- readStructBegin iprot
record <- read_System_add_keyspace_result_fields iprot (System_add_keyspace_result{f_System_add_keyspace_result_success=Nothing,f_System_add_keyspace_result_ire=Nothing})
readStructEnd iprot
return record
data System_drop_keyspace_args = System_drop_keyspace_args{f_System_drop_keyspace_args_keyspace :: Maybe String} deriving (Show,Eq,Ord,Typeable)
write_System_drop_keyspace_args oprot record = do
writeStructBegin oprot "System_drop_keyspace_args"
case f_System_drop_keyspace_args_keyspace record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("keyspace",T_STRING,1)
writeString oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_drop_keyspace_args_fields iprot record = do
(_,_t535,_id536) <- readFieldBegin iprot
if _t535 == T_STOP then return record else
case _id536 of
1 -> if _t535 == T_STRING then do
s <- readString iprot
read_System_drop_keyspace_args_fields iprot record{f_System_drop_keyspace_args_keyspace=Just s}
else do
skip iprot _t535
read_System_drop_keyspace_args_fields iprot record
_ -> do
skip iprot _t535
readFieldEnd iprot
read_System_drop_keyspace_args_fields iprot record
read_System_drop_keyspace_args iprot = do
_ <- readStructBegin iprot
record <- read_System_drop_keyspace_args_fields iprot (System_drop_keyspace_args{f_System_drop_keyspace_args_keyspace=Nothing})
readStructEnd iprot
return record
data System_drop_keyspace_result = System_drop_keyspace_result{f_System_drop_keyspace_result_success :: Maybe String,f_System_drop_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_System_drop_keyspace_result oprot record = do
writeStructBegin oprot "System_drop_keyspace_result"
case f_System_drop_keyspace_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
case f_System_drop_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_drop_keyspace_result_fields iprot record = do
(_,_t540,_id541) <- readFieldBegin iprot
if _t540 == T_STOP then return record else
case _id541 of
0 -> if _t540 == T_STRING then do
s <- readString iprot
read_System_drop_keyspace_result_fields iprot record{f_System_drop_keyspace_result_success=Just s}
else do
skip iprot _t540
read_System_drop_keyspace_result_fields iprot record
1 -> if _t540 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_System_drop_keyspace_result_fields iprot record{f_System_drop_keyspace_result_ire=Just s}
else do
skip iprot _t540
read_System_drop_keyspace_result_fields iprot record
_ -> do
skip iprot _t540
readFieldEnd iprot
read_System_drop_keyspace_result_fields iprot record
read_System_drop_keyspace_result iprot = do
_ <- readStructBegin iprot
record <- read_System_drop_keyspace_result_fields iprot (System_drop_keyspace_result{f_System_drop_keyspace_result_success=Nothing,f_System_drop_keyspace_result_ire=Nothing})
readStructEnd iprot
return record
data System_update_keyspace_args = System_update_keyspace_args{f_System_update_keyspace_args_ks_def :: Maybe KsDef} deriving (Show,Eq,Ord,Typeable)
write_System_update_keyspace_args oprot record = do
writeStructBegin oprot "System_update_keyspace_args"
case f_System_update_keyspace_args_ks_def record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ks_def",T_STRUCT,1)
write_KsDef oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_update_keyspace_args_fields iprot record = do
(_,_t545,_id546) <- readFieldBegin iprot
if _t545 == T_STOP then return record else
case _id546 of
1 -> if _t545 == T_STRUCT then do
s <- (read_KsDef iprot)
read_System_update_keyspace_args_fields iprot record{f_System_update_keyspace_args_ks_def=Just s}
else do
skip iprot _t545
read_System_update_keyspace_args_fields iprot record
_ -> do
skip iprot _t545
readFieldEnd iprot
read_System_update_keyspace_args_fields iprot record
read_System_update_keyspace_args iprot = do
_ <- readStructBegin iprot
record <- read_System_update_keyspace_args_fields iprot (System_update_keyspace_args{f_System_update_keyspace_args_ks_def=Nothing})
readStructEnd iprot
return record
data System_update_keyspace_result = System_update_keyspace_result{f_System_update_keyspace_result_success :: Maybe String,f_System_update_keyspace_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_System_update_keyspace_result oprot record = do
writeStructBegin oprot "System_update_keyspace_result"
case f_System_update_keyspace_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
case f_System_update_keyspace_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_update_keyspace_result_fields iprot record = do
(_,_t550,_id551) <- readFieldBegin iprot
if _t550 == T_STOP then return record else
case _id551 of
0 -> if _t550 == T_STRING then do
s <- readString iprot
read_System_update_keyspace_result_fields iprot record{f_System_update_keyspace_result_success=Just s}
else do
skip iprot _t550
read_System_update_keyspace_result_fields iprot record
1 -> if _t550 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_System_update_keyspace_result_fields iprot record{f_System_update_keyspace_result_ire=Just s}
else do
skip iprot _t550
read_System_update_keyspace_result_fields iprot record
_ -> do
skip iprot _t550
readFieldEnd iprot
read_System_update_keyspace_result_fields iprot record
read_System_update_keyspace_result iprot = do
_ <- readStructBegin iprot
record <- read_System_update_keyspace_result_fields iprot (System_update_keyspace_result{f_System_update_keyspace_result_success=Nothing,f_System_update_keyspace_result_ire=Nothing})
readStructEnd iprot
return record
data System_update_column_family_args = System_update_column_family_args{f_System_update_column_family_args_cf_def :: Maybe CfDef} deriving (Show,Eq,Ord,Typeable)
write_System_update_column_family_args oprot record = do
writeStructBegin oprot "System_update_column_family_args"
case f_System_update_column_family_args_cf_def record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("cf_def",T_STRUCT,1)
write_CfDef oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_update_column_family_args_fields iprot record = do
(_,_t555,_id556) <- readFieldBegin iprot
if _t555 == T_STOP then return record else
case _id556 of
1 -> if _t555 == T_STRUCT then do
s <- (read_CfDef iprot)
read_System_update_column_family_args_fields iprot record{f_System_update_column_family_args_cf_def=Just s}
else do
skip iprot _t555
read_System_update_column_family_args_fields iprot record
_ -> do
skip iprot _t555
readFieldEnd iprot
read_System_update_column_family_args_fields iprot record
read_System_update_column_family_args iprot = do
_ <- readStructBegin iprot
record <- read_System_update_column_family_args_fields iprot (System_update_column_family_args{f_System_update_column_family_args_cf_def=Nothing})
readStructEnd iprot
return record
data System_update_column_family_result = System_update_column_family_result{f_System_update_column_family_result_success :: Maybe String,f_System_update_column_family_result_ire :: Maybe InvalidRequestException} deriving (Show,Eq,Ord,Typeable)
write_System_update_column_family_result oprot record = do
writeStructBegin oprot "System_update_column_family_result"
case f_System_update_column_family_result_success record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("success",T_STRING,0)
writeString oprot _v
writeFieldEnd oprot}
case f_System_update_column_family_result_ire record of {Nothing -> return (); Just _v -> do
writeFieldBegin oprot ("ire",T_STRUCT,1)
write_InvalidRequestException oprot _v
writeFieldEnd oprot}
writeFieldStop oprot
writeStructEnd oprot
read_System_update_column_family_result_fields iprot record = do
(_,_t560,_id561) <- readFieldBegin iprot
if _t560 == T_STOP then return record else
case _id561 of
0 -> if _t560 == T_STRING then do
s <- readString iprot
read_System_update_column_family_result_fields iprot record{f_System_update_column_family_result_success=Just s}
else do
skip iprot _t560
read_System_update_column_family_result_fields iprot record
1 -> if _t560 == T_STRUCT then do
s <- (read_InvalidRequestException iprot)
read_System_update_column_family_result_fields iprot record{f_System_update_column_family_result_ire=Just s}
else do
skip iprot _t560
read_System_update_column_family_result_fields iprot record
_ -> do
skip iprot _t560
readFieldEnd iprot
read_System_update_column_family_result_fields iprot record
read_System_update_column_family_result iprot = do
_ <- readStructBegin iprot
record <- read_System_update_column_family_result_fields iprot (System_update_column_family_result{f_System_update_column_family_result_success=Nothing,f_System_update_column_family_result_ire=Nothing})
readStructEnd iprot
return record
process_login (seqid, iprot, oprot, handler) = do
args <- read_Login_args iprot
readMessageEnd iprot
rs <- return (Login_result Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(do
Iface.login handler (f_Login_args_auth_request args)
return rs)
(\e ->
return rs{f_Login_result_authnx =Just e}))
(\e ->
return rs{f_Login_result_authzx =Just e}))
writeMessageBegin oprot ("login", M_REPLY, seqid);
write_Login_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_set_keyspace (seqid, iprot, oprot, handler) = do
args <- read_Set_keyspace_args iprot
readMessageEnd iprot
rs <- return (Set_keyspace_result Nothing)
res <- (Control.Exception.catch
(do
Iface.set_keyspace handler (f_Set_keyspace_args_keyspace args)
return rs)
(\e ->
return rs{f_Set_keyspace_result_ire =Just e}))
writeMessageBegin oprot ("set_keyspace", M_REPLY, seqid);
write_Set_keyspace_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_get (seqid, iprot, oprot, handler) = do
args <- read_Get_args iprot
readMessageEnd iprot
rs <- return (Get_result Nothing Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.get handler (f_Get_args_key args) (f_Get_args_column_path args) (f_Get_args_consistency_level args)
return rs{f_Get_result_success= Just res})
(\e ->
return rs{f_Get_result_ire =Just e}))
(\e ->
return rs{f_Get_result_nfe =Just e}))
(\e ->
return rs{f_Get_result_ue =Just e}))
(\e ->
return rs{f_Get_result_te =Just e}))
writeMessageBegin oprot ("get", M_REPLY, seqid);
write_Get_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_get_slice (seqid, iprot, oprot, handler) = do
args <- read_Get_slice_args iprot
readMessageEnd iprot
rs <- return (Get_slice_result Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.get_slice handler (f_Get_slice_args_key args) (f_Get_slice_args_column_parent args) (f_Get_slice_args_predicate args) (f_Get_slice_args_consistency_level args)
return rs{f_Get_slice_result_success= Just res})
(\e ->
return rs{f_Get_slice_result_ire =Just e}))
(\e ->
return rs{f_Get_slice_result_ue =Just e}))
(\e ->
return rs{f_Get_slice_result_te =Just e}))
writeMessageBegin oprot ("get_slice", M_REPLY, seqid);
write_Get_slice_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_get_count (seqid, iprot, oprot, handler) = do
args <- read_Get_count_args iprot
readMessageEnd iprot
rs <- return (Get_count_result Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.get_count handler (f_Get_count_args_key args) (f_Get_count_args_column_parent args) (f_Get_count_args_predicate args) (f_Get_count_args_consistency_level args)
return rs{f_Get_count_result_success= Just res})
(\e ->
return rs{f_Get_count_result_ire =Just e}))
(\e ->
return rs{f_Get_count_result_ue =Just e}))
(\e ->
return rs{f_Get_count_result_te =Just e}))
writeMessageBegin oprot ("get_count", M_REPLY, seqid);
write_Get_count_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_multiget_slice (seqid, iprot, oprot, handler) = do
args <- read_Multiget_slice_args iprot
readMessageEnd iprot
rs <- return (Multiget_slice_result Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.multiget_slice handler (f_Multiget_slice_args_keys args) (f_Multiget_slice_args_column_parent args) (f_Multiget_slice_args_predicate args) (f_Multiget_slice_args_consistency_level args)
return rs{f_Multiget_slice_result_success= Just res})
(\e ->
return rs{f_Multiget_slice_result_ire =Just e}))
(\e ->
return rs{f_Multiget_slice_result_ue =Just e}))
(\e ->
return rs{f_Multiget_slice_result_te =Just e}))
writeMessageBegin oprot ("multiget_slice", M_REPLY, seqid);
write_Multiget_slice_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_multiget_count (seqid, iprot, oprot, handler) = do
args <- read_Multiget_count_args iprot
readMessageEnd iprot
rs <- return (Multiget_count_result Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.multiget_count handler (f_Multiget_count_args_keys args) (f_Multiget_count_args_column_parent args) (f_Multiget_count_args_predicate args) (f_Multiget_count_args_consistency_level args)
return rs{f_Multiget_count_result_success= Just res})
(\e ->
return rs{f_Multiget_count_result_ire =Just e}))
(\e ->
return rs{f_Multiget_count_result_ue =Just e}))
(\e ->
return rs{f_Multiget_count_result_te =Just e}))
writeMessageBegin oprot ("multiget_count", M_REPLY, seqid);
write_Multiget_count_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_get_range_slices (seqid, iprot, oprot, handler) = do
args <- read_Get_range_slices_args iprot
readMessageEnd iprot
rs <- return (Get_range_slices_result Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.get_range_slices handler (f_Get_range_slices_args_column_parent args) (f_Get_range_slices_args_predicate args) (f_Get_range_slices_args_range args) (f_Get_range_slices_args_consistency_level args)
return rs{f_Get_range_slices_result_success= Just res})
(\e ->
return rs{f_Get_range_slices_result_ire =Just e}))
(\e ->
return rs{f_Get_range_slices_result_ue =Just e}))
(\e ->
return rs{f_Get_range_slices_result_te =Just e}))
writeMessageBegin oprot ("get_range_slices", M_REPLY, seqid);
write_Get_range_slices_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_get_indexed_slices (seqid, iprot, oprot, handler) = do
args <- read_Get_indexed_slices_args iprot
readMessageEnd iprot
rs <- return (Get_indexed_slices_result Nothing Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.get_indexed_slices handler (f_Get_indexed_slices_args_column_parent args) (f_Get_indexed_slices_args_index_clause args) (f_Get_indexed_slices_args_column_predicate args) (f_Get_indexed_slices_args_consistency_level args)
return rs{f_Get_indexed_slices_result_success= Just res})
(\e ->
return rs{f_Get_indexed_slices_result_ire =Just e}))
(\e ->
return rs{f_Get_indexed_slices_result_ue =Just e}))
(\e ->
return rs{f_Get_indexed_slices_result_te =Just e}))
writeMessageBegin oprot ("get_indexed_slices", M_REPLY, seqid);
write_Get_indexed_slices_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_insert (seqid, iprot, oprot, handler) = do
args <- read_Insert_args iprot
readMessageEnd iprot
rs <- return (Insert_result Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
Iface.insert handler (f_Insert_args_key args) (f_Insert_args_column_parent args) (f_Insert_args_column args) (f_Insert_args_consistency_level args)
return rs)
(\e ->
return rs{f_Insert_result_ire =Just e}))
(\e ->
return rs{f_Insert_result_ue =Just e}))
(\e ->
return rs{f_Insert_result_te =Just e}))
writeMessageBegin oprot ("insert", M_REPLY, seqid);
write_Insert_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_remove (seqid, iprot, oprot, handler) = do
args <- read_Remove_args iprot
readMessageEnd iprot
rs <- return (Remove_result Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
Iface.remove handler (f_Remove_args_key args) (f_Remove_args_column_path args) (f_Remove_args_timestamp args) (f_Remove_args_consistency_level args)
return rs)
(\e ->
return rs{f_Remove_result_ire =Just e}))
(\e ->
return rs{f_Remove_result_ue =Just e}))
(\e ->
return rs{f_Remove_result_te =Just e}))
writeMessageBegin oprot ("remove", M_REPLY, seqid);
write_Remove_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_batch_mutate (seqid, iprot, oprot, handler) = do
args <- read_Batch_mutate_args iprot
readMessageEnd iprot
rs <- return (Batch_mutate_result Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(Control.Exception.catch
(do
Iface.batch_mutate handler (f_Batch_mutate_args_mutation_map args) (f_Batch_mutate_args_consistency_level args)
return rs)
(\e ->
return rs{f_Batch_mutate_result_ire =Just e}))
(\e ->
return rs{f_Batch_mutate_result_ue =Just e}))
(\e ->
return rs{f_Batch_mutate_result_te =Just e}))
writeMessageBegin oprot ("batch_mutate", M_REPLY, seqid);
write_Batch_mutate_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_truncate (seqid, iprot, oprot, handler) = do
args <- read_Truncate_args iprot
readMessageEnd iprot
rs <- return (Truncate_result Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(do
Iface.truncate handler (f_Truncate_args_cfname args)
return rs)
(\e ->
return rs{f_Truncate_result_ire =Just e}))
(\e ->
return rs{f_Truncate_result_ue =Just e}))
writeMessageBegin oprot ("truncate", M_REPLY, seqid);
write_Truncate_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_schema_versions (seqid, iprot, oprot, handler) = do
args <- read_Describe_schema_versions_args iprot
readMessageEnd iprot
rs <- return (Describe_schema_versions_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.describe_schema_versions handler
return rs{f_Describe_schema_versions_result_success= Just res})
(\e ->
return rs{f_Describe_schema_versions_result_ire =Just e}))
writeMessageBegin oprot ("describe_schema_versions", M_REPLY, seqid);
write_Describe_schema_versions_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_keyspaces (seqid, iprot, oprot, handler) = do
args <- read_Describe_keyspaces_args iprot
readMessageEnd iprot
rs <- return (Describe_keyspaces_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.describe_keyspaces handler
return rs{f_Describe_keyspaces_result_success= Just res})
(\e ->
return rs{f_Describe_keyspaces_result_ire =Just e}))
writeMessageBegin oprot ("describe_keyspaces", M_REPLY, seqid);
write_Describe_keyspaces_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_cluster_name (seqid, iprot, oprot, handler) = do
args <- read_Describe_cluster_name_args iprot
readMessageEnd iprot
rs <- return (Describe_cluster_name_result Nothing)
res <- (do
res <- Iface.describe_cluster_name handler
return rs{f_Describe_cluster_name_result_success= Just res})
writeMessageBegin oprot ("describe_cluster_name", M_REPLY, seqid);
write_Describe_cluster_name_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_version (seqid, iprot, oprot, handler) = do
args <- read_Describe_version_args iprot
readMessageEnd iprot
rs <- return (Describe_version_result Nothing)
res <- (do
res <- Iface.describe_version handler
return rs{f_Describe_version_result_success= Just res})
writeMessageBegin oprot ("describe_version", M_REPLY, seqid);
write_Describe_version_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_ring (seqid, iprot, oprot, handler) = do
args <- read_Describe_ring_args iprot
readMessageEnd iprot
rs <- return (Describe_ring_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.describe_ring handler (f_Describe_ring_args_keyspace args)
return rs{f_Describe_ring_result_success= Just res})
(\e ->
return rs{f_Describe_ring_result_ire =Just e}))
writeMessageBegin oprot ("describe_ring", M_REPLY, seqid);
write_Describe_ring_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_partitioner (seqid, iprot, oprot, handler) = do
args <- read_Describe_partitioner_args iprot
readMessageEnd iprot
rs <- return (Describe_partitioner_result Nothing)
res <- (do
res <- Iface.describe_partitioner handler
return rs{f_Describe_partitioner_result_success= Just res})
writeMessageBegin oprot ("describe_partitioner", M_REPLY, seqid);
write_Describe_partitioner_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_snitch (seqid, iprot, oprot, handler) = do
args <- read_Describe_snitch_args iprot
readMessageEnd iprot
rs <- return (Describe_snitch_result Nothing)
res <- (do
res <- Iface.describe_snitch handler
return rs{f_Describe_snitch_result_success= Just res})
writeMessageBegin oprot ("describe_snitch", M_REPLY, seqid);
write_Describe_snitch_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_keyspace (seqid, iprot, oprot, handler) = do
args <- read_Describe_keyspace_args iprot
readMessageEnd iprot
rs <- return (Describe_keyspace_result Nothing Nothing Nothing)
res <- (Control.Exception.catch
(Control.Exception.catch
(do
res <- Iface.describe_keyspace handler (f_Describe_keyspace_args_keyspace args)
return rs{f_Describe_keyspace_result_success= Just res})
(\e ->
return rs{f_Describe_keyspace_result_nfe =Just e}))
(\e ->
return rs{f_Describe_keyspace_result_ire =Just e}))
writeMessageBegin oprot ("describe_keyspace", M_REPLY, seqid);
write_Describe_keyspace_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_describe_splits (seqid, iprot, oprot, handler) = do
args <- read_Describe_splits_args iprot
readMessageEnd iprot
rs <- return (Describe_splits_result Nothing)
res <- (do
res <- Iface.describe_splits handler (f_Describe_splits_args_cfName args) (f_Describe_splits_args_start_token args) (f_Describe_splits_args_end_token args) (f_Describe_splits_args_keys_per_split args)
return rs{f_Describe_splits_result_success= Just res})
writeMessageBegin oprot ("describe_splits", M_REPLY, seqid);
write_Describe_splits_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_system_add_column_family (seqid, iprot, oprot, handler) = do
args <- read_System_add_column_family_args iprot
readMessageEnd iprot
rs <- return (System_add_column_family_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.system_add_column_family handler (f_System_add_column_family_args_cf_def args)
return rs{f_System_add_column_family_result_success= Just res})
(\e ->
return rs{f_System_add_column_family_result_ire =Just e}))
writeMessageBegin oprot ("system_add_column_family", M_REPLY, seqid);
write_System_add_column_family_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_system_drop_column_family (seqid, iprot, oprot, handler) = do
args <- read_System_drop_column_family_args iprot
readMessageEnd iprot
rs <- return (System_drop_column_family_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.system_drop_column_family handler (f_System_drop_column_family_args_column_family args)
return rs{f_System_drop_column_family_result_success= Just res})
(\e ->
return rs{f_System_drop_column_family_result_ire =Just e}))
writeMessageBegin oprot ("system_drop_column_family", M_REPLY, seqid);
write_System_drop_column_family_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_system_add_keyspace (seqid, iprot, oprot, handler) = do
args <- read_System_add_keyspace_args iprot
readMessageEnd iprot
rs <- return (System_add_keyspace_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.system_add_keyspace handler (f_System_add_keyspace_args_ks_def args)
return rs{f_System_add_keyspace_result_success= Just res})
(\e ->
return rs{f_System_add_keyspace_result_ire =Just e}))
writeMessageBegin oprot ("system_add_keyspace", M_REPLY, seqid);
write_System_add_keyspace_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_system_drop_keyspace (seqid, iprot, oprot, handler) = do
args <- read_System_drop_keyspace_args iprot
readMessageEnd iprot
rs <- return (System_drop_keyspace_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.system_drop_keyspace handler (f_System_drop_keyspace_args_keyspace args)
return rs{f_System_drop_keyspace_result_success= Just res})
(\e ->
return rs{f_System_drop_keyspace_result_ire =Just e}))
writeMessageBegin oprot ("system_drop_keyspace", M_REPLY, seqid);
write_System_drop_keyspace_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_system_update_keyspace (seqid, iprot, oprot, handler) = do
args <- read_System_update_keyspace_args iprot
readMessageEnd iprot
rs <- return (System_update_keyspace_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.system_update_keyspace handler (f_System_update_keyspace_args_ks_def args)
return rs{f_System_update_keyspace_result_success= Just res})
(\e ->
return rs{f_System_update_keyspace_result_ire =Just e}))
writeMessageBegin oprot ("system_update_keyspace", M_REPLY, seqid);
write_System_update_keyspace_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
process_system_update_column_family (seqid, iprot, oprot, handler) = do
args <- read_System_update_column_family_args iprot
readMessageEnd iprot
rs <- return (System_update_column_family_result Nothing Nothing)
res <- (Control.Exception.catch
(do
res <- Iface.system_update_column_family handler (f_System_update_column_family_args_cf_def args)
return rs{f_System_update_column_family_result_success= Just res})
(\e ->
return rs{f_System_update_column_family_result_ire =Just e}))
writeMessageBegin oprot ("system_update_column_family", M_REPLY, seqid);
write_System_update_column_family_result oprot res
writeMessageEnd oprot
tFlush (getTransport oprot)
proc_ handler (iprot,oprot) (name,typ,seqid) = case name of
"login" -> process_login (seqid,iprot,oprot,handler)
"set_keyspace" -> process_set_keyspace (seqid,iprot,oprot,handler)
"get" -> process_get (seqid,iprot,oprot,handler)
"get_slice" -> process_get_slice (seqid,iprot,oprot,handler)
"get_count" -> process_get_count (seqid,iprot,oprot,handler)
"multiget_slice" -> process_multiget_slice (seqid,iprot,oprot,handler)
"multiget_count" -> process_multiget_count (seqid,iprot,oprot,handler)
"get_range_slices" -> process_get_range_slices (seqid,iprot,oprot,handler)
"get_indexed_slices" -> process_get_indexed_slices (seqid,iprot,oprot,handler)
"insert" -> process_insert (seqid,iprot,oprot,handler)
"remove" -> process_remove (seqid,iprot,oprot,handler)
"batch_mutate" -> process_batch_mutate (seqid,iprot,oprot,handler)
"truncate" -> process_truncate (seqid,iprot,oprot,handler)
"describe_schema_versions" -> process_describe_schema_versions (seqid,iprot,oprot,handler)
"describe_keyspaces" -> process_describe_keyspaces (seqid,iprot,oprot,handler)
"describe_cluster_name" -> process_describe_cluster_name (seqid,iprot,oprot,handler)
"describe_version" -> process_describe_version (seqid,iprot,oprot,handler)
"describe_ring" -> process_describe_ring (seqid,iprot,oprot,handler)
"describe_partitioner" -> process_describe_partitioner (seqid,iprot,oprot,handler)
"describe_snitch" -> process_describe_snitch (seqid,iprot,oprot,handler)
"describe_keyspace" -> process_describe_keyspace (seqid,iprot,oprot,handler)
"describe_splits" -> process_describe_splits (seqid,iprot,oprot,handler)
"system_add_column_family" -> process_system_add_column_family (seqid,iprot,oprot,handler)
"system_drop_column_family" -> process_system_drop_column_family (seqid,iprot,oprot,handler)
"system_add_keyspace" -> process_system_add_keyspace (seqid,iprot,oprot,handler)
"system_drop_keyspace" -> process_system_drop_keyspace (seqid,iprot,oprot,handler)
"system_update_keyspace" -> process_system_update_keyspace (seqid,iprot,oprot,handler)
"system_update_column_family" -> process_system_update_column_family (seqid,iprot,oprot,handler)
_ -> do
skip iprot T_STRUCT
readMessageEnd iprot
writeMessageBegin oprot (name,M_EXCEPTION,seqid)
writeAppExn oprot (AppExn AE_UNKNOWN_METHOD ("Unknown function " ++ name))
writeMessageEnd oprot
tFlush (getTransport oprot)
process handler (iprot, oprot) = do
(name, typ, seqid) <- readMessageBegin iprot
proc_ handler (iprot,oprot) (name,typ,seqid)
return True