cassandra-thrift 0.8.5 → 0.8.5.1

raw patch · 1 files changed

+3/−3 lines, 1 filesdep ~Thriftnew-uploaderPVP: minor bump suggested

API additions: PVP suggests at least a minor version bump

Dependency ranges changed: Thrift

API changes (from Hackage documentation)

+ Database.Cassandra.Thrift.Cassandra: proc_ :: (Protocol a1, Protocol a3, Transport t1, Transport a2, Cassandra_Iface a) => a -> (a1 t1, a3 a2) -> ([Char], t, Int32) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process :: (Protocol a1, Protocol a3, Transport t, Transport a2, Cassandra_Iface a) => a -> (a1 t, a3 a2) -> IO Bool

+ Database.Cassandra.Thrift.Cassandra: process_add :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_batch_mutate :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_cluster_name :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_keyspace :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_keyspaces :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_partitioner :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_ring :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_schema_versions :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_snitch :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_splits :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_describe_version :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_execute_cql_query :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_get :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_get_count :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_get_indexed_slices :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_get_range_slices :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_get_slice :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_insert :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_login :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_multiget_count :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_multiget_slice :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_remove :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_remove_counter :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_set_keyspace :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_system_add_column_family :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_system_add_keyspace :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_system_drop_column_family :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_system_drop_keyspace :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_system_update_column_family :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_system_update_keyspace :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: process_truncate :: (Protocol a, Protocol a3, Transport t, Transport a2, Cassandra_Iface a1) => (Int32, a t, a3 a2, a1) -> IO ()

+ Database.Cassandra.Thrift.Cassandra: read_Add_args :: (Protocol a, Transport t) => a t -> IO Add_args

+ Database.Cassandra.Thrift.Cassandra: read_Add_args_fields :: (Protocol a, Transport t) => a t -> Add_args -> IO Add_args

+ Database.Cassandra.Thrift.Cassandra: read_Add_result :: (Protocol a, Transport t) => a t -> IO Add_result

+ Database.Cassandra.Thrift.Cassandra: read_Add_result_fields :: (Protocol a, Transport t) => a t -> Add_result -> IO Add_result

+ Database.Cassandra.Thrift.Cassandra: read_Batch_mutate_args :: (Protocol a, Transport t) => a t -> IO Batch_mutate_args

+ Database.Cassandra.Thrift.Cassandra: read_Batch_mutate_args_fields :: (Protocol a, Transport t) => a t -> Batch_mutate_args -> IO Batch_mutate_args

+ Database.Cassandra.Thrift.Cassandra: read_Batch_mutate_result :: (Protocol a, Transport t) => a t -> IO Batch_mutate_result

+ Database.Cassandra.Thrift.Cassandra: read_Batch_mutate_result_fields :: (Protocol a, Transport t) => a t -> Batch_mutate_result -> IO Batch_mutate_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_cluster_name_args :: (Protocol a, Transport t) => a t -> IO Describe_cluster_name_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_cluster_name_args_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra: read_Describe_cluster_name_result :: (Protocol a, Transport t) => a t -> IO Describe_cluster_name_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_cluster_name_result_fields :: (Protocol a, Transport t) => a t -> Describe_cluster_name_result -> IO Describe_cluster_name_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspace_args :: (Protocol a, Transport t) => a t -> IO Describe_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspace_args_fields :: (Protocol a, Transport t) => a t -> Describe_keyspace_args -> IO Describe_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspace_result :: (Protocol a, Transport t) => a t -> IO Describe_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspace_result_fields :: (Protocol a, Transport t) => a t -> Describe_keyspace_result -> IO Describe_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspaces_args :: (Protocol a, Transport t) => a t -> IO Describe_keyspaces_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspaces_args_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspaces_result :: (Protocol a, Transport t) => a t -> IO Describe_keyspaces_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_keyspaces_result_fields :: (Protocol a, Transport t) => a t -> Describe_keyspaces_result -> IO Describe_keyspaces_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_partitioner_args :: (Protocol a, Transport t) => a t -> IO Describe_partitioner_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_partitioner_args_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra: read_Describe_partitioner_result :: (Protocol a, Transport t) => a t -> IO Describe_partitioner_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_partitioner_result_fields :: (Protocol a, Transport t) => a t -> Describe_partitioner_result -> IO Describe_partitioner_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_ring_args :: (Protocol a, Transport t) => a t -> IO Describe_ring_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_ring_args_fields :: (Protocol a, Transport t) => a t -> Describe_ring_args -> IO Describe_ring_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_ring_result :: (Protocol a, Transport t) => a t -> IO Describe_ring_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_ring_result_fields :: (Protocol a, Transport t) => a t -> Describe_ring_result -> IO Describe_ring_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_schema_versions_args :: (Protocol a, Transport t) => a t -> IO Describe_schema_versions_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_schema_versions_args_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra: read_Describe_schema_versions_result :: (Protocol a, Transport t) => a t -> IO Describe_schema_versions_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_schema_versions_result_fields :: (Protocol a, Transport t) => a t -> Describe_schema_versions_result -> IO Describe_schema_versions_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_snitch_args :: (Protocol a, Transport t) => a t -> IO Describe_snitch_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_snitch_args_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra: read_Describe_snitch_result :: (Protocol a, Transport t) => a t -> IO Describe_snitch_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_snitch_result_fields :: (Protocol a, Transport t) => a t -> Describe_snitch_result -> IO Describe_snitch_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_splits_args :: (Protocol a, Transport t) => a t -> IO Describe_splits_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_splits_args_fields :: (Protocol a, Transport t) => a t -> Describe_splits_args -> IO Describe_splits_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_splits_result :: (Protocol a, Transport t) => a t -> IO Describe_splits_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_splits_result_fields :: (Protocol a, Transport t) => a t -> Describe_splits_result -> IO Describe_splits_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_version_args :: (Protocol a, Transport t) => a t -> IO Describe_version_args

+ Database.Cassandra.Thrift.Cassandra: read_Describe_version_args_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra: read_Describe_version_result :: (Protocol a, Transport t) => a t -> IO Describe_version_result

+ Database.Cassandra.Thrift.Cassandra: read_Describe_version_result_fields :: (Protocol a, Transport t) => a t -> Describe_version_result -> IO Describe_version_result

+ Database.Cassandra.Thrift.Cassandra: read_Execute_cql_query_args :: (Protocol a, Transport t) => a t -> IO Execute_cql_query_args

+ Database.Cassandra.Thrift.Cassandra: read_Execute_cql_query_args_fields :: (Protocol a, Transport t) => a t -> Execute_cql_query_args -> IO Execute_cql_query_args

+ Database.Cassandra.Thrift.Cassandra: read_Execute_cql_query_result :: (Protocol a, Transport t) => a t -> IO Execute_cql_query_result

+ Database.Cassandra.Thrift.Cassandra: read_Execute_cql_query_result_fields :: (Protocol a, Transport t) => a t -> Execute_cql_query_result -> IO Execute_cql_query_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_args :: (Protocol a, Transport t) => a t -> IO Get_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_args_fields :: (Protocol a, Transport t) => a t -> Get_args -> IO Get_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_count_args :: (Protocol a, Transport t) => a t -> IO Get_count_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_count_args_fields :: (Protocol a, Transport t) => a t -> Get_count_args -> IO Get_count_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_count_result :: (Protocol a, Transport t) => a t -> IO Get_count_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_count_result_fields :: (Protocol a, Transport t) => a t -> Get_count_result -> IO Get_count_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_indexed_slices_args :: (Protocol a, Transport t) => a t -> IO Get_indexed_slices_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_indexed_slices_args_fields :: (Protocol a, Transport t) => a t -> Get_indexed_slices_args -> IO Get_indexed_slices_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_indexed_slices_result :: (Protocol a, Transport t) => a t -> IO Get_indexed_slices_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_indexed_slices_result_fields :: (Protocol a, Transport t) => a t -> Get_indexed_slices_result -> IO Get_indexed_slices_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_range_slices_args :: (Protocol a, Transport t) => a t -> IO Get_range_slices_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_range_slices_args_fields :: (Protocol a, Transport t) => a t -> Get_range_slices_args -> IO Get_range_slices_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_range_slices_result :: (Protocol a, Transport t) => a t -> IO Get_range_slices_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_range_slices_result_fields :: (Protocol a, Transport t) => a t -> Get_range_slices_result -> IO Get_range_slices_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_result :: (Protocol a, Transport t) => a t -> IO Get_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_result_fields :: (Protocol a, Transport t) => a t -> Get_result -> IO Get_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_slice_args :: (Protocol a, Transport t) => a t -> IO Get_slice_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_slice_args_fields :: (Protocol a, Transport t) => a t -> Get_slice_args -> IO Get_slice_args

+ Database.Cassandra.Thrift.Cassandra: read_Get_slice_result :: (Protocol a, Transport t) => a t -> IO Get_slice_result

+ Database.Cassandra.Thrift.Cassandra: read_Get_slice_result_fields :: (Protocol a, Transport t) => a t -> Get_slice_result -> IO Get_slice_result

+ Database.Cassandra.Thrift.Cassandra: read_Insert_args :: (Protocol a, Transport t) => a t -> IO Insert_args

+ Database.Cassandra.Thrift.Cassandra: read_Insert_args_fields :: (Protocol a, Transport t) => a t -> Insert_args -> IO Insert_args

+ Database.Cassandra.Thrift.Cassandra: read_Insert_result :: (Protocol a, Transport t) => a t -> IO Insert_result

+ Database.Cassandra.Thrift.Cassandra: read_Insert_result_fields :: (Protocol a, Transport t) => a t -> Insert_result -> IO Insert_result

+ Database.Cassandra.Thrift.Cassandra: read_Login_args :: (Protocol a, Transport t) => a t -> IO Login_args

+ Database.Cassandra.Thrift.Cassandra: read_Login_args_fields :: (Protocol a, Transport t) => a t -> Login_args -> IO Login_args

+ Database.Cassandra.Thrift.Cassandra: read_Login_result :: (Protocol a, Transport t) => a t -> IO Login_result

+ Database.Cassandra.Thrift.Cassandra: read_Login_result_fields :: (Protocol a, Transport t) => a t -> Login_result -> IO Login_result

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_count_args :: (Protocol a, Transport t) => a t -> IO Multiget_count_args

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_count_args_fields :: (Protocol a, Transport t) => a t -> Multiget_count_args -> IO Multiget_count_args

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_count_result :: (Protocol a, Transport t) => a t -> IO Multiget_count_result

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_count_result_fields :: (Protocol a, Transport t) => a t -> Multiget_count_result -> IO Multiget_count_result

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_slice_args :: (Protocol a, Transport t) => a t -> IO Multiget_slice_args

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_slice_args_fields :: (Protocol a, Transport t) => a t -> Multiget_slice_args -> IO Multiget_slice_args

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_slice_result :: (Protocol a, Transport t) => a t -> IO Multiget_slice_result

+ Database.Cassandra.Thrift.Cassandra: read_Multiget_slice_result_fields :: (Protocol a, Transport t) => a t -> Multiget_slice_result -> IO Multiget_slice_result

+ Database.Cassandra.Thrift.Cassandra: read_Remove_args :: (Protocol a, Transport t) => a t -> IO Remove_args

+ Database.Cassandra.Thrift.Cassandra: read_Remove_args_fields :: (Protocol a, Transport t) => a t -> Remove_args -> IO Remove_args

+ Database.Cassandra.Thrift.Cassandra: read_Remove_counter_args :: (Protocol a, Transport t) => a t -> IO Remove_counter_args

+ Database.Cassandra.Thrift.Cassandra: read_Remove_counter_args_fields :: (Protocol a, Transport t) => a t -> Remove_counter_args -> IO Remove_counter_args

+ Database.Cassandra.Thrift.Cassandra: read_Remove_counter_result :: (Protocol a, Transport t) => a t -> IO Remove_counter_result

+ Database.Cassandra.Thrift.Cassandra: read_Remove_counter_result_fields :: (Protocol a, Transport t) => a t -> Remove_counter_result -> IO Remove_counter_result

+ Database.Cassandra.Thrift.Cassandra: read_Remove_result :: (Protocol a, Transport t) => a t -> IO Remove_result

+ Database.Cassandra.Thrift.Cassandra: read_Remove_result_fields :: (Protocol a, Transport t) => a t -> Remove_result -> IO Remove_result

+ Database.Cassandra.Thrift.Cassandra: read_Set_keyspace_args :: (Protocol a, Transport t) => a t -> IO Set_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_Set_keyspace_args_fields :: (Protocol a, Transport t) => a t -> Set_keyspace_args -> IO Set_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_Set_keyspace_result :: (Protocol a, Transport t) => a t -> IO Set_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_Set_keyspace_result_fields :: (Protocol a, Transport t) => a t -> Set_keyspace_result -> IO Set_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_System_add_column_family_args :: (Protocol a, Transport t) => a t -> IO System_add_column_family_args

+ Database.Cassandra.Thrift.Cassandra: read_System_add_column_family_args_fields :: (Protocol a, Transport t) => a t -> System_add_column_family_args -> IO System_add_column_family_args

+ Database.Cassandra.Thrift.Cassandra: read_System_add_column_family_result :: (Protocol a, Transport t) => a t -> IO System_add_column_family_result

+ Database.Cassandra.Thrift.Cassandra: read_System_add_column_family_result_fields :: (Protocol a, Transport t) => a t -> System_add_column_family_result -> IO System_add_column_family_result

+ Database.Cassandra.Thrift.Cassandra: read_System_add_keyspace_args :: (Protocol a, Transport t) => a t -> IO System_add_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_System_add_keyspace_args_fields :: (Protocol a, Transport t) => a t -> System_add_keyspace_args -> IO System_add_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_System_add_keyspace_result :: (Protocol a, Transport t) => a t -> IO System_add_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_System_add_keyspace_result_fields :: (Protocol a, Transport t) => a t -> System_add_keyspace_result -> IO System_add_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_column_family_args :: (Protocol a, Transport t) => a t -> IO System_drop_column_family_args

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_column_family_args_fields :: (Protocol a, Transport t) => a t -> System_drop_column_family_args -> IO System_drop_column_family_args

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_column_family_result :: (Protocol a, Transport t) => a t -> IO System_drop_column_family_result

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_column_family_result_fields :: (Protocol a, Transport t) => a t -> System_drop_column_family_result -> IO System_drop_column_family_result

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_keyspace_args :: (Protocol a, Transport t) => a t -> IO System_drop_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_keyspace_args_fields :: (Protocol a, Transport t) => a t -> System_drop_keyspace_args -> IO System_drop_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_keyspace_result :: (Protocol a, Transport t) => a t -> IO System_drop_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_System_drop_keyspace_result_fields :: (Protocol a, Transport t) => a t -> System_drop_keyspace_result -> IO System_drop_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_System_update_column_family_args :: (Protocol a, Transport t) => a t -> IO System_update_column_family_args

+ Database.Cassandra.Thrift.Cassandra: read_System_update_column_family_args_fields :: (Protocol a, Transport t) => a t -> System_update_column_family_args -> IO System_update_column_family_args

+ Database.Cassandra.Thrift.Cassandra: read_System_update_column_family_result :: (Protocol a, Transport t) => a t -> IO System_update_column_family_result

+ Database.Cassandra.Thrift.Cassandra: read_System_update_column_family_result_fields :: (Protocol a, Transport t) => a t -> System_update_column_family_result -> IO System_update_column_family_result

+ Database.Cassandra.Thrift.Cassandra: read_System_update_keyspace_args :: (Protocol a, Transport t) => a t -> IO System_update_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_System_update_keyspace_args_fields :: (Protocol a, Transport t) => a t -> System_update_keyspace_args -> IO System_update_keyspace_args

+ Database.Cassandra.Thrift.Cassandra: read_System_update_keyspace_result :: (Protocol a, Transport t) => a t -> IO System_update_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_System_update_keyspace_result_fields :: (Protocol a, Transport t) => a t -> System_update_keyspace_result -> IO System_update_keyspace_result

+ Database.Cassandra.Thrift.Cassandra: read_Truncate_args :: (Protocol a, Transport t) => a t -> IO Truncate_args

+ Database.Cassandra.Thrift.Cassandra: read_Truncate_args_fields :: (Protocol a, Transport t) => a t -> Truncate_args -> IO Truncate_args

+ Database.Cassandra.Thrift.Cassandra: read_Truncate_result :: (Protocol a, Transport t) => a t -> IO Truncate_result

+ Database.Cassandra.Thrift.Cassandra: read_Truncate_result_fields :: (Protocol a, Transport t) => a t -> Truncate_result -> IO Truncate_result

+ Database.Cassandra.Thrift.Cassandra: write_Add_args :: (Protocol a, Transport t) => a t -> Add_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Add_result :: (Protocol a, Transport t) => a t -> Add_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Batch_mutate_args :: (Protocol a, Transport t) => a t -> Batch_mutate_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Batch_mutate_result :: (Protocol a, Transport t) => a t -> Batch_mutate_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_cluster_name_args :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_cluster_name_result :: (Protocol a, Transport t) => a t -> Describe_cluster_name_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_keyspace_args :: (Protocol a, Transport t) => a t -> Describe_keyspace_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_keyspace_result :: (Protocol a, Transport t) => a t -> Describe_keyspace_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_keyspaces_args :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_keyspaces_result :: (Protocol a, Transport t) => a t -> Describe_keyspaces_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_partitioner_args :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_partitioner_result :: (Protocol a, Transport t) => a t -> Describe_partitioner_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_ring_args :: (Protocol a, Transport t) => a t -> Describe_ring_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_ring_result :: (Protocol a, Transport t) => a t -> Describe_ring_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_schema_versions_args :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_schema_versions_result :: (Protocol a, Transport t) => a t -> Describe_schema_versions_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_snitch_args :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_snitch_result :: (Protocol a, Transport t) => a t -> Describe_snitch_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_splits_args :: (Protocol a, Transport t) => a t -> Describe_splits_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_splits_result :: (Protocol a, Transport t) => a t -> Describe_splits_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_version_args :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Describe_version_result :: (Protocol a, Transport t) => a t -> Describe_version_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Execute_cql_query_args :: (Protocol a, Transport t) => a t -> Execute_cql_query_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Execute_cql_query_result :: (Protocol a, Transport t) => a t -> Execute_cql_query_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_args :: (Protocol a, Transport t) => a t -> Get_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_count_args :: (Protocol a, Transport t) => a t -> Get_count_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_count_result :: (Protocol a, Transport t) => a t -> Get_count_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_indexed_slices_args :: (Protocol a, Transport t) => a t -> Get_indexed_slices_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_indexed_slices_result :: (Protocol a, Transport t) => a t -> Get_indexed_slices_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_range_slices_args :: (Protocol a, Transport t) => a t -> Get_range_slices_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_range_slices_result :: (Protocol a, Transport t) => a t -> Get_range_slices_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_result :: (Protocol a, Transport t) => a t -> Get_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_slice_args :: (Protocol a, Transport t) => a t -> Get_slice_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Get_slice_result :: (Protocol a, Transport t) => a t -> Get_slice_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Insert_args :: (Protocol a, Transport t) => a t -> Insert_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Insert_result :: (Protocol a, Transport t) => a t -> Insert_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Login_args :: (Protocol a, Transport t) => a t -> Login_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Login_result :: (Protocol a, Transport t) => a t -> Login_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Multiget_count_args :: (Protocol a, Transport t) => a t -> Multiget_count_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Multiget_count_result :: (Protocol a, Transport t) => a t -> Multiget_count_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Multiget_slice_args :: (Protocol a, Transport t) => a t -> Multiget_slice_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Multiget_slice_result :: (Protocol a, Transport t) => a t -> Multiget_slice_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Remove_args :: (Protocol a, Transport t) => a t -> Remove_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Remove_counter_args :: (Protocol a, Transport t) => a t -> Remove_counter_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Remove_counter_result :: (Protocol a, Transport t) => a t -> Remove_counter_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Remove_result :: (Protocol a, Transport t) => a t -> Remove_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Set_keyspace_args :: (Protocol a, Transport t) => a t -> Set_keyspace_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Set_keyspace_result :: (Protocol a, Transport t) => a t -> Set_keyspace_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_add_column_family_args :: (Protocol a, Transport t) => a t -> System_add_column_family_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_add_column_family_result :: (Protocol a, Transport t) => a t -> System_add_column_family_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_add_keyspace_args :: (Protocol a, Transport t) => a t -> System_add_keyspace_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_add_keyspace_result :: (Protocol a, Transport t) => a t -> System_add_keyspace_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_drop_column_family_args :: (Protocol a, Transport t) => a t -> System_drop_column_family_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_drop_column_family_result :: (Protocol a, Transport t) => a t -> System_drop_column_family_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_drop_keyspace_args :: (Protocol a, Transport t) => a t -> System_drop_keyspace_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_drop_keyspace_result :: (Protocol a, Transport t) => a t -> System_drop_keyspace_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_update_column_family_args :: (Protocol a, Transport t) => a t -> System_update_column_family_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_update_column_family_result :: (Protocol a, Transport t) => a t -> System_update_column_family_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_update_keyspace_args :: (Protocol a, Transport t) => a t -> System_update_keyspace_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_System_update_keyspace_result :: (Protocol a, Transport t) => a t -> System_update_keyspace_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Truncate_args :: (Protocol a, Transport t) => a t -> Truncate_args -> IO ()

+ Database.Cassandra.Thrift.Cassandra: write_Truncate_result :: (Protocol a, Transport t) => a t -> Truncate_result -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: read_AuthenticationException :: (Protocol a, Transport t) => a t -> IO AuthenticationException

+ Database.Cassandra.Thrift.Cassandra_Types: read_AuthenticationException_fields :: (Protocol a, Transport t) => a t -> AuthenticationException -> IO AuthenticationException

+ Database.Cassandra.Thrift.Cassandra_Types: read_AuthenticationRequest :: (Protocol a, Transport t) => a t -> IO AuthenticationRequest

+ Database.Cassandra.Thrift.Cassandra_Types: read_AuthenticationRequest_fields :: (Protocol a, Transport t) => a t -> AuthenticationRequest -> IO AuthenticationRequest

+ Database.Cassandra.Thrift.Cassandra_Types: read_AuthorizationException :: (Protocol a, Transport t) => a t -> IO AuthorizationException

+ Database.Cassandra.Thrift.Cassandra_Types: read_AuthorizationException_fields :: (Protocol a, Transport t) => a t -> AuthorizationException -> IO AuthorizationException

+ Database.Cassandra.Thrift.Cassandra_Types: read_CfDef :: (Protocol a, Transport t) => a t -> IO CfDef

+ Database.Cassandra.Thrift.Cassandra_Types: read_CfDef_fields :: (Protocol a, Transport t) => a t -> CfDef -> IO CfDef

+ Database.Cassandra.Thrift.Cassandra_Types: read_Column :: (Protocol a, Transport t) => a t -> IO Column

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnDef :: (Protocol a, Transport t) => a t -> IO ColumnDef

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnDef_fields :: (Protocol a, Transport t) => a t -> ColumnDef -> IO ColumnDef

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnOrSuperColumn :: (Protocol a, Transport t) => a t -> IO ColumnOrSuperColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnOrSuperColumn_fields :: (Protocol a, Transport t) => a t -> ColumnOrSuperColumn -> IO ColumnOrSuperColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnParent :: (Protocol a, Transport t) => a t -> IO ColumnParent

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnParent_fields :: (Protocol a, Transport t) => a t -> ColumnParent -> IO ColumnParent

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnPath :: (Protocol a, Transport t) => a t -> IO ColumnPath

+ Database.Cassandra.Thrift.Cassandra_Types: read_ColumnPath_fields :: (Protocol a, Transport t) => a t -> ColumnPath -> IO ColumnPath

+ Database.Cassandra.Thrift.Cassandra_Types: read_Column_fields :: (Protocol a, Transport t) => a t -> Column -> IO Column

+ Database.Cassandra.Thrift.Cassandra_Types: read_CounterColumn :: (Protocol a, Transport t) => a t -> IO CounterColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_CounterColumn_fields :: (Protocol a, Transport t) => a t -> CounterColumn -> IO CounterColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_CounterSuperColumn :: (Protocol a, Transport t) => a t -> IO CounterSuperColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_CounterSuperColumn_fields :: (Protocol a, Transport t) => a t -> CounterSuperColumn -> IO CounterSuperColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_CqlResult :: (Protocol a, Transport t) => a t -> IO CqlResult

+ Database.Cassandra.Thrift.Cassandra_Types: read_CqlResult_fields :: (Protocol a, Transport t) => a t -> CqlResult -> IO CqlResult

+ Database.Cassandra.Thrift.Cassandra_Types: read_CqlRow :: (Protocol a, Transport t) => a t -> IO CqlRow

+ Database.Cassandra.Thrift.Cassandra_Types: read_CqlRow_fields :: (Protocol a, Transport t) => a t -> CqlRow -> IO CqlRow

+ Database.Cassandra.Thrift.Cassandra_Types: read_Deletion :: (Protocol a, Transport t) => a t -> IO Deletion

+ Database.Cassandra.Thrift.Cassandra_Types: read_Deletion_fields :: (Protocol a, Transport t) => a t -> Deletion -> IO Deletion

+ Database.Cassandra.Thrift.Cassandra_Types: read_IndexClause :: (Protocol a, Transport t) => a t -> IO IndexClause

+ Database.Cassandra.Thrift.Cassandra_Types: read_IndexClause_fields :: (Protocol a, Transport t) => a t -> IndexClause -> IO IndexClause

+ Database.Cassandra.Thrift.Cassandra_Types: read_IndexExpression :: (Protocol a, Transport t) => a t -> IO IndexExpression

+ Database.Cassandra.Thrift.Cassandra_Types: read_IndexExpression_fields :: (Protocol a, Transport t) => a t -> IndexExpression -> IO IndexExpression

+ Database.Cassandra.Thrift.Cassandra_Types: read_InvalidRequestException :: (Protocol a, Transport t) => a t -> IO InvalidRequestException

+ Database.Cassandra.Thrift.Cassandra_Types: read_InvalidRequestException_fields :: (Protocol a, Transport t) => a t -> InvalidRequestException -> IO InvalidRequestException

+ Database.Cassandra.Thrift.Cassandra_Types: read_KeyCount :: (Protocol a, Transport t) => a t -> IO KeyCount

+ Database.Cassandra.Thrift.Cassandra_Types: read_KeyCount_fields :: (Protocol a, Transport t) => a t -> KeyCount -> IO KeyCount

+ Database.Cassandra.Thrift.Cassandra_Types: read_KeyRange :: (Protocol a, Transport t) => a t -> IO KeyRange

+ Database.Cassandra.Thrift.Cassandra_Types: read_KeyRange_fields :: (Protocol a, Transport t) => a t -> KeyRange -> IO KeyRange

+ Database.Cassandra.Thrift.Cassandra_Types: read_KeySlice :: (Protocol a, Transport t) => a t -> IO KeySlice

+ Database.Cassandra.Thrift.Cassandra_Types: read_KeySlice_fields :: (Protocol a, Transport t) => a t -> KeySlice -> IO KeySlice

+ Database.Cassandra.Thrift.Cassandra_Types: read_KsDef :: (Protocol a, Transport t) => a t -> IO KsDef

+ Database.Cassandra.Thrift.Cassandra_Types: read_KsDef_fields :: (Protocol a, Transport t) => a t -> KsDef -> IO KsDef

+ Database.Cassandra.Thrift.Cassandra_Types: read_Mutation :: (Protocol a, Transport t) => a t -> IO Mutation

+ Database.Cassandra.Thrift.Cassandra_Types: read_Mutation_fields :: (Protocol a, Transport t) => a t -> Mutation -> IO Mutation

+ Database.Cassandra.Thrift.Cassandra_Types: read_NotFoundException :: (Protocol a, Transport t) => a t -> IO NotFoundException

+ Database.Cassandra.Thrift.Cassandra_Types: read_NotFoundException_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra_Types: read_SchemaDisagreementException :: (Protocol a, Transport t) => a t -> IO SchemaDisagreementException

+ Database.Cassandra.Thrift.Cassandra_Types: read_SchemaDisagreementException_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra_Types: read_SlicePredicate :: (Protocol a, Transport t) => a t -> IO SlicePredicate

+ Database.Cassandra.Thrift.Cassandra_Types: read_SlicePredicate_fields :: (Protocol a, Transport t) => a t -> SlicePredicate -> IO SlicePredicate

+ Database.Cassandra.Thrift.Cassandra_Types: read_SliceRange :: (Protocol a, Transport t) => a t -> IO SliceRange

+ Database.Cassandra.Thrift.Cassandra_Types: read_SliceRange_fields :: (Protocol a, Transport t) => a t -> SliceRange -> IO SliceRange

+ Database.Cassandra.Thrift.Cassandra_Types: read_SuperColumn :: (Protocol a, Transport t) => a t -> IO SuperColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_SuperColumn_fields :: (Protocol a, Transport t) => a t -> SuperColumn -> IO SuperColumn

+ Database.Cassandra.Thrift.Cassandra_Types: read_TimedOutException :: (Protocol a, Transport t) => a t -> IO TimedOutException

+ Database.Cassandra.Thrift.Cassandra_Types: read_TimedOutException_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra_Types: read_TokenRange :: (Protocol a, Transport t) => a t -> IO TokenRange

+ Database.Cassandra.Thrift.Cassandra_Types: read_TokenRange_fields :: (Protocol a, Transport t) => a t -> TokenRange -> IO TokenRange

+ Database.Cassandra.Thrift.Cassandra_Types: read_UnavailableException :: (Protocol a, Transport t) => a t -> IO UnavailableException

+ Database.Cassandra.Thrift.Cassandra_Types: read_UnavailableException_fields :: (Protocol a, Transport t) => a t -> b -> IO b

+ Database.Cassandra.Thrift.Cassandra_Types: write_AuthenticationException :: (Protocol a, Transport t) => a t -> AuthenticationException -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_AuthenticationRequest :: (Protocol a, Transport t) => a t -> AuthenticationRequest -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_AuthorizationException :: (Protocol a, Transport t) => a t -> AuthorizationException -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_CfDef :: (Protocol a, Transport t) => a t -> CfDef -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_Column :: (Protocol a, Transport t) => a t -> Column -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_ColumnDef :: (Protocol a, Transport t) => a t -> ColumnDef -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_ColumnOrSuperColumn :: (Protocol a, Transport t) => a t -> ColumnOrSuperColumn -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_ColumnParent :: (Protocol a, Transport t) => a t -> ColumnParent -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_ColumnPath :: (Protocol a, Transport t) => a t -> ColumnPath -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_CounterColumn :: (Protocol a, Transport t) => a t -> CounterColumn -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_CounterSuperColumn :: (Protocol a, Transport t) => a t -> CounterSuperColumn -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_CqlResult :: (Protocol a, Transport t) => a t -> CqlResult -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_CqlRow :: (Protocol a, Transport t) => a t -> CqlRow -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_Deletion :: (Protocol a, Transport t) => a t -> Deletion -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_IndexClause :: (Protocol a, Transport t) => a t -> IndexClause -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_IndexExpression :: (Protocol a, Transport t) => a t -> IndexExpression -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_InvalidRequestException :: (Protocol a, Transport t) => a t -> InvalidRequestException -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_KeyCount :: (Protocol a, Transport t) => a t -> KeyCount -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_KeyRange :: (Protocol a, Transport t) => a t -> KeyRange -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_KeySlice :: (Protocol a, Transport t) => a t -> KeySlice -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_KsDef :: (Protocol a, Transport t) => a t -> KsDef -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_Mutation :: (Protocol a, Transport t) => a t -> Mutation -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_NotFoundException :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_SchemaDisagreementException :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_SlicePredicate :: (Protocol a, Transport t) => a t -> SlicePredicate -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_SliceRange :: (Protocol a, Transport t) => a t -> SliceRange -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_SuperColumn :: (Protocol a, Transport t) => a t -> SuperColumn -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_TimedOutException :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_TokenRange :: (Protocol a, Transport t) => a t -> TokenRange -> IO ()

+ Database.Cassandra.Thrift.Cassandra_Types: write_UnavailableException :: (Protocol a, Transport t1) => a t1 -> t -> IO ()

Files

cassandra-thrift.cabal +3/−3

cassandra-thrift.cabal view

@@ -1,5 +1,5 @@ Name: cassandra-thrift -Version: 0.8.5+Version: 0.8.5.1 License: OtherLicense  License-File: LICENSE Cabal-version: >= 1.4@@ -8,7 +8,7 @@ Stability: alpha Synopsis: thrift bindings to the cassandra database  Description:-  The Cassandra (v.0.8.5) database bindings, generated using the Thrift (v.0.6.0) compliler, Released under the Apache 2.0 license. +  The Cassandra (v.0.8.5) database bindings, generated using the Thrift (v.0.6.*) compliler, Released under the Apache 2.0 license.       Category: Database  Build-type: Simple@@ -22,5 +22,5 @@      build-depends:   base >= 4.2.0.0 && < 4.9,                       containers,-                     Thrift == 0.6.0,+                     Thrift >= 0.6 && < 0.7,                      bytestring