ISelect abstract#

Interface for managing EXPRESS SELECT data.

SELECT is a union type that holds a single value from a defined set of allowed types. The possible types are defined in the select list, and we call these "selectable types".

State Management:#

A SELECT can be in one of three states:

1. Determined: A specific type is selected and a value is stored
2. Indetermined: No type selected (invalid state for operations)
3. Null: has null descriptor, created by calling createNullSelect

When in an indetermined state (no selected type), most getter/setter methods will return Option.none or equivalent failure indicators.

Conceptual Model:#

A simplistic way to understand SELECT is as an object with multiple attributes where only one attribute can hold a value at any time, and the attribute names correspond to the selectable types. It is similar to union type to programming language that support it, for example, std::variant type of C++ from the standard library.

JSON Representation:#

When used in conjunction with IInstance's JSON interface, SELECT instances should be constructed as JSON objects where the key represents the selected type and the value represents the stored data.

Examples:#

1. Select of simple type (IfcMeasureValue):

{
  "IfcAreaMeasure": 9.0
}

2. Select of select (IfcValue):

{
  "IfcMeasureValue": {
    "IfcAreaMeasure": 9.0
  }
}

3. Select of ENTITY (IfcAxis2Placement):

{
  "IfcAxis2Placement2D": {
    "Location": {
      "@type": "IfcCartesianPoint",
      "Coordinates": [0.0, 0.0]
    }
  }
}

Schema Integration:#

SELECT is one of two categories that can hold attribute values (the other is ENTITY). SELECT instances have no inherent persistency - they must be attributes of an ENTITY to be persisted within a model.

Constructors#

ISelect()#

Properties#

descriptor no setter#

Gets the descriptor for this SELECT type.

ISelectDescriptor get descriptor;

hashCode no setter inherited#

The hash code for this object.

A hash code is a single integer which represents the state of the object that affects operator == comparisons.

All objects have hash codes. The default hash code implemented by Object represents only the identity of the object, the same way as the default operator == implementation only considers objects equal if they are identical (see identityHashCode).

If operator == is overridden to use the object state instead, the hash code must also be changed to represent that state, otherwise the object cannot be used in hash based data structures like the default Set and Map implementations.

Hash codes must be the same for objects that are equal to each other according to operator ==. The hash code of an object should only change if the object changes in a way that affects equality. There are no further requirements for the hash codes. They need not be consistent between executions of the same program and there are no distribution guarantees.

Objects that are not equal are allowed to have the same hash code. It is even technically allowed that all instances have the same hash code, but if clashes happen too often, it may reduce the efficiency of hash-based data structures like HashSet or HashMap.

If a subclass overrides hashCode, it should override the operator == operator as well to maintain consistency.

Inherited from Object.

external int get hashCode;

isDetach no setter#

is select detached from other select/instance and has ownership of its owner memory buffer.

bool get isDetach;

isNull no setter inherited#

Indicates whether the object represents a null value.

Returns true if the object is considered null according to its implementation, false otherwise.

Inherited from INullableObject.

bool get isNull;

runtimeType no setter inherited#

A representation of the runtime type of the object.

Inherited from Object.

external Type get runtimeType;

schema no setter#

Gets the schema that defines this SELECT type.

ISchema get schema;

selectedBaseType no setter#

Gets the base type identifier of the selected value.

For simple types, this is the type itself. For aggregate types, this is the element type of the aggregate.

int get selectedBaseType;

selectedFundamentalType no setter#

Gets the fundamental type category of the selected value.

FundamentalType get selectedFundamentalType;

selectedTypeName no setter#

Gets the name of the currently selected type. If this is not set, this select is in a indetermined state and all get/set and other methods will Option.none to indicate failure.

String get selectedTypeName;

type no setter#

Gets the EXPRESS type name of this SELECT definition.

String get type;

Methods#

addInstanceRef()#

Adds an entity instance reference to an entity aggregate.

inst: The entity instance to create a reference to addInverse: If true, adds an inverse reference from the target instance back to this SELECT's owning instance for bidirectional relationship management Returns true if successful. Returns false if:

• SELECT is not in determined state
• Selected type is not an ENTITYS type

bool addInstanceRef(IInstance inst, [bool addInverse = true]);

addValue()#

Adds a value to an aggregate (list) stored in this SELECT.

value: The value to append to the stored list. The type T must be compatible with the element type of the currently selected aggregate type.

Supported Aggregate Types and Element Types:

This method only works when the selected type is one of the following aggregate (list) fundamental types:

• FundamentalType.BOOLS → Accepts bool elements
• FundamentalType.INTEGERS → Accepts int elements
• FundamentalType.REALS → Accepts double elements
• FundamentalType.STRINGS → Accepts String elements
• FundamentalType.SELECTS → Accepts ISelect elements
• FundamentalType.ENTITYS → Accepts IInstance elements
• FundamentalType.LOGICALS → Accepts PIEnum elements
• FundamentalType.ENUMS → Accepts PIEnum elements

Returns true if:

• The SELECT is in a determined state (type is selected)
• The selected type is one of the supported aggregate types
• The type T of value matches the element type of the selected aggregate
• The value is successfully appended to the stored list

Returns false if:

• The SELECT is in an indetermined or null state
• The selected type is not an aggregate type
• The type T is incompatible with the aggregate's element type
• The value cannot be added (e.g., constraints violation)

Behavior:

• Appends the value to the end of the existing list
• Creates a new list containing only value if no list exists
• Preserves all existing elements in the list

Examples:

// Add to a list of integers
select.addValue<int>(42);
select.addValue<int>(99);  // List becomes [42, 99]

// Add to a list of strings
select.addValue<String>('Hello');
select.addValue<String>('World');  // List becomes ['Hello', 'World']

// Add to a list of entities
select.addValue<IInstance>(entity1);
select.addValue<IInstance>(entity2);  // List contains both entities

// Add to a list of selects
select.addValue<ISelect>(nestedSelect);

Type Safety:

The generic type parameter T provides compile-time type hints, but runtime validation is required. The actual element type is determined by the selected aggregate's fundamental type, not by T.

Related Methods:

• setValue: Replaces the entire stored value
• updateValue: Modifies an existing element at a specific index
• removeValue: Removes an element at a specific index
• addInstanceRef: Specialized version for adding entity references with inverse relationship management

Error Scenarios:

1. Wrong selected type: Returns false if selected type is not an aggregate
2. Type mismatch: Returns false if value type doesn't match aggregate element type
3. Null/indetermined state: Returns false if no type is selected
4. Constraint violation: Returns false if schema constraints prevent addition

Note:

For FundamentalType.ENTITYS, prefer addInstanceRef when you need to manage inverse relationships between entities.

Performance:

This operation is O(1) for appending to the end of the list. For bulk additions, consider using setValue with a complete list for better performance.

bool addValue<T>(T value);

createComplexInstance()#

Creates a complex entity instance from constituent parts.

parts: List of type identifiers for the partial instances that form the complex entity

IInstance createComplexInstance(List<int> parts);

createEnum()#

Creates an enumeration of the currently selected type.

Returns null enum if the selected type is not an enumeration.

PIEnum createEnum();

createInstance()#

Creates an entity instance.

typeName: The EXPRESS entity type name to create typeId: The hash-based entity type identifier to create

If no parameters are provided, creates an instance of the currently selected type.

IInstance createInstance({String? typeName, int? typeId});

createNullSelect()#

Creates a null SELECT instance for null safety support.

Returns a special null SELECT instance that represents an unset value.

ISelect createNullSelect();

createSelect()#

Creates a SELECT instance of the requested type.

typeName: The EXPRESS SELECT type name to create typeId: The hash-based SELECT type identifier to create selectedTypeName: Optional initial selected type name

Returns null select if the selected type is not compatible with the requested type.

ISelect createSelect(
    {String? typeName, int? typeId, String? selectedTypeName});

detach()#

Detaches the select object from its dependent buffer.

When a select shares a buffer with a parent instance, calling detach() creates an independent copy of the buffer, giving this select its own memory ownership. This is essential when the parent buffer may be modified and you need this select to remain independent and unchanged.

After detachment, the select's runtime type changes from attached to free, and isDetach will return true.

When to Use:

• Before modifying a parent instance that contains this select
• When extracting a select for independent processing
• When you need to ensure data isolation between operations

Example:

// Get a select from an instance (initially shares buffer)
final select = instance.getSelect(attName: 'Placement');

// Detach BEFORE modifying the parent instance
select.detach();  // select now has independent buffer

// Modify parent instance - select remains unchanged
instance.setAttributesByJson({
  "Description": "Modified description"
});

Returns true if the select was successfully detached, false if:

• The select is already detached
• The select is a null select
• Detachment fails for any reason

bool detach();

duplicate()#

Creates a deep copy of this SELECT instance.

ISelect duplicate();

getBinary()#

Gets the stored value if the selected type is BINARY.

Returns optionOf with the binary data if successful. Returns Option.none if:

• SELECT is not in determined state
• Selected type is not BINARY type
• Value is null or retrieval fails

Uint8List getBinary();

getBinarys()#

Gets the stored value if the selected type is BINARYS (binary aggregate).

Returns a List<Uint8List> containing the binary data if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not a BINARYS type
• Value is null or retrieval fails

List<Uint8List> getBinarys();

getBool()#

Gets the stored value if the selected type is BOOLEAN.

Returns optionOf if successful. Returns Option.none if:

• SELECT is not in determined state
• Selected type is not BOOLEAN
• Value is null or retrieval fails

Option<bool> getBool();

getBools()#

Gets the stored value if the selected type is BOOLS (boolean aggregate).

Returns a List<bool> containing the values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not a BOOLS type
• Value is null or retrieval fails

List<bool> getBools();

getEnum()#

Gets the stored value if the selected type is ENUM.

Returns a PIEnum representing the enumeration value. Returns null enum if:

• SELECT is not in determined state
• Selected type is not an enumeration
• Value is null or retrieval fails

PIEnum getEnum();

getEnums()#

Gets the stored value if the selected type is ENUMS (enumeration aggregate).

Returns a List<PIEnum> containing the enumeration values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not an ENUMS type
• Value is null or retrieval fails

List<PIEnum> getEnums();

getInstance()#

Gets the stored value if the selected type is ENTITY.

resolveRef: If true, retrieves the fully populated instance from the owning instance's composites or from the model. If false, returns the instance reference as-is. detach: If true, the returned instance will have its own independent memory buffer instead of sharing the parent instance's buffer. This is useful when the parent buffer may be modified and you need the entity instance to remain independent. See detach() for more details.

Returns the entity instance if successful. Returns null instance if:

• SELECT is not in determined state
• Selected type is not an ENTITY
• Value is null or retrieval fails

IInstance getInstance({bool resolveRef = false, bool detach = false});

getInstances()#

Gets the stored value if the selected type is ENTITYS (entity aggregate).

resolveRef: If true, resolves instance references to fully populated instances. If false, returns instance references as-is. detach: If true, each returned instance in the list will have its own independent memory buffer instead of sharing the parent instance's buffer. This is useful when the parent buffer may be modified and you need the entity instances to remain independent. See detach() for more details.

Returns a List<IInstance> containing the entity values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not an ENTITYS type
• Value is null or retrieval fails

List<IInstance> getInstances({bool resolveRef = false, bool detach = false});

getInt()#

Gets the stored value if the selected type is INTEGER.

Returns optionOf if successful. Returns Option.none if:

• SELECT is not in determined state
• Selected type is not an integer type
• Value is null or retrieval fails

Option<int> getInt();

getInts()#

Gets the stored value if the selected type is INTEGERS (integer aggregate).

Returns a List<int> containing the values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not an INTEGERS type
• Value is null or retrieval fails

List<int> getInts();

getLogical()#

Gets the stored value if the selected type is LOGICAL.

Returns a PIEnum representing the logical value (True, False, Unknown). Returns null enum if:

• SELECT is not in determined state
• Selected type is not LOGICAL
• Value is null or retrieval fails

PIEnum getLogical();

getLogicals()#

Gets the stored value if the selected type is LOGICALS (logical aggregate).

Returns a List<PIEnum> containing the logical values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not a LOGICALS type
• Value is null or retrieval fails

List<PIEnum> getLogicals();

getReal()#

Gets the stored value if the selected type is REAL.

Returns optionOf if successful. Returns Option.none if:

• SELECT is not in determined state
• Selected type is not a real number type
• Value is null or retrieval fails

Option<double> getReal();

getReals()#

Gets the stored value if the selected type is REALS (real number aggregate).

Returns a List<double> containing the values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not a REALS type
• Value is null or retrieval fails

List<double> getReals();

getSelect()#

Gets the stored value if the selected type is SELECT.

detach: If true, the returned nested select will have its own independent memory buffer instead of sharing the parent instance's buffer. This is useful when the parent buffer may be modified and you need the select to remain independent. See detach() for more details.

Returns the nested SELECT instance if successful. Returns null select if:

• SELECT is not in determined state
• Selected type is not a SELECT
• Value is null or retrieval fails

ISelect getSelect({bool detach = false});

getSelectableType()#

Gets the type identifier and fundamental type of a selectable type.

type: The EXPRESS type name to look up Returns a tuple (int typeId, FundamentalType funType) for the target type.

Note:

The returned type could be a subtype of the requested target type.

(int, FundamentalType) getSelectableType(String type);

getSelectedValue()#

Gets the currently stored value in a generic way.

resolveRef: If true, resolves instance references to fully populated instances. If false, returns instance references as-is. detach: If true, any instances or selects returned will have their own independent memory buffer instead of sharing the parent instance's buffer. This is useful when you need to manipulate the retrieved values independently of the original instance hierarchy. See detach() for more details.

Returns the stored value. Returns Option.none if:

• Value retrieval fails

Option<T> getSelectedValue<T>({bool resolveRef = false, bool detach = false});

getSelects()#

Gets the stored value if the selected type is SELECTS (select aggregate).

detach: If true, each returned select in the list will have its own independent memory buffer instead of sharing the parent instance's buffer. This is useful when the parent buffer may be modified and you need the selects to remain independent. See detach() for more details.

Returns a List<ISelect> containing the select values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not a SELECTS type
• Value is null or retrieval fails

List<ISelect> getSelects({bool detach = false});

getString()#

Gets the stored value if the selected type is STRING.

Returns optionOf if successful. Returns Option.none if:

• SELECT is not in determined state
• Selected type is not a STRING type
• Value is null or retrieval fails

Option<String> getString();

getStrings()#

Gets the stored value if the selected type is STRINGS (string aggregate).

Returns a List<String> containing the values if successful. Returns an empty list if:

• SELECT is not in determined state
• Selected type is not a STRINGS type
• Value is null or retrieval fails

List<String> getStrings();

noSuchMethod() inherited#

Invoked when a nonexistent method or property is accessed.

A dynamic member invocation can attempt to call a member which doesn't exist on the receiving object. Example:

dynamic object = 1;
object.add(42); // Statically allowed, run-time error

This invalid code will invoke the noSuchMethod method of the integer 1 with an Invocation representing the .add(42) call and arguments (which then throws).

Classes can override noSuchMethod to provide custom behavior for such invalid dynamic invocations.

A class with a non-default noSuchMethod invocation can also omit implementations for members of its interface. Example:

class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}

This code has no compile-time warnings or errors even though the MockList class has no concrete implementation of any of the List interface methods. Calls to List methods are forwarded to noSuchMethod, so this code will log an invocation similar to Invocation.method(#add, [42]) and then throw.

If a value is returned from noSuchMethod, it becomes the result of the original invocation. If the value is not of a type that can be returned by the original invocation, a type error occurs at the invocation.

The default behavior is to throw a NoSuchMethodError.

Inherited from Object.

@pragma("vm:entry-point")
@pragma("wasm:entry-point")
external dynamic noSuchMethod(Invocation invocation);

nullify()#

Sets this SELECT stored value to null value.

Returns optionOf if successfully nullified. Returns Option.none if this SELECT is a nullSelect (lacks a descriptor).

Option<bool> nullify();

removeValue()#

Removes element at index from the stored aggregate list.

Only works for aggregate types (BOOLS, INTEGERS, REALS, etc.). index must be valid (0 ≤ index < list.length). Subsequent elements shift left, list size decreases by 1.

Returns true on success, false for:

• Invalid index or wrong selected type
• Empty list or null/indetermined state
• Constraint violation

Example: select.removeValue(2) removes element at position 2. Check list size first. For bulk removals, use setValue with filtered list.

bool removeValue(int index);

setInstanceRef()#

Sets the stored value to an instance reference.

inst: The entity instance to create a reference to addInverse: If true, adds an inverse reference from the target instance back to this SELECT's owning instance for bidirectional relationship management Returns true if successful. Returns false if:

• Selected type is not an ENTITY
• Instance type is not compatible with selected ENTITY type
• Reference creation fails

bool setInstanceRef(IInstance inst, [bool addInverse = true]);

setSelectedComplexType()#

Sets the selected type as a complex entity type using its constituent parts.

types: List of partial type names that form the complex entity

Returns true if the complex type was successfully selected, false otherwise.

Note:

If you already know the specific complex type, use setSelectedType instead.

bool setSelectedComplexType(List<String> types);

setSelectedType()#

Sets the currently selected type.

typeName: The EXPRESS type name to select typeId: The hash-based type identifier to select

Returns true if the type was successfully selected, false if type specified in input parameter is incompatible with the selectble types. For instances, it should be the actual ENTITY type to be stored. At least one parameter must be provided.

bool setSelectedType({String? typeName, int? typeId});

setValue()#

Sets the stored value for the currently selected type.

value: The value to store. The type T must be compatible with the currently selected type's fundamental type.

Supported Fundamental Types and Corresponding Dart Types:

• FundamentalType.BOOLEAN → bool
• FundamentalType.INTEGER → int
• FundamentalType.REAL → double
• FundamentalType.STRING → String
• FundamentalType.BINARY → Uint8List
• FundamentalType.LOGICAL → PIEnum
• FundamentalType.ENUM → PIEnum
• FundamentalType.ENTITY → IInstance
• FundamentalType.SELECT → ISelect
• FundamentalType.BOOLS → List<bool>
• FundamentalType.INTEGERS → List<int>
• FundamentalType.REALS → List<double>
• FundamentalType.STRINGS → List<String>
• FundamentalType.SELECTS → List<ISelect>
• FundamentalType.ENTITYS → List<IInstance>
• FundamentalType.LOGICALS → List<PIEnum>
• FundamentalType.ENUMS → List<PIEnum>

Returns true if:

• The SELECT is in a determined state (type is selected)
• The type of value is compatible with the currently selected fundamental type
• The value is successfully stored

Returns false if:

• The SELECT is in an indetermined state (no type selected)
• The SELECT is in a null state
• The type T of value is incompatible with the selected fundamental type
• Value storage fails for any other reason

Type Safety:

The generic type parameter T provides compile-time type checking. However, runtime validation is still required because Dart's generics use type erasure. Mismatched types will result in a return value of false.

Examples:

// Set a real (double) value
select.setValue<double>(3.14);

// Set an integer value
select.setValue<int>(42);

// Set a string value
select.setValue<String>('Hello');

// Set a boolean list (aggregate)
select.setValue<List<bool>>([true, false, true]);

// Set an entity reference
select.setValue<IInstance>(someEntity);

// Set a nested select
select.setValue<ISelect>(nestedSelect);

Note:

This method requires the SELECT to be in a determined state (type already selected via setSelectedType or similar). If no type is selected, this method will return false.

For setting entity references with inverse relationship management, use setInstanceRef instead for ENTITY types.

Error Handling:

This method returns false on failure rather than throwing exceptions. Check the return value and handle errors appropriately in calling code.

bool setValue<T>(T value);

toJson()#

Converts the select to a JSON-compatible map representation.

This method serializes the selected value into a Map with a single key being the type name of the selected value, and the value being the JSON-compatible Dart object. Nested instances and selects are recursively converted to their JSON form.

setDefaultForOption: If true (default), optional values that are null will return their default values (e.g., false for boolean, 0 for integer, 0.0 for real, '' for string). If false, null optional values will return null.

Returns a Map with the selected type as key and the value as value.

Example

final select = owner.getSelect(attName: 'Owner');
select.setString('IfcPerson');

final json = select.toJson();
// Output: {'IfcPerson': 'John Doe'}

Map<String, dynamic> toJson({bool setDefaultForOption = true});

toString() inherited#

A string representation of this object.

Some classes have a default textual representation, often paired with a static parse function (like int.parse). These classes will provide the textual representation as their string representation.

Other classes have no meaningful textual representation that a program will care about. Such classes will typically override toString to provide useful information when inspecting the object, mainly for debugging or logging.

Inherited from Object.

external String toString();

updateValue()#

Updates an element at a specific index in an aggregate (list) stored in this SELECT.

index: The zero-based position in the list to update value: The new value to store at the specified position

Supported Aggregate Types:

This method only works when the selected type is one of the following aggregate (list) fundamental types:

• FundamentalType.BOOLS → Accepts bool elements
• FundamentalType.INTEGERS → Accepts int elements
• FundamentalType.REALS → Accepts double elements
• FundamentalType.STRINGS → Accepts String elements
• FundamentalType.SELECTS → Accepts ISelect elements
• FundamentalType.ENTITYS → Accepts IInstance elements
• FundamentalType.LOGICALS → Accepts PIEnum elements
• FundamentalType.ENUMS → Accepts PIEnum elements

Returns true if:

• The SELECT is in a determined state (type is selected)
• The selected type is one of the supported aggregate types
• index is within bounds of the existing list (0 ≤ index < list.length)
• The type T of value matches the element type of the selected aggregate
• The value is successfully updated at the specified position

Returns false if:

• The SELECT is in an indetermined or null state
• The selected type is not an aggregate type
• index is out of bounds
• The type T is incompatible with the aggregate's element type
• The update violates schema constraints

Behavior:

• Replaces the existing value at index with value
• Does not change the list size or other elements
• Preserves the original list structure
• Validates the new value against schema constraints

Examples:

// Update an element in a list of integers
// Assuming list is [10, 20, 30]
select.updateValue<int>(1, 99);  // List becomes [10, 99, 30]

// Update an element in a list of strings
// Assuming list is ['A', 'B', 'C']
select.updateValue<String>(2, 'Z');  // List becomes ['A', 'B', 'Z']

// Update an entity reference in a list
// Assuming list contains entity references
select.updateValue<IInstance>(0, updatedEntity);

// Update a nested select in a list
select.updateValue<ISelect>(3, newSelect);

Index Validation:

The index must be:

• Non-negative (≥ 0)
• Less than the current list length
• For an empty list, any index will return false

Use get*() methods (like getInts(), getStrings(), etc.) to check the current list size before calling this method.

Type Safety:

The generic type parameter T must match the element type of the selected aggregate. Runtime validation ensures compatibility.

Related Methods:

• addValue: Appends a new element to the end of the list
• removeValue: Removes an element at a specific index
• setValue: Replaces the entire list with a new list

Error Scenarios:

1. Index out of bounds: Most common failure - check list size first
2. Wrong selected type: Selected type is not an aggregate
3. Type mismatch: value type doesn't match aggregate element type
4. Null/indetermined state: No type selected or null SELECT
5. Constraint violation: New value violates schema constraints

Special Considerations:

• For FundamentalType.ENTITYS: Updating entity references may affect inverse relationships. The old reference's inverse may need cleanup.
• For FundamentalType.SELECTS: The replaced select may need disposal or cleanup depending on implementation.
• Schema constraints (like unique values) are revalidated after update.

Performance:

This operation is O(1) for direct index access. No list reallocation occurs unless the new value has different memory characteristics.

bool updateValue<T>(int index, T value);

Operators#

operator ==() inherited#

The equality operator.

The default behavior for all Objects is to return true if and only if this object and other are the same object.

Override this method to specify a different equality relation on a class. The overriding method must still be an equivalence relation. That is, it must be:

• Total: It must return a boolean for all arguments. It should never throw.

• Reflexive: For all objects o, o == o must be true.

• Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must either both be true, or both be false.

• Transitive: For all objects o1, o2, and o3, if o1 == o2 and o2 == o3 are true, then o1 == o3 must be true.

The method should also be consistent over time, so whether two objects are equal should only change if at least one of the objects was modified.

If a subclass overrides the equality operator, it should override the hashCode method as well to maintain consistency.

Inherited from Object.

external bool operator ==(Object other);