use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("Hello, World!");
    
    // slice returns a new Bytes sharing the underlying buffer
    let slice = data.slice(0..5);
    println!("Slice: {:?}", slice);  // "Hello"
    
    // The original is still accessible
    println!("Original: {:?}", data);  // "Hello, World!"
    
    // Both share the same underlying memory
    // No copy was made
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("Hello, World!");
    
    // copy_to_bytes allocates new memory and copies data
    let copied = data.copy_to_bytes(5);
    println!("Copied: {:?}", copied);  // "Hello"
    
    // The original is modified! copy_to_bytes consumes from the front
    println!("Original after copy: {:?}", data);  // ", World!"
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("Hello, World!");
    
    // slice doesn't modify the original
    let s1 = data.slice(0..5);
    let s2 = data.slice(7..12);
    
    println!("Slice 1: {:?}", s1);  // "Hello"
    println!("Slice 2: {:?}", s2);  // "World"
    println!("Original: {:?}", data);  // Still "Hello, World!"
    
    // Multiple slices can coexist, all sharing the buffer
    let s3 = data.slice(2..10);
    println!("Slice 3: {:?}", s3);  // "llo, Wor"
}

use bytes::Bytes;
 
fn main() {
    let mut data = Bytes::from("Hello, World!");
    
    // copy_to_bytes takes ownership and advances the cursor
    let first = data.copy_to_bytes(5);
    println!("First: {:?}", first);  // "Hello"
    println!("Remaining: {:?}", data);  // ", World!"
    
    // Continue consuming
    data.advance(2);  // Skip ", "
    let second = data.copy_to_bytes(5);
    println!("Second: {:?}", second);  // "World"
    println!("Final: {:?}", data);  // "!"
    
    // This is useful for parsing protocols where you consume bytes
}

use bytes::Bytes;
 
fn main() {
    // Large buffer
    let data = Bytes::from(vec
![0u8; 1_000_000]);
    
    // Multiple slices share the same allocation
    let s1 = data.slice(0..100_000);
    let s2 = data.slice(100_000..200_000);
    let s3 = data.slice(500_000..600_000);
    
    // All share the same 1MB buffer
    // No additional allocation
    // Reference counting tracks usage
    
    println!("Slice 1 len: {}", s1.len());
    println!("Slice 2 len: {}", s2.len());
    println!("Slice 3 len: {}", s3.len());
    
    // Original buffer is freed only when all references are dropped
    drop(data);
    drop(s1);
    drop(s2);
    // s3 still keeps the buffer alive
    println!("Slice 3 still valid: {} bytes", s3.len());
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from(vec
![0u8; 1_000_000]);
    
    // copy_to_bytes creates independent allocation
    let copied = data.copy_to_bytes(100_000);
    
    // Original can be dropped without affecting copy
    drop(data);
    
    // Copied buffer is still valid
    println!("Copied len: {}", copied.len());
    
    // This costs allocation but provides independence
}

use bytes::Bytes;
 
fn main() {
    // Create a large buffer
    let original = Bytes::from(vec
![0u8; 10_000_000];
    
    // Take a tiny slice
    let tiny_slice = original.slice(0..10);
    
    // Problem: the entire 10MB buffer is retained!
    // Even though we only need 10 bytes
    drop(original);
    
    // tiny_slice still holds reference to the 10MB buffer
    println!("Tiny slice: {} bytes", tiny_slice.len());
    // But 10MB is still allocated
    
    // Solution: copy_to_bytes for small extractions
    let original2 = Bytes::from(vec
![0u8; 10_000_000];
    let tiny_copy = original2.slice(0..10).copy_to_bytes(10);
    
    drop(original2);
    // Now only the 10-byte copy is retained
    // The 10MB buffer is freed
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from("GET /index.html HTTP/1.1\r\nHost: example.com\r\n\r\n");
    
    // Parsing: extract method (slice, no copy needed)
    let method = data.slice(0..3);
    println!("Method: {:?}", method);  // "GET"
    
    // Extract path
    let path_start = 4;
    let path_end = 15;
    let path = data.slice(path_start..path_end);
    println!("Path: {:?}", path);  // "/index.html"
    
    // These slices share the buffer - zero allocation
    // Great for transient parsing where you don't need owned data
    
    // Use slice when:
    // 1. You need multiple views into the same buffer
    // 2. The slices are short-lived
    // 3. Memory efficiency is critical
    // 4. You're not crossing ownership boundaries
}

use bytes::Bytes;
use std::thread;
 
fn main() {
    let data = Bytes::from("HTTP response data...");
    
    // Scenario 1: Small extraction from large buffer
    let large = Bytes::from(vec
![0u8; 10_000_000];
    let header = large.slice(0..100).copy_to_bytes(100);
    drop(large);
    // Now we only hold 100 bytes, not 10MB
    
    // Scenario 2: Data needs to outlive the original
    let owned_copy = data.copy_to_bytes(data.len());
    // owned_copy is independent of data
    
    // Scenario 3: Sending to another thread
    let data = Bytes::from("shared data");
    let thread_data = data.copy_to_bytes(data.len());
    
    thread::spawn(move || {
        println!("Thread: {:?}", thread_data);
    });
    
    // data is still valid in main thread
    println!("Main: {:?}", data);
}

use bytes::Bytes;
 
fn parse_packet(data: &mut Bytes) -> (Bytes, Bytes, Bytes) {
    // copy_to_bytes consumes from the front - perfect for parsing
    let header = data.copy_to_bytes(4);   // Consume 4 bytes
    let length = u32::from_be_bytes(
        [header[0], header[1], header[2], header[3]]
    ) as usize;
    
    let payload = data.copy_to_bytes(length);  // Consume payload
    let remaining = data.clone();  // What's left
    
    (header, payload, remaining)
}
 
fn main() {
    let mut packet = Bytes::from(vec
![
        0x00, 0x00, 0x00, 0x05,  // Length: 5
        b'H', b'e', b'l', b'l', b'o',  // Payload
        b'E', b'x', b't', b'r', b'a',  // Remaining
    ]);
    
    let (header, payload, remaining) = parse_packet(&mut packet);
    
    println!("Header: {:?}", header);
    println!("Payload: {:?}", payload);
    println!("Remaining: {:?}", remaining);
}

use bytes::Bytes;
 
fn process_request(data: Bytes) -> Vec<Bytes> {
    let mut segments = Vec::new();
    let mut pos = 0;
    
    // Find all CRLF-delimited segments
    while pos < data.len() {
        // Use slice for zero-copy segmentation
        let remaining = data.slice(pos..);
        
        if let Some(end) = remaining.windows(2).position(|w| w == b"\r\n") {
            let segment = data.slice(pos..pos + end);
            segments.push(segment);
            pos += end + 2;
        } else {
            let segment = data.slice(pos..);
            segments.push(segment);
            break;
        }
    }
    
    segments
}
 
fn main() {
    let request = Bytes::from("GET / HTTP/1.1\r\nHost: example.com\r\n\r\n");
    
    // All segments share the same buffer - zero allocation
    let segments = process_request(request.clone());
    
    for (i, segment) in segments.iter().enumerate() {
        println!("Segment {}: {:?}", i, segment);
    }
    
    // Original buffer still alive
    println!("Original: {:?}", request);
}

use bytes::Bytes;
 
struct PacketProcessor {
    buffer: Bytes,
}
 
impl PacketProcessor {
    fn new(data: Bytes) -> Self {
        Self { buffer: data }
    }
    
    // Returns a slice that shares the buffer
    fn get_header(&self) -> Bytes {
        self.buffer.slice(0..4)
    }
    
    // Returns owned data independent of buffer
    fn extract_payload(&mut self, len: usize) -> Bytes {
        self.buffer.copy_to_bytes(len)
    }
    
    // Returns owned copy, releases original
    fn take_ownership(&self) -> Bytes {
        self.buffer.slice(..).copy_to_bytes(self.buffer.len())
    }
}
 
fn main() {
    let data = Bytes::from("header-payload-data");
    let mut processor = PacketProcessor::new(data);
    
    // Slice: shares buffer
    let header = processor.get_header();
    println!("Header: {:?}", header);
    
    // copy_to_bytes: independent
    let payload = processor.extract_payload(7);
    println!("Payload: {:?}", payload);
    
    // Take ownership: copy
    let owned = processor.take_ownership();
    println!("Owned: {:?}", owned);
}

use bytes::Bytes;
 
fn main() {
    let data = Bytes::from(vec
![0u8; 10_000_000];
    
    // slice: O(1) - just pointer arithmetic
    let start = std::time::Instant::now();
    for _ in 0..1000 {
        let _slice = data.slice(1000..2000);
    }
    let slice_time = start.elapsed();
    println!("slice (1000 iterations): {:?}", slice_time);
    
    // copy_to_bytes: O(n) - actual memory copy
    let start = std::time::Instant::now();
    for _ in 0..1000 {
        let _copy = data.slice(1000..2000).copy_to_bytes(1000);
    }
    let copy_time = start.elapsed();
    println!("copy_to_bytes (1000 iterations): {:?}", copy_time);
    
    // slice is faster but retains the buffer
    // copy_to_bytes is slower but creates independence
    
    // For small extractions from large buffers:
    // - slice: fast but retains large buffer
    // - copy_to_bytes: slower but releases large buffer
}

use bytes::{Bytes, BytesMut, Buf};
 
fn main() {
    let mut buf = BytesMut::with_capacity(1024);
    buf.extend_from_slice(b"Hello, World!");
    
    // split_to is like copy_to_bytes for BytesMut
    let part1 = buf.split_to(5);
    println!("Part 1: {:?}", part1);  // "Hello"
    println!("Remaining: {:?}", buf);  // ", World!"
    
    // split_to moves data into new BytesMut (zero-copy)
    // Unlike copy_to_bytes, it doesn't allocate
    
    // freeze() converts BytesMut to Bytes
    let bytes = buf.freeze();
    println!("Frozen: {:?}", bytes);  // ", World!"
    
    // Now you can slice or copy_to_bytes
    let slice = bytes.slice(0..6);
    println!("Slice: {:?}", slice);  // ", Worl"
}

use bytes::Bytes;
use std::thread;
 
fn main() {
    let data = Bytes::from(vec
![0u8; 1000];
    
    // slice: shares buffer, thread-safe via Arc
    let slice1 = data.slice(0..100);
    let slice2 = data.slice(100..200);
    
    let h1 = thread::spawn(move || {
        println!("Thread 1 slice len: {}", slice1.len());
    });
    
    let h2 = thread::spawn(move || {
        println!("Thread 2 slice len: {}", slice2.len());
    });
    
    h1.join().unwrap();
    h2.join().unwrap();
    
    // copy_to_bytes: independent, no sharing concerns
    let data2 = Bytes::from(vec
![0u8; 1000];
    let copy1 = data2.copy_to_bytes(100);
    let copy2 = data2.copy_to_bytes(100);
    
    // Each copy is independent, can be sent anywhere
    println!("Copy 1: {} bytes, Copy 2: {} bytes", copy1.len(), copy2.len());
}