Enum Encoding 

pub enum Encoding {
    Utf8,
    Utf8Bom,
    Utf16Le,
    Utf16Be,
    Ascii,
    Latin1,
    Windows1252,
    Windows1250,
    Gb18030,
    Gbk,
    ShiftJis,
    EucKr,
}

Supported text encodings for file I/O

The editor internally uses UTF-8 for all text processing. When loading files, content is converted from the detected encoding to UTF-8. When saving, content is converted back to the original (or user-selected) encoding.

Variants

Utf8

UTF-8 (default, most common)

Utf8Bom

UTF-8 with Byte Order Mark

Utf16Le

UTF-16 Little Endian (Windows default for Unicode files)

Utf16Be

UTF-16 Big Endian

Ascii

ASCII (7-bit, subset of UTF-8)

Latin1

Latin-1 / ISO-8859-1 (Western European)

Windows1252

Windows-1252 / CP-1252 (Windows Western European, often called “ANSI”)

Windows1250

Windows-1250 / CP-1250 (Windows Central European)

Gb18030

GB18030 (Chinese, superset of GBK)

Gbk

GBK (Chinese Simplified, subset of GB18030)

ShiftJis

Shift-JIS (Japanese)

EucKr

EUC-KR (Korean)

Implementations

impl Encoding

pub fn display_name(&self) -> &'static str

Get the display name for status bar

pub fn description(&self) -> &'static str

Get a longer description for UI (e.g., command palette)

pub fn to_encoding_rs(&self) -> &'static Encoding

Get the encoding_rs Encoding for this type

pub fn has_bom(&self) -> bool

Returns true if this encoding uses a BOM (Byte Order Mark)

pub fn bom_bytes(&self) -> Option<&'static [u8]>

Get the BOM bytes for this encoding (if any)

pub fn all() -> &'static [Encoding]

All available encodings for UI display

pub fn is_resynchronizable(&self) -> bool

Returns true if this encoding supports “resynchronization” - the ability to find character boundaries when jumping into the middle of a file.

Resynchronizable encodings can be safely used with lazy/streaming file loading because you can determine character boundaries from any position.

• UTF-8: Excellent - unique bit patterns distinguish lead/continuation bytes
• ASCII/Latin-1/Windows-1252: Trivial - every byte is a character
• UTF-16: Good with 2-byte alignment - can detect surrogate pairs
• UTF-32: Good with 4-byte alignment

Non-resynchronizable encodings (legacy CJK like Shift-JIS, GB18030, GBK, Big5) have ambiguous byte sequences where a byte could be either a standalone character or part of a multi-byte sequence. You must scan from the beginning to be certain.

pub fn alignment(&self) -> Option<usize>

Returns the byte alignment required for this encoding when doing random access.

For lazy loading of large files, reads must be aligned to this boundary. Returns None if the encoding is not resynchronizable (requires full file scan).

pub fn requires_full_file_load(&self) -> bool

Returns true if this encoding requires the entire file to be loaded for correct decoding (cannot use lazy/streaming loading).

This is the inverse of is_resynchronizable() and indicates that the user should be warned before loading large files in this encoding.

Trait Implementations

impl Clone for Encoding

fn clone(&self) -> Encoding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Encoding

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

Formats the value using the given formatter.

impl Default for Encoding

fn default() -> Encoding

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Encoding

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Encoding

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Encoding

fn eq(&self, other: &Encoding) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Encoding

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Encoding

impl Eq for Encoding

impl StructuralPartialEq for Encoding