memcached-async 0.0.1

use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;

use crate::types::{Request, RequestMeta};

/// Per-request context passed to handlers.
#[derive(Debug, Clone)]
pub struct RequestContext {
    pub request: Request,
    pub meta: RequestMeta,
    pub peer_addr: SocketAddr,
    pub local_addr: SocketAddr,
    pub client_id: u64,
    pub extensions: Extensions,
}

/// Connection-level info for extension factories.
#[derive(Debug, Clone, Copy)]
pub struct ConnectionInfo {
    pub peer_addr: SocketAddr,
    pub local_addr: SocketAddr,
    pub client_id: u64,
}

/// Typed extensions map stored in the request context.
#[derive(Debug, Default, Clone)]
pub struct Extensions {
    inner: HashMap<TypeId, Arc<dyn Any + Send + Sync>>,
}

impl Extensions {
    pub fn insert<T: Send + Sync + 'static>(&mut self, value: T) {
        self.inner.insert(TypeId::of::<T>(), Arc::new(value));
    }

    pub fn get<T: Send + Sync + 'static>(&self) -> Option<&T> {
        self.inner
            .get(&TypeId::of::<T>())
            .and_then(|value| value.as_ref().downcast_ref::<T>())
    }

    /// Returns a mutable reference when this entry is uniquely owned.
    pub fn get_mut<T: Send + Sync + 'static>(&mut self) -> Option<&mut T> {
        self.inner
            .get_mut(&TypeId::of::<T>())
            .and_then(|value| Arc::get_mut(value))
            .and_then(|value| value.downcast_mut::<T>())
    }
}

/// Client id wrapper.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct ClientId(pub u64);

/// Peer address wrapper.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct PeerAddr(pub SocketAddr);

/// Local address wrapper.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct LocalAddr(pub SocketAddr);

/// Application state wrapper for extractors.
#[derive(Debug, Clone)]
pub struct State<T>(pub Arc<T>);