CString

extern class CString

C string char *

Used as underlying implementation for String and some other Text.

Inheritance

dep_class_core__text__native__CStringObjectObjectSerializableSerializableSerializable->ObjectPointerPointerPointer->ObjectDirectSerializableDirectSerializableDirectSerializable->SerializableNativeCArrayNativeCArrayNativeCArray->PointerCStringCStringCString->DirectSerializableCString->NativeCArray

Parents

  • DirectSerializable: Instances of this class are not delayed and instead serialized immediately
  • NativeCArray: A native C array, as in a pointer to the first element of the array

Ancestors

  • Object: The root of the class hierarchy.
  • Pointer: Pointer classes are used to manipulate extern C structures.
  • Serializable: Instances of this class can be passed to Serializer::serialize

Constructors

Concerns

  • core: Nit common library of core classes and methods
    • text: All the classes and methods related to the manipulation of text entities
      • native: Native structures for text and bytes
      • abstract_text: Abstract class for manipulation of sequences of characters
      • flat: All the array-based text representations
    • bytes: Services for byte streams and arrays
    • exec: Invocation and management of operating system sub-processes.
  • base64: Offers the base 64 encoding and decoding algorithms
    • base64: Offers the base 64 encoding and decoding algorithms
  • c: Structures and services for compatibility with the C language
    • c: Structures and services for compatibility with the C language
  • cpp: Services for compatibility with C++ code and libraries
    • cpp: Services for compatibility with C++ code and libraries
  • jvm: Java Virtual Machine invocation API and others services from the JNI C API
    • jvm: Java Virtual Machine invocation API and others services from the JNI C API
  • gettext: Internationalization of Strings using gettext library
    • gettext: Internationalization of Strings using gettext library
  • cocoa: Cocoa API, the development layer of OS X
    • foundation: The Foundation Kit provides basic Objective-C classes and structures
  • java: Supporting services for the FFI with Java and to access Java libraries
    • ffi_support: Core supporting services for the FFI with Java
  • json: read and write JSON formatted text
    • serialization_write: Services to write Nit objects to JSON strings: serialize_to_json and JsonSerializer
  • msgpack: MessagePack, an efficient binary serialization format

in core::text::native

redef type SELF

Type of this instance, automatically specialized in every class

A common use case of the virtual type SELF is to type an attribute and store another instance of the same type as self. It can also be used as as return type to a method producing a copy of self or returning an instance expected to be the exact same type as self.

This virtual type must be used with caution as it can hinder specialization. In fact, it imposes strict restrictions on all sub-classes and their usage. For example, using SELF as a return type of a method foo forces all subclasses to ensure that foo returns the correct and updated type. A dangerous usage take the form of a method typed by SELF which creates and returns a new instance. If not correctly specialized, this method would break when invoked on a sub-class.

A general rule for safe usage of SELF is to ensure that inputs typed SELF are stored in attributes typed SELF and returned by methods typed SELF, pretty much the same things as you would do with parameter types.

redef intern fun ==(o)

Have self and other the same value?

assert 1 + 1 == 2
assert not 1 == "1"
assert 1.to_s == "1"

The exact meaning of same value is left to the subclasses. Implicitly, the default implementation, is is_same_instance.

The laws of == are the following:

  • reflexivity a.is_same_instance(b) implies a == b
  • symmetry: (a == b) == (b == a)
  • transitivity: (a == b) and (b == c) implies (a == c)

== might not be constant on some objects overtime because of their evolution.

var a = [1]
var b = [1]
var c = [1,2]
assert a == b and not a == c
a.add 2
assert not a == b and a == c

Lastly, == is highly linked with hash and a specific redefinition of == should usually be associated with a specific redefinition of hash.

ENSURE result implies self.hash == other.hash

fun char_at(pos: Int): Char

Gets the UTF-8 char at index pos

Index is expressed in Unicode chars

    assert "かきく".as(FlatString).items.char_at(0) == 'か'

If the char at position pos is an invalid Unicode char, the Unicode replacement character � (0xFFFD) will be used.

    assert "かきく".as(FlatString).items.char_at(1) == '�'

in core::text::abstract_text

abstract fun to_s_unsafe(byte_length: nullable Int, char_length: nullable Int, copy: nullable Bool, clean: nullable Bool): String

Get a String from the data at self (with unsafe options)

The default behavior is the safest and equivalent to to_s.

Options:

  • Set byte_length to the number of bytes to use as data. Otherwise, this method searches for a terminating null byte.

  • Set char_length to the number of Unicode character in the string. Otherwise, the data is read to count the characters. Ignored if clean == true.

  • If copy == true, the default, copies the data at self in the Nit GC allocated memory. Otherwise, the return may still point to the data at self.

  • If clean == true, the default, the string is cleaned of invalid UTF-8 characters. If cleaning is necessary, the data is copied into Nit GC managed memory, whether or not copy == true. Don't clean only when the data has already been verified as valid UTF-8, other library services rely on UTF-8 compliant characters.

in core::text::flat

redef fun to_s_unsafe(byte_length, char_length, copy, clean)

Get a String from the data at self (with unsafe options)

The default behavior is the safest and equivalent to to_s.

Options:

  • Set byte_length to the number of bytes to use as data. Otherwise, this method searches for a terminating null byte.

  • Set char_length to the number of Unicode character in the string. Otherwise, the data is read to count the characters. Ignored if clean == true.

  • If copy == true, the default, copies the data at self in the Nit GC allocated memory. Otherwise, the return may still point to the data at self.

  • If clean == true, the default, the string is cleaned of invalid UTF-8 characters. If cleaning is necessary, the data is copied into Nit GC managed memory, whether or not copy == true. Don't clean only when the data has already been verified as valid UTF-8, other library services rely on UTF-8 compliant characters.

in core::bytes

in core::exec

in base64::base64

in c::c

in cpp::cpp

in jvm::jvm

in gettext::gettext

in cocoa::foundation

in java::ffi_support

in json::serialization_write

redef fun accept_json_serializer(v)

Refinable service to customize the serialization of this class to JSON

This method can be refined to customize the serialization by either writing pure JSON directly on the stream v.stream or by using other services of JsonSerializer.

Most of the time, it is preferable to refine the method core_serialize_to which is used by all the serialization engines, not just JSON.

in msgpack::serialization_write

redef fun accept_msgpack_serializer(v)

Hook to customize the serialization of this class to MessagePack

This method can be refined to customize the serialization by either writing pure JSON directly on the stream v.stream or by using other services of MsgPackSerializer.

Most of the time, it is better to refine the method core_serialize_to which is used by all the serialization engines, not just MessagePack.