Global

class method Compact(dst: Memory<Buffer>; src: Slice<Byte>): error

static error Compact(Memory<Buffer> dst, Slice<Byte> src)

static func Compact(_ dst: Memory<Buffer>, _ src: Slice<Byte>) -> error

func Compact(dst Memory<Buffer>, src Slice<Byte>) error

Shared Function Compact(dst As Memory<Buffer>, src As Slice<Byte>) As error

class method HTMLEscape(dst: Memory<Buffer>; src: Slice<Byte>)

static void HTMLEscape(Memory<Buffer> dst, Slice<Byte> src)

static func HTMLEscape(_ dst: Memory<Buffer>, _ src: Slice<Byte>)

// .NET, .NET Standard 2.0
func HTMLEscape(dst Memory<Buffer>, src Slice<Byte>) 
// Island
func HTMLEscape(dst Memory<Buffer>, src Slice<Byte>) void

Shared Sub HTMLEscape(dst As Memory<Buffer>, src As Slice<Byte>)

class method Indent(dst: Memory<Buffer>; src: Slice<Byte>; prefix: string; indent: string): error

static error Indent(Memory<Buffer> dst, Slice<Byte> src, string prefix, string indent)

static func Indent(_ dst: Memory<Buffer>, _ src: Slice<Byte>, _ prefix: string, _ indent: string) -> error

func Indent(dst Memory<Buffer>, src Slice<Byte>, prefix string, indent string) error

Shared Function Indent(dst As Memory<Buffer>, src As Slice<Byte>, prefix As string, indent As string) As error

class method Marshal(v: Object): tuple of (Slice<Byte>, error)

static (Slice<Byte>, error) Marshal(Object v)

static func Marshal(_ v: Object) -> tuple of (Slice<Byte>, error)

func Marshal(v interface{}) tuple of (Slice<Byte>, error)

Shared Function Marshal(v As Object) As Tuple (Of Slice<Byte>, error)

class method MarshalIndent(v: Object; prefix: string; indent: string): tuple of (Slice<Byte>, error)

static (Slice<Byte>, error) MarshalIndent(Object v, string prefix, string indent)

static func MarshalIndent(_ v: Object, _ prefix: string, _ indent: string) -> tuple of (Slice<Byte>, error)

func MarshalIndent(v interface{}, prefix string, indent string) tuple of (Slice<Byte>, error)

Shared Function MarshalIndent(v As Object, prefix As string, indent As string) As Tuple (Of Slice<Byte>, error)

class method NewDecoder(r: Reader): Memory<Decoder>

static Memory<Decoder> NewDecoder(Reader r)

static func NewDecoder(_ r: Reader) -> Memory<Decoder>

func NewDecoder(r Reader) Memory<Decoder>

Shared Function NewDecoder(r As Reader) As Memory<Decoder>

class method NewEncoder(w: Writer): Memory<Encoder>

static Memory<Encoder> NewEncoder(Writer w)

static func NewEncoder(_ w: Writer) -> Memory<Encoder>

func NewEncoder(w Writer) Memory<Encoder>

Shared Function NewEncoder(w As Writer) As Memory<Encoder>

class method Unmarshal(data: Slice<Byte>; v: Object): error

static error Unmarshal(Slice<Byte> data, Object v)

static func Unmarshal(_ data: Slice<Byte>, _ v: Object) -> error

func Unmarshal(data Slice<Byte>, v interface{}) error

Shared Function Unmarshal(data As Slice<Byte>, v As Object) As error

class method Valid(data: Slice<Byte>): bool

static bool Valid(Slice<Byte> data)

static func Valid(_ data: Slice<Byte>) -> bool

func Valid(data Slice<Byte>) bool

Shared Function Valid(data As Slice<Byte>) As bool