use serde::Deserialize;
 
// The Deserialize trait includes:
pub trait Deserialize<'de>: Sized {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>;
 
    // Optional: deserialize into existing value
    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
    where
        D: Deserializer<'de>,
    {
        // Default implementation: just overwrite with new value
        *place = Self::deserialize(deserializer)?;
        Ok(())
    }
}

use serde::Deserialize;
 
// Default implementation (what happens without custom impl):
// *place = Self::deserialize(deserializer)?;
 
// This still works, but doesn't save allocations
// The existing value is just overwritten with a new one
 
// Optimized implementation (what Vec does):
// 1. Clear existing elements (keep capacity)
// 2. Deserialize new elements directly into buffer
// 3. Only reallocate if new size exceeds capacity
 
#[derive(Debug)]
struct Container {
    items: Vec<i32>,
}
 
impl<'de> Deserialize<'de> for Container {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        // Regular deserialization
        let items = Vec::deserialize(deserializer)?;
        Ok(Container { items })
    }
}

use serde::Deserialize;
use serde_json;
 
fn main() {
    // Vec implements deserialize_in_place to reuse capacity
    let json_data = r#"[1, 2, 3, 4, 5]"#;
    
    // Create a Vec with some capacity
    let mut vec: Vec<i32> = Vec::with_capacity(100);
    println!("Capacity before: {}", vec.capacity());
    
    // First deserialize
    let mut deserializer = serde_json::Deserializer::from_str(json_data);
    Vec::<i32>::deserialize_in_place(&mut deserializer, &mut vec).unwrap();
    println!("After first: {:?}, capacity: {}", vec, vec.capacity());
    
    // Second deserialize - reuses capacity
    let json_data2 = r#"[10, 20, 30]"#;
    let mut deserializer2 = serde_json::Deserializer::from_str(json_data2);
    Vec::<i32>::deserialize_in_place(&mut deserializer2, &mut vec).unwrap();
    println!("After second: {:?}, capacity: {}", vec, vec.capacity());
}

use serde::Deserialize;
use serde_json;
 
fn main() {
    let mut buffer = String::with_capacity(100);
    println!("Capacity before: {}", buffer.capacity());
    
    // First deserialize
    let json = r#""hello world""#;
    let mut de = serde_json::Deserializer::from_str(json);
    String::deserialize_in_place(&mut de, &mut buffer).unwrap();
    println!("After first: '{}', capacity: {}", buffer, buffer.capacity());
    
    // Second deserialize - may reuse capacity
    let json2 = r#""new value""#;
    let mut de2 = serde_json::Deserializer::from_str(json2);
    String::deserialize_in_place(&mut de2, &mut buffer).unwrap();
    println!("After second: '{}', capacity: {}", buffer, buffer.capacity());
    
    // If new string fits in existing capacity, no reallocation
    // If new string is larger, reallocation occurs
}

use std::collections::HashMap;
use serde::Deserialize;
use serde_json;
 
fn main() {
    let mut map: HashMap<String, i32> = HashMap::with_capacity(100);
    println!("Capacity before: {}", map.capacity());
    
    // First deserialize
    let json = r#"{"a": 1, "b": 2, "c": 3}"#;
    let mut de = serde_json::Deserializer::from_str(json);
    HashMap::<String, i32>::deserialize_in_place(&mut de, &mut map).unwrap();
    println!("After first: {:?}, capacity: {}", map, map.capacity());
    
    // Second deserialize - clears and reuses
    let json2 = r#"{"x": 10, "y": 20}"#;
    let mut de2 = serde_json::Deserializer::from_str(json2);
    HashMap::<String, i32>::deserialize_in_place(&mut de2, &mut map).unwrap();
    println!("After second: {:?}, capacity: {}", map, map.capacity());
}

use serde::Deserialize;
use bincode;
 
fn main() {
    let mut buffer: Vec<u8> = Vec::with_capacity(100);
    
    // First deserialize
    let data: Vec<u32> = vec![1, 2, 3, 4, 5];
    let encoded = bincode::serialize(&data).unwrap();
    Vec::<u32>::deserialize_in_place(&mut bincode::Deserializer::from_slice(&encoded), &mut buffer).unwrap();
    println!("After first: {:?}", buffer);
    
    // Second deserialize - reuses buffer
    let data2: Vec<u32> = vec![10, 20];
    let encoded2 = bincode::serialize(&data2).unwrap();
    Vec::<u32>::deserialize_in_place(&mut bincode::Deserializer::from_slice(&encoded2), &mut buffer).unwrap();
    println!("After second: {:?}", buffer);
}

use serde::Deserialize;
use serde_json;
 
fn benchmark_regular() -> Vec<Vec<i32>> {
    // Regular deserialization - allocates each time
    let json_data = r#"[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"#;
    let mut results = Vec::new();
    
    for _ in 0..1000 {
        let de = serde_json::Deserializer::from_str(json_data);
        let data: Vec<Vec<i32>> = Vec::deserialize(de).unwrap();
        results.push(data);
    }
    
    results
}
 
fn benchmark_in_place() -> Vec<Vec<i32>> {
    // In-place deserialization - reuses allocation
    let json_data = r#"[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"#;
    let mut buffer: Vec<Vec<i32>> = Vec::new();
    let mut results = Vec::new();
    
    for _ in 0..1000 {
        let de = serde_json::Deserializer::from_str(json_data);
        Vec::<Vec<i32>>::deserialize_in_place(de, &mut buffer).unwrap();
        results.push(buffer.clone()); // Clone if you need to keep the data
    }
    
    results
}
 
fn main() {
    // In-place is faster when:
    // 1. Deserializing same structure repeatedly
    // 2. Deserialized size is similar each time
    // 3. You don't need to keep previous values
    
    // Measure to see the difference in your use case
}

use serde::Deserialize;
use serde_json;
 
// Scenario 1: Processing a stream of similar-sized messages
fn process_stream() {
    let mut buffer: Message = Message::default();
    
    for json_message in incoming_messages() {
        let de = serde_json::Deserializer::from_str(&json_message);
        Message::deserialize_in_place(de, &mut buffer).unwrap();
        process_message(&buffer);
    }
}
 
// Scenario 2: Repeatedly deserializing into same structure
fn process_config_updates() {
    let mut config: Config = Config::default();
    
    loop {
        let json = read_config_update();
        let de = serde_json::Deserializer::from_str(&json);
        Config::deserialize_in_place(de, &mut config).unwrap();
        apply_config(&config);
    }
}
 
#[derive(Debug, Default, Deserialize)]
struct Message {
    id: u32,
    data: Vec<String>,
}
 
#[derive(Debug, Default, Deserialize)]
struct Config {
    items: Vec<String>,
    settings: HashMap<String, String>,
}
 
fn incoming_messages() -> Vec<String> { vec![] }
fn process_message(_: &Message) {}
fn read_config_update() -> String { String::new() }
fn apply_config(_: &Config) {}
 
use std::collections::HashMap;

use serde::Deserialize;
use serde_json;
 
// Scenario: Deserialized size varies wildly
// In-place doesn't help much if capacity is constantly exceeded
 
fn process_variable_sizes() {
    let mut buffer: Vec<i32> = Vec::new();
    
    // Small message - fits in capacity
    let small = r#"[1, 2, 3]"#;
    Vec::<i32>::deserialize_in_place(
        &mut serde_json::Deserializer::from_str(small),
        &mut buffer
    ).unwrap();
    
    // Huge message - causes reallocation
    let huge = r#"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]"#;
    Vec::<i32>::deserialize_in_place(
        &mut serde_json::Deserializer::from_str(huge),
        &mut buffer
    ).unwrap();
    
    // Reallocation happened - in-place helped less
}
 
// Scenario: Need to keep multiple deserialized values
fn keep_all_values() {
    let mut buffer: Vec<i32> = Vec::new();
    let mut all_values: Vec<Vec<i32>> = Vec::new();
    
    for json in ["[1]", "[2]", "[3]"] {
        Vec::<i32>::deserialize_in_place(
            &mut serde_json::Deserializer::from_str(json),
            &mut buffer
        ).unwrap();
        // Must clone if you need to keep this value
        all_values.push(buffer.clone());
    }
    // Cloning defeats the purpose - just use regular deserialize
}

use serde::{Deserialize, Deserializer};
use std::collections::HashMap;
 
#[derive(Debug)]
struct Cache {
    entries: HashMap<String, String>,
}
 
impl<'de> Deserialize<'de> for Cache {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let entries = HashMap::deserialize(deserializer)?;
        Ok(Cache { entries })
    }
    
    // Implement in-place for HashMap reuse
    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
    where
        D: Deserializer<'de>,
    {
        // Clear existing entries but keep capacity
        place.entries.clear();
        
        // Deserialize directly into existing HashMap
        // Note: HashMap::deserialize_in_place handles this internally
        let new_entries: HashMap<String, String> = HashMap::deserialize(deserializer)?;
        place.entries = new_entries;
        
        // Better implementation would use HashMap::deserialize_in_place
        // But this shows the pattern
        Ok(())
    }
}
 
impl Default for Cache {
    fn default() -> Self {
        Cache {
            entries: HashMap::new(),
        }
    }
}

use serde::Deserialize;
use serde_json;
 
#[derive(Debug, Default)]
struct NestedContainer {
    outer: Vec<InnerItem>,
}
 
#[derive(Debug, Default, Deserialize)]
struct InnerItem {
    values: Vec<i32>,
}
 
// Vec<Vec<i32>> automatically benefits from nested in-place
fn nested_example() {
    let mut container: Vec<Vec<i32>> = Vec::new();
    
    let json = r#"[[1, 2, 3], [4, 5, 6]]"#;
    Vec::<Vec<i32>>::deserialize_in_place(
        &mut serde_json::Deserializer::from_str(json),
        &mut container
    ).unwrap();
    
    println!("{:?}", container);
    
    // Outer Vec and inner Vecs all reuse capacity
    let json2 = r#"[[7, 8], [9, 10, 11]]"#;
    Vec::<Vec<i32>>::deserialize_in_place(
        &mut serde_json::Deserializer::from_str(json2),
        &mut container
    ).unwrap();
    
    println!("{:?}", container);
}

use serde::Deserialize;
 
// Types without custom deserialize_in_place use the default
// Default: *place = Self::deserialize(deserializer)
 
#[derive(Debug, Deserialize)]
struct SimpleStruct {
    value: i32,
}
 
fn fallback_example() {
    let mut instance = SimpleStruct { value: 0 };
    
    // SimpleStruct doesn't implement deserialize_in_place
    // Uses default: overwrites with new value
    // No allocation savings since i32 is stack-allocated
    
    let json = r#"{"value": 42}"#;
    SimpleStruct::deserialize_in_place(
        &mut serde_json::Deserializer::from_str(json),
        &mut instance
    ).unwrap();
    
    println!("{:?}", instance);
}

// High benefit:
// - Vec<T>: Reuses buffer capacity
// - String: Reuses string buffer
// - HashMap<K, V>: Reuses bucket allocation
// - HashSet<T>: Reuses bucket allocation
// - VecDeque<T>: Reuses ring buffer
 
// Moderate benefit:
// - Structs containing the above types
 
// Low/No benefit:
// - i32, f64, bool: Stack-allocated, no heap reuse
// - Box<T>: Always allocates
// - Rc<T>, Arc<T>: Always allocates
// - Structs with only primitive fields
 
// Example of no-benefit type:
#[derive(Deserialize)]
struct Point {
    x: f64,
    y: f64,
}
// Point is stack-allocated, no memory to reuse
 
// Example of high-benefit type:
#[derive(Deserialize)]
struct MessageBuffer {
    data: Vec<u8>,      // Reuses buffer
    headers: Vec<Header>, // Reuses buffer
}

use serde::Deserialize;
 
// Zero-copy: Borrow from input (no allocation at all)
#[derive(Deserialize)]
struct BorrowedMessage<'a> {
    #[serde(borrow)]
    text: &'a str,  // Borrows from input
}
 
// In-place: Reuse existing allocation
struct OwnedMessage {
    text: String,  // Owns the data, but reuses buffer
}
 
// Zero-copy is better when:
// - Input lifetime exceeds usage
// - You don't need to modify the data
// - Input is already in memory
 
// In-place is better when:
// - You need owned data (lifetime issues)
// - You need to modify after deserialization
// - You need to keep data after input is dropped

use serde::Deserialize;
use serde_json;
 
#[derive(Debug, Default, Deserialize)]
struct NetworkMessage {
    sequence: u64,
    payload: Vec<u8>,
    metadata: HashMap<String, String>,
}
 
struct MessageProcessor {
    // Reuse these buffers across messages
    buffer: NetworkMessage,
}
 
impl MessageProcessor {
    fn new() -> Self {
        Self {
            buffer: NetworkMessage {
                sequence: 0,
                payload: Vec::with_capacity(1024),
                metadata: HashMap::with_capacity(16),
            },
        }
    }
    
    fn process(&mut self, json: &str) -> Result<(), Box<dyn std::error::Error>> {
        // Clear and reuse internal buffers
        self.buffer.payload.clear();
        self.buffer.metadata.clear();
        
        // Deserialize in-place
        NetworkMessage::deserialize_in_place(
            &mut serde_json::Deserializer::from_str(json),
            &mut self.buffer
        )?;
        
        // Process the message
        println!("Sequence: {}, Payload len: {}, Metadata: {:?}", 
                 self.buffer.sequence,
                 self.buffer.payload.len(),
                 self.buffer.metadata);
        
        Ok(())
    }
}
 
fn main() {
    let mut processor = MessageProcessor::new();
    
    let messages = [
        r#"{"sequence": 1, "payload": [1,2,3], "metadata": {"type": "data"}}"#,
        r#"{"sequence": 2, "payload": [4,5,6,7,8], "metadata": {"type": "more"}}"#,
    ];
    
    for msg in messages {
        processor.process(msg).unwrap();
    }
}

use serde::Deserialize;
use std::collections::HashMap;
use std::fs;
 
#[derive(Debug, Default, Deserialize)]
struct AppConfig {
    database_url: String,
    max_connections: u32,
    feature_flags: HashMap<String, bool>,
}
 
struct ConfigManager {
    config: AppConfig,
}
 
impl ConfigManager {
    fn new() -> Self {
        Self {
            config: AppConfig {
                database_url: String::with_capacity(256),
                max_connections: 0,
                feature_flags: HashMap::with_capacity(32),
            },
        }
    }
    
    fn reload(&mut self, path: &str) -> Result<(), Box<dyn std::error::Error>> {
        let content = fs::read_to_string(path)?;
        
        // Reuse config's internal allocations
        AppConfig::deserialize_in_place(
            &mut serde_json::Deserializer::from_str(&content),
            &mut self.config
        )?;
        
        println!("Config reloaded: {:?}", self.config);
        Ok(())
    }
    
    fn get(&self) -> &AppConfig {
        &self.config
    }
}
 
fn main() {
    let mut manager = ConfigManager::new();
    // manager.reload("config.json").unwrap();
}