use crate::cassandra::collection::Set;
use crate::cassandra::data_type::ConstDataType;
use crate::cassandra::error::*;
use crate::cassandra::inet::Inet;
use crate::cassandra::tuple::Tuple;
use crate::cassandra::util::Protected;
use crate::cassandra::uuid::Uuid;
use crate::cassandra_sys::cass_false;
use crate::cassandra_sys::cass_true;
use crate::cassandra_sys::cass_user_type_data_type;
use crate::cassandra_sys::cass_user_type_free;
use crate::cassandra_sys::cass_user_type_set_bool;
use crate::cassandra_sys::cass_user_type_set_bool_by_name;
use crate::cassandra_sys::cass_user_type_set_bytes;
use crate::cassandra_sys::cass_user_type_set_bytes_by_name;
use crate::cassandra_sys::cass_user_type_set_collection;
use crate::cassandra_sys::cass_user_type_set_collection_by_name;
use crate::cassandra_sys::cass_user_type_set_decimal;
use crate::cassandra_sys::cass_user_type_set_decimal_by_name;
use crate::cassandra_sys::cass_user_type_set_double;
use crate::cassandra_sys::cass_user_type_set_double_by_name;
use crate::cassandra_sys::cass_user_type_set_float;
use crate::cassandra_sys::cass_user_type_set_float_by_name;
use crate::cassandra_sys::cass_user_type_set_inet;
use crate::cassandra_sys::cass_user_type_set_inet_by_name;
use crate::cassandra_sys::cass_user_type_set_int16;
use crate::cassandra_sys::cass_user_type_set_int16_by_name;
use crate::cassandra_sys::cass_user_type_set_int32;
use crate::cassandra_sys::cass_user_type_set_int32_by_name;
use crate::cassandra_sys::cass_user_type_set_int64;
use crate::cassandra_sys::cass_user_type_set_int64_by_name;
use crate::cassandra_sys::cass_user_type_set_int8;
use crate::cassandra_sys::cass_user_type_set_int8_by_name;
use crate::cassandra_sys::cass_user_type_set_null;
use crate::cassandra_sys::cass_user_type_set_null_by_name;
use crate::cassandra_sys::cass_user_type_set_string;
use crate::cassandra_sys::cass_user_type_set_string_by_name;
use crate::cassandra_sys::cass_user_type_set_tuple;
use crate::cassandra_sys::cass_user_type_set_tuple_by_name;
use crate::cassandra_sys::cass_user_type_set_uint32;
use crate::cassandra_sys::cass_user_type_set_uint32_by_name;
use crate::cassandra_sys::cass_user_type_set_user_type;
use crate::cassandra_sys::cass_user_type_set_user_type_by_name;
use crate::cassandra_sys::cass_user_type_set_uuid;
use crate::cassandra_sys::cass_user_type_set_uuid_by_name;
use crate::cassandra_sys::CassUserType as _UserType;
use std::ffi::CString;
#[derive(Debug)]
pub struct UserType(*mut _UserType);
unsafe impl Send for UserType {}
impl Protected<*mut _UserType> for UserType {
fn inner(&self) -> *mut _UserType {
self.0
}
fn build(inner: *mut _UserType) -> Self {
if inner.is_null() {
panic!("Unexpected null pointer")
};
UserType(inner)
}
}
impl Drop for UserType {
fn drop(&mut self) {
unsafe { cass_user_type_free(self.0) }
}
}
impl UserType {
pub fn data_type(&self) -> ConstDataType {
unsafe { ConstDataType::build(cass_user_type_data_type(self.0)) }
}
pub fn set_null(&mut self, index: usize) -> Result<&mut Self> {
unsafe { cass_user_type_set_null(self.0, index).to_result(self) }
}
pub fn set_null_by_name<S>(&mut self, name: S) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name_cstr = CString::new(name.into())?;
cass_user_type_set_null_by_name(self.0, name_cstr.as_ptr()).to_result(self)
}
}
pub fn set_int8(&mut self, index: usize, value: i8) -> Result<&mut Self> {
unsafe { cass_user_type_set_int8(self.0, index, value).to_result(self) }
}
pub fn set_int8_by_name<S>(&mut self, name: S, value: i8) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_int8_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_int16(&mut self, index: usize, value: i16) -> Result<&mut Self> {
unsafe { cass_user_type_set_int16(self.0, index, value).to_result(self) }
}
pub fn set_int16_by_name<S>(&mut self, name: S, value: i16) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_int16_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_int32(&mut self, index: usize, value: i32) -> Result<&mut Self> {
unsafe { cass_user_type_set_int32(self.0, index, value).to_result(self) }
}
pub fn set_int32_by_name<S>(&mut self, name: S, value: i32) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_int32_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_uint32(&mut self, index: usize, value: u32) -> Result<&mut Self> {
unsafe { cass_user_type_set_uint32(self.0, index, value).to_result(self) }
}
pub fn set_uint32_by_name<S>(&mut self, name: S, value: u32) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_uint32_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_int64(&mut self, index: usize, value: i64) -> Result<&mut Self> {
unsafe { cass_user_type_set_int64(self.0, index, value).to_result(self) }
}
pub fn set_int64_by_name<S>(&mut self, name: S, value: i64) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_int64_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_float(&mut self, index: usize, value: f32) -> Result<&mut Self> {
unsafe { cass_user_type_set_float(self.0, index, value).to_result(self) }
}
pub fn set_float_by_name<S>(&mut self, name: S, value: f32) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_float_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_double(&mut self, index: usize, value: f64) -> Result<&mut Self> {
unsafe { cass_user_type_set_double(self.0, index, value).to_result(self) }
}
pub fn set_double_by_name<S>(&mut self, name: S, value: f64) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_double_by_name(self.0, name.as_ptr(), value).to_result(self)
}
}
pub fn set_bool(&mut self, index: usize, value: bool) -> Result<&mut Self> {
unsafe {
cass_user_type_set_bool(self.0, index, if value { cass_true } else { cass_false })
.to_result(self)
}
}
pub fn set_bool_by_name<S>(&mut self, name: S, value: bool) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_bool_by_name(
self.0,
name.as_ptr(),
if value { cass_true } else { cass_false },
)
.to_result(self)
}
}
pub fn set_stringl<S>(&mut self, index: usize, value: S) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let value = CString::new(value.into())?;
cass_user_type_set_string(self.0, index, value.as_ptr()).to_result(self)
}
}
pub fn set_string_by_name<S>(&mut self, name: S, value: S) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
let value = CString::new(value.into())?;
cass_user_type_set_string_by_name(self.0, name.as_ptr(), value.as_ptr()).to_result(self)
}
}
pub fn set_bytes(&mut self, index: usize, value: Vec<u8>) -> Result<&mut Self> {
unsafe {
cass_user_type_set_bytes(self.0, index, value.as_ptr(), value.len()).to_result(self)
}
}
pub fn set_bytes_by_name<S>(&mut self, name: S, value: Vec<u8>) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_bytes_by_name(self.0, name.as_ptr(), value.as_ptr(), value.len())
.to_result(self)
}
}
pub fn set_uuid<S>(&mut self, index: usize, value: S) -> Result<&mut Self>
where
S: Into<Uuid>,
{
unsafe { cass_user_type_set_uuid(self.0, index, value.into().inner()).to_result(self) }
}
pub fn set_uuid_by_name<S, U>(&mut self, name: S, value: U) -> Result<&mut Self>
where
S: Into<String>,
U: Into<Uuid>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_uuid_by_name(self.0, name.as_ptr(), value.into().inner())
.to_result(self)
}
}
pub fn set_inet<S>(&mut self, index: usize, value: S) -> Result<&mut Self>
where
S: Into<Inet>,
{
unsafe { cass_user_type_set_inet(self.0, index, value.into().inner()).to_result(self) }
}
pub fn set_inet_by_name<S, U>(&mut self, name: S, value: U) -> Result<&mut Self>
where
S: Into<String>,
U: Into<Inet>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_inet_by_name(self.0, name.as_ptr(), value.into().inner())
.to_result(self)
}
}
pub fn set_collection<S>(&mut self, index: usize, value: S) -> Result<&mut Self>
where
S: Into<Set>,
{
unsafe {
cass_user_type_set_collection(self.0, index, value.into().inner()).to_result(self)
}
}
pub fn set_collection_by_name<S>(&mut self, name: S, value: Set) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_collection_by_name(self.0, name.as_ptr(), value.inner())
.to_result(self)
}
}
pub fn set_tuple(&mut self, index: usize, value: Tuple) -> Result<&mut Self> {
unsafe { cass_user_type_set_tuple(self.0, index, value.inner()).to_result(self) }
}
pub fn set_tuple_by_name<S>(&mut self, name: S, value: Tuple) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_tuple_by_name(self.0, name.as_ptr(), value.inner()).to_result(self)
}
}
pub fn set_user_type(&mut self, index: usize, value: UserType) -> Result<&mut Self> {
unsafe { cass_user_type_set_user_type(self.0, index, value.0).to_result(self) }
}
pub fn set_user_type_by_name<S>(&mut self, name: S, value: UserType) -> Result<&mut Self>
where
S: Into<String>,
{
unsafe {
let name = CString::new(name.into())?;
cass_user_type_set_user_type_by_name(self.0, name.as_ptr(), value.0).to_result(self)
}
}
}