Struct SimpleUploadOptions 

pub struct SimpleUploadOptions {
    pub chunk_size: usize,
    pub max_concurrency: usize,
    pub type: i32,
}

Options for simple upload methods

Use the builder pattern to customize upload behavior:

Example

use baidu_netdisk_sdk::upload::SimpleUploadOptions;

let options = SimpleUploadOptions::default()
    .chunk_size(8 * 1024 * 1024)  // 8MB chunks
    .max_concurrency(20)         // 20 parallel uploads
    .r#type(1);                  // file type

Default Values

• chunk_size: 4MB (4194304 bytes)
• max_concurrency: 10
• r#type: 1

Fields

chunk_size: usize

Size of each chunk in bytes (default: 4MB)

max_concurrency: usize

Maximum number of parallel chunk uploads (default: 10)

type: i32

File type hint (default: 1)

Implementations

impl SimpleUploadOptions

pub fn new() -> Self

pub fn chunk_size(self, size: usize) -> Self

Examples found in repository

examples/upload_file_options.rs (line 38)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!(
            "Usage: {} <local_file> <remote_path> [chunk_size] [concurrency]",
            args[0]
        );
        println!("Example: {} test.mp4 /upload/video.mp4 8388608 20", args[0]);
        println!("  - chunk_size: bytes per chunk (default: 4194304 = 4MB)");
        println!("  - concurrency: parallel uploads (default: 10)");
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    let chunk_size: usize = args
        .get(3)
        .and_then(|s| s.parse().ok())
        .unwrap_or(4 * 1024 * 1024);
    let concurrency: usize = args.get(4).and_then(|s| s.parse().ok()).unwrap_or(10);

    let options = SimpleUploadOptions::default()
        .chunk_size(chunk_size)
        .max_concurrency(concurrency);

    println!("=== Baidu NetDisk File Upload (Custom Options) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!(
        "Chunk size: {} bytes ({:.2} MB)",
        chunk_size,
        chunk_size as f64 / 1024.0 / 1024.0
    );
    println!("Concurrency: {}", concurrency);
    println!();

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_file_with_options(local_file, remote_path, options)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub fn max_concurrency(self, concurrency: usize) -> Self

Examples found in repository

examples/upload_file_options.rs (line 39)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!(
            "Usage: {} <local_file> <remote_path> [chunk_size] [concurrency]",
            args[0]
        );
        println!("Example: {} test.mp4 /upload/video.mp4 8388608 20", args[0]);
        println!("  - chunk_size: bytes per chunk (default: 4194304 = 4MB)");
        println!("  - concurrency: parallel uploads (default: 10)");
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    let chunk_size: usize = args
        .get(3)
        .and_then(|s| s.parse().ok())
        .unwrap_or(4 * 1024 * 1024);
    let concurrency: usize = args.get(4).and_then(|s| s.parse().ok()).unwrap_or(10);

    let options = SimpleUploadOptions::default()
        .chunk_size(chunk_size)
        .max_concurrency(concurrency);

    println!("=== Baidu NetDisk File Upload (Custom Options) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!(
        "Chunk size: {} bytes ({:.2} MB)",
        chunk_size,
        chunk_size as f64 / 1024.0 / 1024.0
    );
    println!("Concurrency: {}", concurrency);
    println!();

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_file_with_options(local_file, remote_path, options)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub fn type(self, type: i32) -> Self

Trait Implementations

impl Clone for SimpleUploadOptions

fn clone(&self) -> SimpleUploadOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SimpleUploadOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SimpleUploadOptions

fn default() -> Self

Returns the “default value” for a type.