use crate::cassandra::data_type::ConstDataType;
use crate::cassandra::data_type::DataType;
use crate::cassandra::error::*;
use crate::cassandra::inet::Inet;
use crate::cassandra::tuple::Tuple;
use crate::cassandra::user_type::UserType;
use crate::cassandra::util::Protected;
use crate::cassandra::uuid::Uuid;
use crate::cassandra_sys::cass_collection_append_bool;
use crate::cassandra_sys::cass_collection_append_bytes;
use crate::cassandra_sys::cass_collection_append_collection;
use crate::cassandra_sys::cass_collection_append_decimal;
use crate::cassandra_sys::cass_collection_append_double;
use crate::cassandra_sys::cass_collection_append_float;
use crate::cassandra_sys::cass_collection_append_inet;
use crate::cassandra_sys::cass_collection_append_int16;
use crate::cassandra_sys::cass_collection_append_int32;
use crate::cassandra_sys::cass_collection_append_int64;
use crate::cassandra_sys::cass_collection_append_int8;
use crate::cassandra_sys::cass_collection_append_string;
use crate::cassandra_sys::cass_collection_append_tuple;
use crate::cassandra_sys::cass_collection_append_uint32;
use crate::cassandra_sys::cass_collection_append_user_type;
use crate::cassandra_sys::cass_collection_append_uuid;
use crate::cassandra_sys::cass_collection_data_type;
use crate::cassandra_sys::cass_collection_free;
use crate::cassandra_sys::cass_collection_new;
use crate::cassandra_sys::cass_collection_new_from_data_type;
use crate::cassandra_sys::cass_false;
use crate::cassandra_sys::cass_true;
use crate::cassandra_sys::CassCollection as _CassCollection;
use crate::cassandra_sys::CASS_COLLECTION_TYPE_LIST;
use crate::cassandra_sys::CASS_COLLECTION_TYPE_MAP;
use crate::cassandra_sys::CASS_COLLECTION_TYPE_SET;
use std::ffi::CString;
pub trait CassCollection {
type Value;
fn new(item_count: usize) -> Self;
fn new_from_data_type(value: DataType, item_count: usize) -> Self;
fn data_type(&self) -> ConstDataType;
fn append_int8(&mut self, value: i8) -> Result<&mut Self>;
fn append_int16(&mut self, value: i16) -> Result<&mut Self>;
fn append_int32(&mut self, value: i32) -> Result<&mut Self>;
fn append_uint32(&mut self, value: u32) -> Result<&mut Self>;
fn append_int64(&mut self, value: i64) -> Result<&mut Self>;
fn append_float(&mut self, value: f32) -> Result<&mut Self>;
fn append_double(&mut self, value: f64) -> Result<&mut Self>;
fn append_bool(&mut self, value: bool) -> Result<&mut Self>;
fn append_string(&mut self, value: &str) -> Result<&mut Self>;
fn append_bytes(&mut self, value: Vec<u8>) -> Result<&mut Self>;
fn append_uuid(&mut self, value: Uuid) -> Result<&mut Self>;
fn append_inet(&mut self, value: Inet) -> Result<&mut Self>;
fn append_list(&mut self, value: List) -> Result<&mut Self>;
fn append_set(&mut self, value: Set) -> Result<&mut Self>;
fn append_map(&mut self, value: Map) -> Result<&mut Self>;
fn append_tuple(&mut self, value: Tuple) -> Result<&mut Self>;
fn append_user_type(&mut self, value: &UserType) -> Result<&mut Self>;
}
#[derive(Debug)]
pub struct List(*mut _CassCollection);
unsafe impl Send for List {}
impl Protected<*mut _CassCollection> for List {
fn inner(&self) -> *mut _CassCollection {
self.0
}
fn build(inner: *mut _CassCollection) -> Self {
if inner.is_null() {
panic!("Unexpected null pointer")
};
List(inner)
}
}
impl Protected<*mut _CassCollection> for Map {
fn inner(&self) -> *mut _CassCollection {
self.0
}
fn build(inner: *mut _CassCollection) -> Self {
if inner.is_null() {
panic!("Unexpected null pointer")
};
Map(inner)
}
}
impl Protected<*mut _CassCollection> for Set {
fn inner(&self) -> *mut _CassCollection {
self.0
}
fn build(inner: *mut _CassCollection) -> Self {
if inner.is_null() {
panic!("Unexpected null pointer")
};
Set(inner)
}
}
impl Drop for List {
fn drop(&mut self) {
unsafe { cass_collection_free(self.0) }
}
}
impl CassCollection for List {
type Value = _CassCollection;
fn new(item_count: usize) -> Self {
unsafe { List::build(cass_collection_new(CASS_COLLECTION_TYPE_LIST, item_count)) }
}
fn new_from_data_type(value: DataType, item_count: usize) -> Self {
unsafe {
List(cass_collection_new_from_data_type(
value.inner(),
item_count,
))
}
}
fn data_type(&self) -> ConstDataType {
unsafe { ConstDataType::build(cass_collection_data_type(self.inner())) }
}
fn append_int8(&mut self, value: i8) -> Result<&mut Self> {
unsafe { cass_collection_append_int8(self.inner(), value).to_result(self) }
}
fn append_int16(&mut self, value: i16) -> Result<&mut Self> {
unsafe { cass_collection_append_int16(self.inner(), value).to_result(self) }
}
fn append_int32(&mut self, value: i32) -> Result<&mut Self> {
unsafe { cass_collection_append_int32(self.inner(), value).to_result(self) }
}
fn append_uint32(&mut self, value: u32) -> Result<&mut Self> {
unsafe { cass_collection_append_uint32(self.inner(), value).to_result(self) }
}
fn append_int64(&mut self, value: i64) -> Result<&mut Self> {
unsafe { cass_collection_append_int64(self.inner(), value).to_result(self) }
}
fn append_float(&mut self, value: f32) -> Result<&mut Self> {
unsafe { cass_collection_append_float(self.inner(), value).to_result(self) }
}
fn append_double(&mut self, value: f64) -> Result<&mut Self> {
unsafe { cass_collection_append_double(self.inner(), value).to_result(self) }
}
fn append_bool(&mut self, value: bool) -> Result<&mut Self> {
unsafe {
cass_collection_append_bool(self.inner(), if value { cass_true } else { cass_false })
.to_result(self)
}
}
fn append_string(&mut self, value: &str) -> Result<&mut Self> {
unsafe {
let cstr = CString::new(value)?;
let result = cass_collection_append_string(self.inner(), cstr.as_ptr());
result.to_result(self)
}
}
fn append_bytes(&mut self, value: Vec<u8>) -> Result<&mut Self> {
unsafe {
let bytes = cass_collection_append_bytes(self.inner(), value[..].as_ptr(), value.len());
bytes.to_result(self)
}
}
fn append_uuid(&mut self, value: Uuid) -> Result<&mut Self> {
unsafe { cass_collection_append_uuid(self.inner(), value.inner()).to_result(self) }
}
fn append_inet(&mut self, value: Inet) -> Result<&mut Self> {
unsafe { cass_collection_append_inet(self.inner(), value.inner()).to_result(self) }
}
fn append_list(&mut self, value: List) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_set(&mut self, value: Set) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_map(&mut self, value: Map) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_tuple(&mut self, value: Tuple) -> Result<&mut Self> {
unsafe { cass_collection_append_tuple(self.inner(), value.inner()).to_result(self) }
}
fn append_user_type(&mut self, value: &UserType) -> Result<&mut Self> {
unsafe { cass_collection_append_user_type(self.inner(), value.inner()).to_result(self) }
}
}
#[derive(Debug)]
pub struct Set(*mut _CassCollection);
unsafe impl Send for Set {}
impl Drop for Set {
fn drop(&mut self) {
unsafe { cass_collection_free(self.inner()) }
}
}
impl CassCollection for Set {
type Value = _CassCollection;
fn new(item_count: usize) -> Self {
unsafe { Set(cass_collection_new(CASS_COLLECTION_TYPE_SET, item_count)) }
}
fn new_from_data_type(value: DataType, item_count: usize) -> Self {
unsafe {
Set(cass_collection_new_from_data_type(
value.inner(),
item_count,
))
}
}
fn data_type(&self) -> ConstDataType {
unsafe { ConstDataType::build(cass_collection_data_type(self.inner())) }
}
fn append_int8(&mut self, value: i8) -> Result<&mut Self> {
unsafe { cass_collection_append_int8(self.inner(), value).to_result(self) }
}
fn append_int16(&mut self, value: i16) -> Result<&mut Self> {
unsafe { cass_collection_append_int16(self.inner(), value).to_result(self) }
}
fn append_int32(&mut self, value: i32) -> Result<&mut Self> {
unsafe { cass_collection_append_int32(self.inner(), value).to_result(self) }
}
fn append_uint32(&mut self, value: u32) -> Result<&mut Self> {
unsafe { cass_collection_append_uint32(self.inner(), value).to_result(self) }
}
fn append_int64(&mut self, value: i64) -> Result<&mut Self> {
unsafe { cass_collection_append_int64(self.inner(), value).to_result(self) }
}
fn append_float(&mut self, value: f32) -> Result<&mut Self> {
unsafe { cass_collection_append_float(self.inner(), value).to_result(self) }
}
fn append_double(&mut self, value: f64) -> Result<&mut Self> {
unsafe { cass_collection_append_double(self.inner(), value).to_result(self) }
}
fn append_bool(&mut self, value: bool) -> Result<&mut Self> {
unsafe {
cass_collection_append_bool(self.inner(), if value { cass_true } else { cass_false })
.to_result(self)
}
}
fn append_string(&mut self, value: &str) -> Result<&mut Self> {
unsafe {
let cstr = CString::new(value)?;
let result = cass_collection_append_string(self.inner(), cstr.as_ptr());
result.to_result(self)
}
}
fn append_bytes(&mut self, value: Vec<u8>) -> Result<&mut Self> {
unsafe {
let bytes = cass_collection_append_bytes(self.inner(), value[..].as_ptr(), value.len());
bytes.to_result(self)
}
}
fn append_uuid(&mut self, value: Uuid) -> Result<&mut Self> {
unsafe { cass_collection_append_uuid(self.inner(), value.inner()).to_result(self) }
}
fn append_inet(&mut self, value: Inet) -> Result<&mut Self> {
unsafe { cass_collection_append_inet(self.inner(), value.inner()).to_result(self) }
}
fn append_list(&mut self, value: List) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_set(&mut self, value: Set) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_map(&mut self, value: Map) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_tuple(&mut self, value: Tuple) -> Result<&mut Self> {
unsafe { cass_collection_append_tuple(self.inner(), value.inner()).to_result(self) }
}
fn append_user_type(&mut self, value: &UserType) -> Result<&mut Self> {
unsafe { cass_collection_append_user_type(self.inner(), value.inner()).to_result(self) }
}
}
#[derive(Debug)]
pub struct Map(*mut _CassCollection);
unsafe impl Send for Map {}
impl Drop for Map {
fn drop(&mut self) {
unsafe { cass_collection_free(self.0) }
}
}
impl CassCollection for Map {
type Value = _CassCollection;
fn new(item_count: usize) -> Self {
unsafe { Map(cass_collection_new(CASS_COLLECTION_TYPE_MAP, item_count)) }
}
fn new_from_data_type(value: DataType, item_count: usize) -> Self {
unsafe {
Map(cass_collection_new_from_data_type(
value.inner(),
item_count,
))
}
}
fn data_type(&self) -> ConstDataType {
unsafe { ConstDataType::build(cass_collection_data_type(self.inner())) }
}
fn append_int8(&mut self, value: i8) -> Result<&mut Self> {
unsafe { cass_collection_append_int8(self.inner(), value).to_result(self) }
}
fn append_int16(&mut self, value: i16) -> Result<&mut Self> {
unsafe { cass_collection_append_int16(self.inner(), value).to_result(self) }
}
fn append_int32(&mut self, value: i32) -> Result<&mut Self> {
unsafe { cass_collection_append_int32(self.inner(), value).to_result(self) }
}
fn append_uint32(&mut self, value: u32) -> Result<&mut Self> {
unsafe { cass_collection_append_uint32(self.inner(), value).to_result(self) }
}
fn append_int64(&mut self, value: i64) -> Result<&mut Self> {
unsafe { cass_collection_append_int64(self.inner(), value).to_result(self) }
}
fn append_float(&mut self, value: f32) -> Result<&mut Self> {
unsafe { cass_collection_append_float(self.inner(), value).to_result(self) }
}
fn append_double(&mut self, value: f64) -> Result<&mut Self> {
unsafe { cass_collection_append_double(self.inner(), value).to_result(self) }
}
fn append_bool(&mut self, value: bool) -> Result<&mut Self> {
unsafe {
cass_collection_append_bool(self.inner(), if value { cass_true } else { cass_false })
.to_result(self)
}
}
fn append_string(&mut self, value: &str) -> Result<&mut Self> {
unsafe {
let cstr = CString::new(value)?;
let result = cass_collection_append_string(self.inner(), cstr.as_ptr());
result.to_result(self)
}
}
fn append_bytes(&mut self, value: Vec<u8>) -> Result<&mut Self> {
unsafe {
let bytes = cass_collection_append_bytes(self.inner(), value[..].as_ptr(), value.len());
bytes.to_result(self)
}
}
fn append_uuid(&mut self, value: Uuid) -> Result<&mut Self> {
unsafe { cass_collection_append_uuid(self.inner(), value.inner()).to_result(self) }
}
fn append_inet(&mut self, value: Inet) -> Result<&mut Self> {
unsafe { cass_collection_append_inet(self.inner(), value.inner()).to_result(self) }
}
fn append_list(&mut self, value: List) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_set(&mut self, value: Set) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_map(&mut self, value: Map) -> Result<&mut Self> {
unsafe { cass_collection_append_collection(self.inner(), value.0).to_result(self) }
}
fn append_tuple(&mut self, value: Tuple) -> Result<&mut Self> {
unsafe { cass_collection_append_tuple(self.inner(), value.inner()).to_result(self) }
}
fn append_user_type(&mut self, value: &UserType) -> Result<&mut Self> {
unsafe { cass_collection_append_user_type(self.inner(), value.inner()).to_result(self) }
}
}