Bool

enum Bool

Native Booleans.

true and false are the only instances.

Boolean are manipulated trough three special operators: and, or, not.

Booleans are mainly used by conditional statement and loops.

Inheritance

dep_class_core__kernel__BoolObjectObjectSerializableSerializableSerializable->ObjectPepperablePepperablePepperable->ObjectDirectSerializableDirectSerializableDirectSerializable->SerializableBoolBoolBool->PepperableBool->DirectSerializable

Parents

  • DirectSerializable: Instances of this class are not delayed and instead serialized immediately
  • Pepperable: Provides a method to convert in PepperVars.

Ancestors

  • Object: The root of the class hierarchy.
  • Serializable: Instances of this class can be passed to Serializer::serialize

Constructors

Concerns

  • core: Nit common library of core classes and methods
    • kernel: Most basic classes and methods.
    • text: All the classes and methods related to the manipulation of text entities
      • abstract_text: Abstract class for manipulation of sequences of characters
  • 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
  • pnacl: Provides PNaCl support for Nit.
    • pnacl: Provides PNaCl support for Nit.
  • 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
  • android: Android platform support and APIs
    • bundle: A mapping class of String to various value types used by the
      • bundle: A mapping class of String to various value types used by the

in core::kernel

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 ==(b)

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

redef fun hash

The hash code of the object.

The hash code is used in many data-structures and algorithms to identify objects that might be equal. Therefore, the precise semantic of hash is highly linked with the semantic of == and the only law of hash is that a == b implies a.hash == b.hash.

assert (1+1).hash == 2.hash
assert 1.to_s.hash == "1".hash

hash (like ==) might not be constant on some objects over time because of their evolution.

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

A specific redefinition of == should usually be associated with a specific redefinition of hash. Note that, unfortunately, a correct definition of hash that is lawful with == is sometime tricky and a cause of bugs.

Without redefinition, hash is based on the object_id of the instance.

redef intern fun object_id

An internal hash code for the object based on its identity.

Unless specific code, you should not use this method but use hash instead.

As its name hints it, the internal hash code, is used internally to provide a hash value. It is also used by the inspect method to loosely identify objects and helps debugging.

var a = "Hello"
var b = a
assert a.object_id == b.object_id

The specific details of the internal hash code it let to the specific engine. The rules are the following:

  • The object_id MUST be invariant for the whole life of the object.
  • Two living instances of the same classes SHOULD NOT share the same object_id.
  • Two instances of different classes MIGHT share the same object_id.
  • The object_id of a garbage-collected instance MIGHT be reused by new instances.
  • The object_id of an object MIGHT be non constant across different executions.

For instance, the nitc compiler uses the address of the object in memory as its object_id.

TODO rename in something like internal_hash_code

in core::text::abstract_text

in jvm::jvm

in pnacl::pnacl

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.

in android::bundle::bundle

redef fun add_to_bundle(bundle, key)

Called by []= to dynamically choose the appropriate method according

to the value type to store Non-primitive Object (String excluded) will be stored as a serialized json String Refine your class to customize this method behaviour