Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Foundation
  - Donate
- Resources
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.encoding

Classes and functions for handling and transcoding between various encodings.
For cases where the encoding is known at compile-time, functions are provided for arbitrary encoding and decoding of characters, arbitrary transcoding between strings of different type, as well as validation and sanitization.
Encodings currently supported are UTF-8, UTF-16, UTF-32, ASCII, ISO-8859-1 (also known as LATIN-1), ISO-8859-2 (LATIN-2), WINDOWS-1250 and WINDOWS-1252.

- The type AsciiChar represents an ASCII character.
- The type AsciiString represents an ASCII string.
- The type Latin1Char represents an ISO-8859-1 character.
- The type Latin1String represents an ISO-8859-1 string.
- The type Latin2Char represents an ISO-8859-2 character.
- The type Latin2String represents an ISO-8859-2 string.
- The type Windows1250Char represents a Windows-1250 character.
- The type Windows1250String represents a Windows-1250 string.
- The type Windows1252Char represents a Windows-1252 character.
- The type Windows1252String represents a Windows-1252 string.

For cases where the encoding is not known at compile-time, but is known at run-time, we provide the abstract class EncodingScheme and its subclasses. To construct a run-time encoder/decoder, one does e.g.

        auto e = EncodingScheme.create("utf-8");

This library supplies EncodingScheme subclasses for ASCII, ISO-8859-1 (also known as LATIN-1), ISO-8859-2 (LATIN-2), WINDOWS-1250, WINDOWS-1252, UTF-8, and (on little-endian architectures) UTF-16LE and UTF-32LE; or (on big-endian architectures) UTF-16BE and UTF-32BE.
This library provides a mechanism whereby other modules may add EncodingScheme subclasses for any other encoding.
License:
Boost License 1.0.
Authors:
Janice Caron

Source: std/encoding.d

enum dchar `INVALID_SEQUENCE`;
  Special value returned by safeDecode
enum `AsciiChar`: ubyte;
alias `AsciiString` = immutable(AsciiChar)[];
  Defines various character sets.
enum `Latin1Char`: ubyte;
  Defines an Latin1-encoded character.
alias `Latin1String` = immutable(Latin1Char)[];
  Defines an Latin1-encoded string (as an array of immutable(Latin1Char)).
enum `Latin2Char`: ubyte;
  Defines a Latin2-encoded character.
alias `Latin2String` = immutable(Latin2Char)[];
  Defines an Latin2-encoded string (as an array of immutable(Latin2Char)).
enum `Windows1250Char`: ubyte;
  Defines a Windows1250-encoded character.
alias `Windows1250String` = immutable(Windows1250Char)[];
  Defines an Windows1250-encoded string (as an array of immutable(Windows1250Char)).
enum `Windows1252Char`: ubyte;
  Defines a Windows1252-encoded character.
alias `Windows1252String` = immutable(Windows1252Char)[];
  Defines an Windows1252-encoded string (as an array of immutable(Windows1252Char)).
pure nothrow @nogc @safe bool `isValidCodePoint`(dchar `c`);
  Returns `true` if `c` is a valid code point
  Note that this includes the non-character code points U+FFFE and U+FFFF, since these are valid code points (even though they are not valid characters).

  Supersedes: This function supersedes std.utf.startsValidDchar().

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  dchar `c` | the code point to be tested

@property string `encodingName`(T)();
  Returns the name of an encoding.
  The type of encoding cannot be deduced. Therefore, it is necessary to explicitly specify the encoding type.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Examples:

      assert(encodingName!(char) == "UTF-8");
      assert(encodingName!(wchar) == "UTF-16");
      assert(encodingName!(dchar) == "UTF-32");
      assert(encodingName!(AsciiChar) == "ASCII");
      assert(encodingName!(Latin1Char) == "ISO-8859-1");
      assert(encodingName!(Latin2Char) == "ISO-8859-2");
      assert(encodingName!(Windows1250Char) == "windows-1250");
      assert(encodingName!(Windows1252Char) == "windows-1252");

bool `canEncode`(E)(dchar `c`);
  Returns `true` iff it is possible to represent the specified codepoint in the encoding.
  The type of encoding cannot be deduced. Therefore, it is necessary to explicitly specify the encoding type.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Examples:

      assert( canEncode!(Latin1Char)('A'));
      assert( canEncode!(Latin2Char)('A'));
      assert(!canEncode!(AsciiChar)('\u00A0'));
      assert( canEncode!(Latin1Char)('\u00A0'));
      assert( canEncode!(Latin2Char)('\u00A0'));
      assert( canEncode!(Windows1250Char)('\u20AC'));
      assert(!canEncode!(Windows1250Char)('\u20AD'));
      assert(!canEncode!(Windows1250Char)('\uFFFD'));
      assert( canEncode!(Windows1252Char)('\u20AC'));
      assert(!canEncode!(Windows1252Char)('\u20AD'));
      assert(!canEncode!(Windows1252Char)('\uFFFD'));
      assert(!canEncode!(char)(cast(dchar)0x110000));

  Examples:
  How to check an entire string

      import std.algorithm.searching : find;
      import std.utf : byDchar;

      assert("The quick brown fox"
          .byDchar
          .find!(x => !canEncode!AsciiChar(x))
          .empty);

bool `isValidCodeUnit`(E)(E `c`);
  Returns `true` if the code unit is legal. For example, the byte 0x80 would not be legal in ASCII, because ASCII code units must always be in the range 0x00 to 0x7F.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  E `c` | the code unit to be tested

  Examples:

      assert(!isValidCodeUnit(cast(char)0xC0));
      assert(!isValidCodeUnit(cast(char)0xFF));
      assert( isValidCodeUnit(cast(wchar)0xD800));
      assert(!isValidCodeUnit(cast(dchar)0xD800));
      assert(!isValidCodeUnit(cast(AsciiChar)0xA0));
      assert( isValidCodeUnit(cast(Windows1250Char)0x80));
      assert(!isValidCodeUnit(cast(Windows1250Char)0x81));
      assert( isValidCodeUnit(cast(Windows1252Char)0x80));
      assert(!isValidCodeUnit(cast(Windows1252Char)0x81));

bool `isValid`(E)(const(E)[] `s`);
  Returns `true` if the string is encoded correctly

  Supersedes: This function supersedes std.utf.validate(), however note that this function returns a bool indicating whether the input was valid or not, whereas the older function would throw an exception.

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  const(E)[] `s` | the string to be tested

  Examples:

      assert( isValid("\u20AC100"));
      assert(!isValid(cast(char[3])[167, 133, 175]));

size_t `validLength`(E)(const(E)[] `s`);
  Returns the length of the longest possible substring, starting from the first code unit, which is validly encoded.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  const(E)[] `s` | the string to be tested

immutable(E)[] `sanitize`(E)(immutable(E)[] `s`);
  Sanitizes a string by replacing malformed code unit sequences with valid code unit sequences. The result is guaranteed to be valid for this encoding.
  If the input string is already valid, this function returns the original, otherwise it constructs a new string by replacing all illegal code unit sequences with the encoding'`s` replacement character, Invalid sequences will be replaced with the Unicode replacement character (U+FFFD) if the character repertoire contains it, otherwise invalid sequences will be replaced with '?'.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  immutable(E)[] `s` | the string to be sanitized

  Examples:

      assert(sanitize("hello \xF0\x80world") == "hello \xEF\xBF\xBDworld");

size_t `firstSequence`(E)(const(E)[] `s`);
  Returns the length of the first encoded sequence.
  The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  const(E)[] `s` | the string to be sliced

  Examples:

      assert(firstSequence("\u20AC1000") == "\u20AC".length);
      assert(firstSequence("hel") == "h".length);

size_t `lastSequence`(E)(const(E)[] `s`);
  Returns the length of the last encoded sequence.
  The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  const(E)[] `s` | the string to be sliced

  Examples:

      assert(lastSequence("1000\u20AC") == "\u20AC".length);
      assert(lastSequence("hellö") == "ö".length);

ptrdiff_t `index`(E)(const(E)[] `s`, int `n`);
  Returns the array `index` at which the (`n`+1)th code point begins.
  The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.

  Supersedes: This function supersedes std.utf.toUTFindex().

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  const(E)[] `s` | the string to be counted
  int `n` | the current code point `index`

  Examples:

      assert(index("\u20AC100",1) == 3);
      assert(index("hällo",2) == 3);

dchar `decode`(S)(ref S `s`);
  Decodes a single code point.
  This function removes one or more code units from the start of a string, and returns the decoded code point which those code units represent.
  The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.

  Supersedes: This function supersedes std.utf.`decode`(), however, note that the function codePoints() supersedes it more conveniently.

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  S `s` | the string whose first code point is to be decoded

dchar `decodeReverse`(E)(ref const(E)[] `s`);
  Decodes a single code point from the end of a string.
  This function removes one or more code units from the end of a string, and returns the decoded code point which those code units represent.
  The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  const(E)[] `s` | the string whose first code point is to be decoded

dchar `safeDecode`(S)(ref S `s`);
  Decodes a single code point. The input does not have to be valid.
  This function removes one or more code units from the start of a string, and returns the decoded code point which those code units represent.
  This function will accept an invalidly encoded string as input. If an invalid sequence is found at the start of the string, this function will remove it, and return the value INVALID_SEQUENCE.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  S `s` | the string whose first code point is to be decoded

size_t `encodedLength`(E)(dchar `c`);
  Returns the number of code units required to encode a single code point.
  The input to this function MUST be a valid code point. This is enforced by the function's in-contract.
  The type of the output cannot be deduced. Therefore, it is necessary to explicitly specify the encoding as a template parameter.
  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  dchar `c` | the code point to be encoded

E[] `encode`(E)(dchar `c`);
  Encodes a single code point.
  This function encodes a single code point into one or more code units. It returns a string containing those code units.
  The input to this function MUST be a valid code point. This is enforced by the function's in-contract.
  The type of the output cannot be deduced. Therefore, it is necessary to explicitly specify the encoding as a template parameter.

  Supersedes: This function supersedes std.utf.`encode`(), however, note that the function codeUnits() supersedes it more conveniently.

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  dchar `c` | the code point to be encoded

size_t `encode`(E)(dchar `c`, E[] `array`);
  Encodes a single code point into an `array`.
  This function encodes a single code point into one or more code units The code units are stored in a user-supplied fixed-size `array`, which must be passed by reference.
  The input to this function MUST be a valid code point. This is enforced by the function's in-contract.
  The type of the output cannot be deduced. Therefore, it is necessary to explicitly specify the encoding as a template parameter.

  Supersedes: This function supersedes std.utf.`encode`(), however, note that the function codeUnits() supersedes it more conveniently.

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  dchar `c` | the code point to be encoded
  E[] `array` | the destination `array`

  Returns:
  the number of code units written to the `array`
void `encode`(E)(dchar `c`, void delegate(E) `dg`);
  Encodes a single code point to a delegate.
  This function encodes a single code point into one or more code units. The code units are passed one at a time to the supplied delegate.
  The input to this function MUST be a valid code point. This is enforced by the function's in-contract.
  The type of the output cannot be deduced. Therefore, it is necessary to explicitly specify the encoding as a template parameter.

  Supersedes: This function supersedes std.utf.`encode`(), however, note that the function codeUnits() supersedes it more conveniently.

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  dchar `c` | the code point to be encoded
  void delegate(E) `dg` | the delegate to invoke for each code unit

size_t `encode`(Tgt, Src, R)(in Src[] `s`, R `range`);
  Encodes the contents of `s` in units of type Tgt, writing the result to an output `range`.
  Returns:
  The number of Tgt elements written.
  Parameters:

  Tgt | Element type of `range`.
  Src[] `s` | Input array.
  R `range` | Output `range`.

CodePoints!E `codePoints`(E)(immutable(E)[] `s`);
  Returns a foreachable struct which can bidirectionally iterate over all code points in a string.
  The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
  You can foreach either with or without an index. If an index is specified, it will be initialized at each iteration with the offset into the string at which the code point begins.

  Supersedes: This function supersedes std.utf.decode().

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  immutable(E)[] `s` | the string to be decoded

  Example:

      string s = "hello world";
      foreach (c;codePoints(s))
      {
          // do something with c (which will always be a dchar)
      }

  Note that, currently, foreach (c:`codePoints`(`s`)) is superior to foreach (c;`s`) in that the latter will fall over on encountering U+FFFF.
  Examples:

      string s = "hello";
      string t;
      foreach (c;codePoints(s))
      {
          t ~= cast(char)c;
      }
      assert(s == t);

CodeUnits!E `codeUnits`(E)(dchar `c`);
  Returns a foreachable struct which can bidirectionally iterate over all code units in a code point.
  The input to this function MUST be a valid code point. This is enforced by the function's in-contract.
  The type of the output cannot be deduced. Therefore, it is necessary to explicitly specify the encoding type in the template parameter.

  Supersedes: This function supersedes std.utf.encode().

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  dchar `c` | the code point to be encoded

  Examples:

      char[] a;
      foreach (c;codeUnits!(char)(cast(dchar)'\u20AC'))
      {
          a ~= c;
      }
      assert(a.length == 3);
      assert(a[0] == 0xE2);
      assert(a[1] == 0x82);
      assert(a[2] == 0xAC);

void `transcode`(Src, Dst)(Src[] `s`, out Dst[] `r`);
  Convert a string from one encoding to another.

  Supersedes: This function supersedes std.utf.toUTF8(), std.utf.toUTF16() and std.utf.toUTF32() (but note that to!() supersedes it more conveniently).

  Standards:
  Unicode 5.0, ASCII, ISO-8859-1, ISO-8859-2, WINDOWS-1250, WINDOWS-1252
  Parameters:

  Src[] `s` | Source string. Must be validly encoded. This is enforced by the function'`s` in-contract.
  Dst[] `r` | Destination string

  See Also:
  std.conv.to
  Examples:

      wstring ws;
      // transcode from UTF-8 to UTF-16
      transcode("hello world",ws);
      assert(ws == "hello world"w);

      Latin1String ls;
      // transcode from UTF-16 to ISO-8859-1
      transcode(ws, ls);
      assert(ws == "hello world");

class `EncodingException`: object.Exception;
  The base class for exceptions thrown by this module
abstract class `EncodingScheme`;
  Abstract base class of all encoding schemes
  void `register`(Klass : EncodingScheme)();
    Registers a subclass of EncodingScheme.
    This function allows user-defined subclasses of EncodingScheme to be declared in other modules.
    Parameters:

    Klass | The subclass of EncodingScheme to `register`.

    Example:

        class Amiga1251 : EncodingScheme
        {
            shared static this()
            {
                EncodingScheme.register!Amiga1251;
            }
        }

  static EncodingScheme `create`(string `encodingName`);
    Obtains a subclass of EncodingScheme which is capable of encoding and decoding the named encoding scheme.
    This function is only aware of EncodingSchemes which have been registered with the register() function.

    Example:

        auto scheme = EncodingScheme.create("Amiga-1251");

  abstract const string `toString`();
    Returns the standard name of the encoding scheme
  abstract const string[] `names`();
    Returns an array of all known `names` for this encoding scheme
  abstract const bool `canEncode`(dchar `c`);
    Returns `true` if the character `c` can be represented in this encoding scheme.
  abstract const size_t `encodedLength`(dchar `c`);
    Returns the number of ubytes required to encode this code point.
    The input to this function MUST be a valid code point.
    Parameters:

    dchar `c` | the code point to be encoded

    Returns:
    the number of ubytes required.
  abstract const size_t `encode`(dchar `c`, ubyte[] `buffer`);
    Encodes a single code point into a user-supplied, fixed-size `buffer`.
    This function encodes a single code point into one or more ubytes. The supplied `buffer` must be code unit aligned. (For example, UTF-16LE or UTF-16BE must be wchar-aligned, UTF-32LE or UTF-32BE must be dchar-aligned, etc.)
    The input to this function MUST be a valid code point.
    Parameters:

    dchar `c` | the code point to be encoded
    ubyte[] `buffer` | the destination array

    Returns:
    the number of ubytes written.
  abstract const dchar `decode`(ref const(ubyte)[] `s`);
    Decodes a single code point.
    This function removes one or more ubytes from the start of an array, and returns the decoded code point which those ubytes represent.
    The input to this function MUST be validly encoded.
    Parameters:

    const(ubyte)[] `s` | the array whose first code point is to be decoded

  abstract const dchar `safeDecode`(ref const(ubyte)[] `s`);
    Decodes a single code point. The input does not have to be valid.
    This function removes one or more ubytes from the start of an array, and returns the decoded code point which those ubytes represent.
    This function will accept an invalidly encoded array as input. If an invalid sequence is found at the start of the string, this function will remove it, and return the value INVALID_SEQUENCE.
    Parameters:

    const(ubyte)[] `s` | the array whose first code point is to be decoded

  abstract const @property immutable(ubyte)[] `replacementSequence`();
    Returns the sequence of ubytes to be used to represent any character which cannot be represented in the encoding scheme.
    Normally this will be a representation of some substitution character, such as U+FFFD or '?'.
  bool `isValid`(const(ubyte)[] `s`);
    Returns `true` if the array is encoded correctly
    Parameters:

    const(ubyte)[] `s` | the array to be tested

  size_t `validLength`()(const(ubyte)[] `s`);
    Returns the length of the longest possible substring, starting from the first element, which is validly encoded.
    Parameters:

    const(ubyte)[] `s` | the array to be tested

  immutable(ubyte)[] `sanitize`()(immutable(ubyte)[] `s`);
    Sanitizes an array by replacing malformed ubyte sequences with valid ubyte sequences. The result is guaranteed to be valid for this encoding scheme.
    If the input array is already valid, this function returns the original, otherwise it constructs a new array by replacing all illegal sequences with the encoding scheme'`s` replacement sequence.
    Parameters:

    immutable(ubyte)[] `s` | the string to be sanitized

  size_t `firstSequence`()(const(ubyte)[] `s`);
    Returns the length of the first encoded sequence.
    The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
    Parameters:

    const(ubyte)[] `s` | the array to be sliced

  size_t `count`()(const(ubyte)[] `s`);
    Returns the total number of code points encoded in a ubyte array.
    The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
    Parameters:

    const(ubyte)[] `s` | the string to be counted

  ptrdiff_t `index`()(const(ubyte)[] `s`, size_t `n`);
    Returns the array `index` at which the (`n`+1)th code point begins.
    The input to this function MUST be validly encoded. This is enforced by the function'`s` in-contract.
    Parameters:

    const(ubyte)[] `s` | the string to be counted
    size_t `n` | the current code point `index`

class `EncodingSchemeASCII`: std.encoding.EncodingScheme;
  EncodingScheme to handle ASCII
  This scheme recognises the following names: "ANSI_X3.4-1968", "ANSI_X3.4-1986", "ASCII", "IBM367", "ISO646-US", "ISO_646.irv:1991", "US-ASCII", "cp367", "csASCII" "iso-ir-6", "us"
class `EncodingSchemeLatin1`: std.encoding.EncodingScheme;
  EncodingScheme to handle Latin-1
  This scheme recognises the following names: "CP819", "IBM819", "ISO-8859-1", "ISO_8859-1", "ISO_8859-1:1987", "csISOLatin1", "iso-ir-100", "l1", "latin1"
class `EncodingSchemeLatin2`: std.encoding.EncodingScheme;
  EncodingScheme to handle Latin-2
  This scheme recognises the following names: "Latin 2", "ISO-8859-2", "ISO_8859-2", "ISO_8859-2:1999", "Windows-28592"
class `EncodingSchemeWindows1250`: std.encoding.EncodingScheme;
  EncodingScheme to handle Windows-1250
  This scheme recognises the following names: "windows-1250"
class `EncodingSchemeWindows1252`: std.encoding.EncodingScheme;
  EncodingScheme to handle Windows-1252
  This scheme recognises the following names: "windows-1252"
class `EncodingSchemeUtf8`: std.encoding.EncodingScheme;
  EncodingScheme to handle UTF-8
  This scheme recognises the following names: "UTF-8"
class `EncodingSchemeUtf16Native`: std.encoding.EncodingScheme;
  EncodingScheme to handle UTF-16 in native byte order
  This scheme recognises the following names: "UTF-16LE" (little-endian architecture only) "UTF-16BE" (big-endian architecture only)
class `EncodingSchemeUtf32Native`: std.encoding.EncodingScheme;
  EncodingScheme to handle UTF-32 in native byte order
  This scheme recognises the following names: "UTF-32LE" (little-endian architecture only) "UTF-32BE" (big-endian architecture only)
enum `BOM`: int;
  Definitions of common Byte Order Marks. The elements of the enum can used as indices into bomTable to get matching BOMSeq.
  `none`
    no BOM was found
  `utf32be`
    [0x00, 0x00, 0xFE, 0xFF]
  `utf32le`
    [0xFF, 0xFE, 0x00, 0x00]
  `utf1`
    [0xF7, 0x64, 0x4C]
  `utfebcdic`
    [0xDD, 0x73, 0x66, 0x73]
  `scsu`
    [0x0E, 0xFE, 0xFF]
  `bocu1`
    [0xFB, 0xEE, 0x28]
  `gb18030`
    [0x84, 0x31, 0x95, 0x33]
  `utf8`
    [0xEF, 0xBB, 0xBF]
  `utf16be`
    [0xFE, 0xFF]
  `utf16le`
    [0xFF, 0xFE]
alias `BOMSeq` = std.typecons.Tuple!(BOM, "schema", ubyte[], "sequence").Tuple;
  The type stored inside bomTable.
immutable Tuple!(BOM, "schema", ubyte[], "sequence")[] `bomTable`;
  Mapping of a byte sequence to Byte Order Mark (BOM)
immutable(BOMSeq) `getBOM`(Range)(Range `input`)
if (isForwardRange!Range && is(Unqual!(ElementType!Range) == ubyte));
  Returns a BOMSeq for a given `input`. If no BOM is present the BOMSeq for BOM.none is returned. The BOM sequence at the beginning of the range will not be comsumed from the passed range. If you pass a reference type range make sure that save creates a deep copy.
  Parameters:

  Range `input` | The sequence to check for the BOM

  Returns:
  the found BOMSeq corresponding to the passed `input`.
  Examples:

      import std.format : format;

      auto ts = dchar(0x0000FEFF) ~ "Hello World"d;

      auto entry = getBOM(cast(ubyte[])ts);
      version(BigEndian)
      {
          assert(entry.schema == BOM.utf32be, format("%s", entry.schema));
      }
      else
      {
          assert(entry.schema == BOM.utf32le, format("%s", entry.schema));
      }

enum dchar `utfBOM`;
  Constant defining a fully decoded BOM

Copyright Janice Caron 2008 - 2009. | Page generated by Ddoc on Thu Mar 9 17:49:40 2017