wedb_embed 0.1.1

/// 为 meta 结构体批量实现 MetaOps trait（仅需指定 tag）
macro_rules! impl_meta_ops {
    ($ty:ty, $tag:expr, $enc_ty:ty) => {
        impl $crate::meta::MetaOps for $ty {
            const TAG: &[u8] = $tag;
            type EncodedBytes = $enc_ty;

            #[inline]
            fn decode(bytes: &[u8]) -> Option<Self> {
                <$ty>::decode(bytes)
            }

            #[inline]
            fn is_expired(&self, now_ms: u64) -> bool {
                self.base.is_expired(now_ms)
            }

            #[inline]
            fn encode_bytes(&self) -> Self::EncodedBytes {
                self.encode()
            }

            #[inline]
            fn base(&self) -> &$crate::meta::KeyMeta {
                &self.base
            }

            #[inline]
            fn base_mut(&mut self) -> &mut $crate::meta::KeyMeta {
                &mut self.base
            }
        }
    };
    ($ty:ty, $tag:expr) => {
        impl_meta_ops!($ty, $tag, [u8; <$ty>::ENCODED_SIZE]);
    };
}

/// 为复合数据类型批量定义单 KeyMeta 封装结构体并实现对应方法及 MetaOps
macro_rules! define_simple_key_meta {
    ($meta_name:ident, $redis_type:ident, $tag:expr, $doc:expr) => {
        #[doc = $doc]
        #[derive(Debug, Clone, Copy, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
        pub struct $meta_name {
            pub base: $crate::meta::KeyMeta,
        }

        impl $meta_name {
            pub const ENCODED_SIZE: usize = $crate::meta::KeyMeta::ENCODED_SIZE;
            pub const KVROCKS_ENCODED_SIZE: usize =
                $crate::meta::KeyMeta::KVROCKS_COMPLEX_ENCODED_SIZE;

            #[inline]
            pub const fn new(expire_at: u64, version: u64, size: u64) -> Self {
                Self {
                    base: $crate::meta::KeyMeta::new(
                        $crate::meta::RedisType::$redis_type,
                        expire_at,
                        version,
                        size,
                    ),
                }
            }

            #[inline]
            pub fn new_with_version(expire_at: u64, size: u64) -> Self {
                Self {
                    base: $crate::meta::KeyMeta::new_with_version(
                        $crate::meta::RedisType::$redis_type,
                        expire_at,
                        size,
                    ),
                }
            }

            #[inline]
            pub const fn size(&self) -> u64 {
                self.base.size
            }

            #[inline]
            pub const fn version(&self) -> u64 {
                self.base.version
            }

            #[inline]
            pub const fn expire_at(&self) -> u64 {
                self.base.expire_at
            }

            #[inline]
            pub const fn ttl(&self, now_ms: u64) -> i64 {
                self.base.ttl(now_ms)
            }

            #[inline]
            pub const fn is_empty(&self) -> bool {
                self.base.size == 0
            }

            #[inline]
            pub const fn is_expired(&self, now_ms: u64) -> bool {
                self.base.is_expired(now_ms)
            }

            #[inline]
            pub fn encode(&self) -> [u8; Self::ENCODED_SIZE] {
                self.base.encode()
            }

            #[inline]
            pub fn encode_kvrocks(&self) -> Vec<u8> {
                self.base.encode_kvrocks()
            }

            #[inline]
            pub fn decode(bytes: &[u8]) -> Option<Self> {
                let base = $crate::meta::KeyMeta::decode(bytes)?;
                if base.rtype == $crate::meta::RedisType::$redis_type {
                    Some(Self { base })
                } else {
                    None
                }
            }
        }

        impl_meta_ops!($meta_name, $tag);
    };
}