Struct StringEncrypt 

pub struct StringEncrypt { /* private fields */ }

Stateful HTTP client: pass the activation key to the constructor, configure other options via setters, then StringEncrypt::send.

POST field code (activation key) is the value given at construction (empty string = demo).

For Command::ENCRYPT with compression enabled (StringEncrypt::set_compression), the API may return source as base64-encoded gzip of the decryptor text. StringEncrypt::send decodes that automatically so source is always plain text on success unless you call StringEncrypt::set_decompress_encrypt_source with false.

Implementations

impl StringEncrypt

pub fn new(api_key: impl Into<String>, prefer_curl: bool) -> Self

Create a client. api_key is sent as code (empty = demo). prefer_curl is ignored; kept for parity with the PHP SDK.

Examples found in repository

examples/encrypt_simple.rs (line 19)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode

    let result = string_encrypt
        .encrypt_string("Hello!", "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt.rs (line 19)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/is_demo.rs (line 19)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("", false); // leave empty for demo mode

    let result = string_encrypt.is_demo().await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.demo.unwrap_or(false) {
        println!("DEMO mode");
    } else {
        println!("FULL mode");
        println!("Credits left: {}", result.credits_left.unwrap_or(0));
    }

    println!("Label max length: {}", result.label_limit.unwrap_or(0));
    println!("String max length: {}", result.string_limit.unwrap_or(0));
    println!("Bytes max length: {}", result.bytes_limit.unwrap_or(0));
    println!(
        "cmd_min / cmd_max: {} / {}",
        result.cmd_min.unwrap_or(0),
        result.cmd_max.unwrap_or(0)
    );
}

examples/encrypt_file.rs (line 21)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn demo() -> Self

Same as new("", false) for demo mode checks.

pub fn prefer_curl(&self) -> bool

pub fn set_prefer_curl(&mut self, prefer_curl: bool) -> &mut Self

pub fn decompress_encrypt_source(&self) -> bool

pub fn set_decompress_encrypt_source(&mut self, decompress: bool) -> &mut Self

Disable automatic gzip+base64 decoding of source for encrypt+compression responses if you need the raw payload from the API.

pub fn command(&self) -> Option<&str>

pub fn set_command(&mut self, command: &str) -> &mut Self

pub fn label(&self) -> &str

pub fn set_label(&mut self, label: impl Into<String>) -> &mut Self

pub fn set_string(&mut self, string: impl Into<String>) -> &mut Self

UTF-8 text input; clears raw bytes input.

pub fn set_bytes(&mut self, bytes: impl Into<Vec<u8>>) -> &mut Self

Raw binary input; clears string input.

pub fn compression(&self) -> bool

pub fn set_compression(&mut self, compression: bool) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 21)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 23)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn language(&self) -> &str

pub fn set_language(&mut self, language: &str) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 25)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 28)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn highlight_off(&self) -> bool

pub fn highlight_mode(&self) -> Option<&str>

pub fn set_highlight(&mut self, highlight: impl Into<HighlightArg>) -> &mut Self

false disables highlight; pass a mode string such as geshi / js when supported server-side.

pub fn cmd_min(&self) -> i32

pub fn set_cmd_min(&mut self, cmd_min: i32) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 26)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 29)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn cmd_max(&self) -> i32

pub fn set_cmd_max(&mut self, cmd_max: i32) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 27)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 30)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn local(&self) -> bool

pub fn set_local(&mut self, local: bool) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 28)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 31)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn unicode(&self) -> bool

pub fn set_unicode(&mut self, unicode: bool) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 22)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 24)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn lang_locale(&self) -> &str

pub fn set_lang_locale(&mut self, lang_locale: impl Into<String>) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 23)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 25)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn ansi_encoding(&self) -> &str

pub fn set_ansi_encoding( &mut self, ansi_encoding: impl Into<String>, ) -> &mut Self

Examples found in repository

examples/encrypt_file.rs (line 27)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn new_lines(&self) -> &str

pub fn set_new_lines(&mut self, new_lines: &str) -> &mut Self

Examples found in repository

examples/encrypt.rs (line 24)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt_file.rs (line 26)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub fn template(&self) -> Option<&str>

pub fn set_template(&mut self, template: Option<String>) -> &mut Self

pub fn return_template(&self) -> bool

pub fn set_return_template(&mut self, return_template: bool) -> &mut Self

pub fn include_tags(&self) -> bool

pub fn set_include_tags(&mut self, include_tags: bool) -> &mut Self

pub fn include_example(&self) -> bool

pub fn set_include_example(&mut self, include_example: bool) -> &mut Self

pub fn include_debug_comments(&self) -> bool

pub fn set_include_debug_comments( &mut self, include_debug_comments: bool, ) -> &mut Self

pub fn api_url(&self) -> &str

pub fn set_api_url(&mut self, url: impl Into<String>) -> &mut Self

pub fn reset(&mut self) -> &mut Self

Reset request fields to defaults (reuse the same client for another call).

pub async fn is_demo(&mut self) -> Option<ApiResponse>

Activation status and limits for the activation key passed to the constructor.

Examples found in repository

examples/is_demo.rs (line 21)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("", false); // leave empty for demo mode

    let result = string_encrypt.is_demo().await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.demo.unwrap_or(false) {
        println!("DEMO mode");
    } else {
        println!("FULL mode");
        println!("Credits left: {}", result.credits_left.unwrap_or(0));
    }

    println!("Label max length: {}", result.label_limit.unwrap_or(0));
    println!("String max length: {}", result.string_limit.unwrap_or(0));
    println!("Bytes max length: {}", result.bytes_limit.unwrap_or(0));
    println!(
        "cmd_min / cmd_max: {} / {}",
        result.cmd_min.unwrap_or(0),
        result.cmd_max.unwrap_or(0)
    );
}

pub async fn encrypt_file_contents( &mut self, file_path: impl AsRef<Path>, label: &str, ) -> Option<ApiResponse>

Encrypt raw file contents (binary). Uses other encrypt options already set on this client.

Examples found in repository

examples/encrypt_file.rs (line 39)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_ansi_encoding("WINDOWS-1250")
        .set_language(Language::PHP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.push("examples");
    path.push("sample.bin");

    // Full license: raw bytes from file (demo may return ERROR_DEMO).
    let result = string_encrypt
        .encrypt_file_contents(&path, "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API or file is missing/empty.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub async fn encrypt_string( &mut self, string: &str, label: &str, ) -> Option<ApiResponse>

Encrypt a UTF-8 string. Uses other encrypt options already set on this client.

Examples found in repository

examples/encrypt_simple.rs (line 22)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode

    let result = string_encrypt
        .encrypt_string("Hello!", "$label")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

examples/encrypt.rs (line 31)

async fn main() {
    let mut string_encrypt = StringEncrypt::new("YOUR-API-KEY-HERE", false); // leave empty for demo mode
    string_encrypt
        .set_compression(false)
        .set_unicode(true)
        .set_lang_locale("en_US.utf8")
        .set_new_lines(NewLine::LF)
        .set_language(Language::CPP)
        .set_cmd_min(1)
        .set_cmd_max(3)
        .set_local(false);

    let result = string_encrypt
        .encrypt_string("Hello!", "wszLabel")
        .await;

    let Some(result) = result else {
        println!("Cannot connect to the API.");
        std::process::exit(1);
    };

    if result.error != Some(ErrorCode::SUCCESS as i64) {
        println!("API error: {:?}", result.error);
        std::process::exit(1);
    }

    println!("{}\n", result.source.unwrap_or_default());
}

pub async fn send(&mut self) -> Option<ApiResponse>

Send the request and return decoded JSON, or None on transport / JSON failure.