Interop

java.lang.Object
- com.oracle.truffle.espresso.polyglot.Interop

```
public final class Interop
extends Object
```
Provides access to the interoperability message protocol between Truffle languages. Every method represents one message specified by the protocol. In the following text we will abbreviate interoperability with interop. This class provides access to a strict subset of Truffle's interop protocol.
Foreign objects will always have a Java type in Espresso, how a Java type is attached to a foreign object remains an implementation detail.

Since:

21.0

See Also:

Polyglot

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`asBoolean(Object receiver)` Returns the Java boolean value if the receiver represents a `boolean` like value.
`static byte`	`asByte(Object receiver)` Returns the receiver value as Java byte primitive if the number fits without loss of precision.
`static double`	`asDouble(Object receiver)` Returns the receiver value as Java double primitive if the number fits without loss of precision.
`static float`	`asFloat(Object receiver)` Returns the receiver value as Java float primitive if the number fits without loss of precision.
`static int`	`asInt(Object receiver)` Returns the receiver value as Java int primitive if the number fits without loss of precision.
`static long`	`asLong(Object receiver)` Returns the receiver value as Java long primitive if the number fits without loss of precision.
`static long`	`asPointer(Object receiver)` Returns the pointer value as long value if the receiver represents a pointer like value.
`static short`	`asShort(Object receiver)` Returns the receiver value as Java short primitive if the number fits without loss of precision.
`static String`	`asString(Object receiver)` Returns the Java string value if the receiver represents a `string` like value.
`static Object`	`execute(Object receiver, Object... arguments)` Executes an executable value with the given arguments.
`static boolean`	`fitsInByte(Object receiver)` Returns `true` if the receiver represents a `number` and its value fits in a Java byte primitive without loss of precision, else `false`.
`static boolean`	`fitsInDouble(Object receiver)` Returns `true` if the receiver represents a `number` and its value fits in a Java double primitive without loss of precision, else `false`.
`static boolean`	`fitsInFloat(Object receiver)` Returns `true` if the receiver represents a `number` and its value fits in a Java float primitive without loss of precision, else `false`.
`static boolean`	`fitsInInt(Object receiver)` Returns `true` if the receiver represents a `number` and its value fits in a Java int primitive without loss of precision, else `false`.
`static boolean`	`fitsInLong(Object receiver)` Returns `true` if the receiver represents a `number` and its value fits in a Java long primitive without loss of precision, else `false`.
`static boolean`	`fitsInShort(Object receiver)` Returns `true` if the receiver represents a `number` and its value fits in a Java short primitive without loss of precision, else `false`.
`static long`	`getArraySize(Object receiver)` Returns the array size of the receiver.
`static long`	`getBufferSize(Object receiver)` Returns the buffer size of the receiver, in bytes.
`static Object`	`getDeclaringMetaObject(Object receiver)` Returns declaring meta object.
`static Object`	`getExceptionCause(Object receiver)` Returns the internal cause of the receiver.
`static int`	`getExceptionExitStatus(Object receiver)` Returns exception exit status of the receiver.
`static Object`	`getExceptionMessage(Object receiver)` Returns exception message of the receiver.
`static Object`	`getExceptionStackTrace(Object receiver)` Returns the exception stack trace of the receiver that is of type exception.
`static ExceptionType`	`getExceptionType(Object receiver)` Returns `exception type` of the receiver.
`static Object`	`getExecutableName(Object receiver)` Returns executable name of the receiver.
`static Object`	`getHashEntriesIterator(Object receiver)` Returns the hash entries iterator for the receiver.
`static Object`	`getHashKeysIterator(Object receiver)` Returns the hash keys iterator for the receiver.
`static long`	`getHashSize(Object receiver)` Returns the number of receiver entries.
`static Object`	`getHashValuesIterator(Object receiver)` Returns the hash values iterator for the receiver.
`static Object`	`getIterator(Object receiver)` Returns the iterator for the receiver.
`static Object`	`getIteratorNextElement(Object receiver)` Returns the next element in the iteration.
`static Object`	`getMembers(Object receiver)` Returns an array of member name strings.
`static Object`	`getMetaObject(Object receiver)` Returns the metaobject that is associated with this value.
`static Object`	`getMetaQualifiedName(Object metaObject)` Returns the qualified name of a metaobject as `string`.
`static Object`	`getMetaSimpleName(Object metaObject)` Returns the simple name of a metaobject as `string`.
`static boolean`	`hasArrayElements(Object receiver)` Returns `true` if the receiver may have array elements.
`static boolean`	`hasBufferElements(Object receiver)` Returns `true` if the receiver may have buffer elements.
`static boolean`	`hasDeclaringMetaObject(Object receiver)` Returns `true` if the receiver has a declaring meta object.
`static boolean`	`hasExceptionCause(Object receiver)` Returns `true` if the receiver is an exception with an attached internal cause.
`static boolean`	`hasExceptionMessage(Object receiver)` Returns `true` if the receiver is an exception that has an exception message.
`static boolean`	`hasExceptionStackTrace(Object receiver)` Returns `true` if the receiver is an exception and has a stack trace.
`static boolean`	`hasExecutableName(Object receiver)` Returns `true` if the receiver has an executable name.
`static boolean`	`hasHashEntries(Object receiver)` Returns `true` if the receiver may have hash entries.
`static boolean`	`hasIdentity(Object receiver)` Returns `true` if and only if the receiver specifies identity, else `false`.
`static boolean`	`hasIterator(Object receiver)` Returns `true` if the receiver provides an iterator.
`static boolean`	`hasIteratorNextElement(Object receiver)` Returns `true` if the receiver is an iterator which has more elements, else `false`.
`static boolean`	`hasMemberReadSideEffects(Object receiver, String member)` Returns `true` if reading a member may cause a side-effect.
`static boolean`	`hasMembers(Object receiver)` Returns `true` if the receiver may have members.
`static boolean`	`hasMemberWriteSideEffects(Object receiver, String member)` Returns `true` if writing a member may cause a side-effect, besides the write operation of the member.
`static boolean`	`hasMetaObject(Object receiver)` Returns `true` if the receiver value has a metaobject associated.
`static int`	`identityHashCode(Object receiver)` Returns an identity hash code for the receiver if it has `identity`.
`static Object`	`instantiate(Object receiver, Object... arguments)` Instantiates the receiver value with the given arguments.
`static Object`	`invokeMember(Object receiver, String member, Object... arguments)` Invokes a member for a given receiver and arguments.
`static boolean`	`isArrayElementExisting(Object receiver, long index)` Returns true if the array element is existing.
`static boolean`	`isArrayElementInsertable(Object receiver, long index)` Returns `true` if a given array element index is not existing and `insertable`.
`static boolean`	`isArrayElementModifiable(Object receiver, long index)` Returns `true` if a given array element index is existing and `writable`.
`static boolean`	`isArrayElementReadable(Object receiver, long index)` Returns `true` if a given array element is `readable`.
`static boolean`	`isArrayElementRemovable(Object receiver, long index)` Returns `true` if a given array element index is existing and `removable`.
`static boolean`	`isArrayElementWritable(Object receiver, long index)` Returns true if the array element is `modifiable` or `insertable`.
`static boolean`	`isBoolean(Object receiver)` Returns `true` if the receiver represents a `boolean` like value, else `false`.
`static boolean`	`isBufferWritable(Object receiver)` Returns `true` if the receiver is a modifiable buffer.
`static boolean`	`isException(Object receiver)` Returns `true` if the receiver value represents a throwable exception/error.
`static boolean`	`isExceptionIncompleteSource(Object receiver)` Returns `true` if receiver value represents an incomplete source exception.
`static boolean`	`isExecutable(Object receiver)` Returns `true` if the receiver represents an `executable` value, else `false`.
`static boolean`	`isHashEntryExisting(Object receiver, Object key)` Returns `true` if mapping for a given key is existing.
`static boolean`	`isHashEntryInsertable(Object receiver, Object key)` Returns `true` if mapping for the specified key does not exist and is `writable`.
`static boolean`	`isHashEntryModifiable(Object receiver, Object key)` Returns `true` if mapping for the specified key exists and is `writable`.
`static boolean`	`isHashEntryReadable(Object receiver, Object key)` Returns `true` if mapping for the specified key exists and is `readable`.
`static boolean`	`isHashEntryRemovable(Object receiver, Object key)` Returns `true` if mapping for the specified key exists and is removable.
`static boolean`	`isHashEntryWritable(Object receiver, Object key)` Returns `true` if mapping for the specified key is `modifiable` or `insertable`.
`static boolean`	`isIdentical(Object receiver, Object other)` Returns `true` if two values represent the identical value, else `false`.
`static boolean`	`isInstantiable(Object receiver)` Returns `true` if the receiver represents an `instantiable` value, else `false`.
`static boolean`	`isIterator(Object receiver)` Returns `true` if the receiver represents an iterator.
`static boolean`	`isMemberExisting(Object receiver, String member)` Returns true if the member is existing.
`static boolean`	`isMemberInsertable(Object receiver, String member)` Returns `true` if a given member is not existing and `writable`.
`static boolean`	`isMemberInvocable(Object receiver, String member)` Returns `true` if a given member is invocable.
`static boolean`	`isMemberModifiable(Object receiver, String member)` Returns `true` if a given member is existing and `writable`.
`static boolean`	`isMemberReadable(Object receiver, String member)` Returns `true` if a given member is `readable`.
`static boolean`	`isMemberRemovable(Object receiver, String member)` Returns `true` if a given member is existing and removable.
`static boolean`	`isMemberWritable(Object receiver, String member)` Returns true if the member is `modifiable` or `insertable`.
`static boolean`	`isMetaInstance(Object receiver, Object instance)` Returns `true` if the given instance is of the provided receiver metaobject, else `false`.
`static boolean`	`isMetaObject(Object receiver)` Returns `true` if the receiver value represents a metaobject.
`static boolean`	`isNull(Object receiver)` Returns `true` if the receiver represents a `null` like value, else `false`.
`static boolean`	`isNumber(Object receiver)` Returns `true` if the receiver represents a `number` value, else `false`.
`static boolean`	`isPointer(Object receiver)` Returns `true` if the receiver value represents a native pointer.
`static boolean`	`isString(Object receiver)` Returns `true` if the receiver represents a `string` value, else `false`.
`static Object`	`readArrayElement(Object receiver, long index)` Reads the value of an array element by index.
`static byte`	`readBufferByte(Object receiver, long byteOffset)` Reads the byte from the receiver object at the given byte offset from the start of the buffer.
`static double`	`readBufferDouble(Object receiver, ByteOrder order, long byteOffset)` Reads the double from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static float`	`readBufferFloat(Object receiver, ByteOrder order, long byteOffset)` Reads the float from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static int`	`readBufferInt(Object receiver, ByteOrder order, long byteOffset)` Reads the int from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static long`	`readBufferLong(Object receiver, ByteOrder order, long byteOffset)` Reads the long from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static short`	`readBufferShort(Object receiver, ByteOrder order, long byteOffset)` Reads the short from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static Object`	`readHashValue(Object receiver, Object key)` Reads the value for the specified key.
`static Object`	`readHashValueOrDefault(Object receiver, Object key, Object defaultValue)` Reads the value for the specified key or returns the `defaultValue` when the mapping for the specified key does not exist or is not readable.
`static Object`	`readMember(Object receiver, String member)` Reads the value of a given member.
`static void`	`removeArrayElement(Object receiver, long index)` Remove an array element from the receiver object.
`static void`	`removeHashEntry(Object receiver, Object key)` Removes the mapping for a given key from the receiver.
`static void`	`removeMember(Object receiver, String member)` Removes a member from the receiver object.
`static RuntimeException`	`throwException(Object receiver)` Throws the receiver object as an exception of the source language, as if it was thrown by the source language itself.
`static Object`	`toDisplayString(Object receiver)` Converts the receiver to a human readable `string` of the language.
`static Object`	`toDisplayString(Object receiver, boolean allowSideEffects)` Converts the receiver to a human readable `string`.
`static void`	`toNative(Object receiver)` Attempts to transform a receiver to a value that represents a raw native pointer.
`static void`	`writeArrayElement(Object receiver, long index, Object value)` Writes the value of an array element by index.
`static void`	`writeBufferByte(Object receiver, long byteOffset, byte value)` Writes the given byte from the receiver object at the given byte offset from the start of the buffer.
`static void`	`writeBufferDouble(Object receiver, ByteOrder order, long byteOffset, double value)` Writes the given double from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static void`	`writeBufferFloat(Object receiver, ByteOrder order, long byteOffset, float value)` Writes the given float from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static void`	`writeBufferInt(Object receiver, ByteOrder order, long byteOffset, int value)` Writes the given int from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static void`	`writeBufferLong(Object receiver, ByteOrder order, long byteOffset, long value)` Writes the given long from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static void`	`writeBufferShort(Object receiver, ByteOrder order, long byteOffset, short value)` Writes the given short from the receiver object in the given byte order at the given byte offset from the start of the buffer.
`static void`	`writeHashEntry(Object receiver, Object key, Object value)` Associates the specified value with the specified key in the receiver.
`static void`	`writeMember(Object receiver, String member, Object value)` Writes the value of a given member.

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - isNull
```
public static boolean isNull(Object receiver)
```
    Returns true if the receiver represents a null like value, else false. Most object oriented languages have one or many values representing null values. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true behave the same as Java null, but its identity is preserved.
    
    Since:
    
    21.0
  - isBoolean
```
public static boolean isBoolean(Object receiver)
```
    Returns true if the receiver represents a boolean like value, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as boolean or Boolean (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.asBoolean(Object)
  - asBoolean
```
public static boolean asBoolean(Object receiver)
                         throws UnsupportedMessageException
```
    Returns the Java boolean value if the receiver represents a boolean like value.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isBoolean(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isBoolean(Object)
  - isString
```
public static boolean isString(Object receiver)
```
    Returns true if the receiver represents a string value, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as String; in this particular case the the conversion is eager and does not preserves identity.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.asString(Object)
  - asString
```
public static String asString(Object receiver)
                       throws UnsupportedMessageException
```
    Returns the Java string value if the receiver represents a string like value.
    There's no guarantee about preserving or not the identity of foreign objects.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isString(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isString(Object)
  - isNumber
```
public static boolean isNumber(Object receiver)
```
    Returns true if the receiver represents a number value, else false. Invoking this message does not cause any observable side-effects.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.fitsInByte(Object), Interop.fitsInShort(Object), Interop.fitsInInt(Object), Interop.fitsInLong(Object), Interop.fitsInFloat(Object), Interop.fitsInDouble(Object), Interop.asByte(Object), Interop.asShort(Object), Interop.asInt(Object), Interop.asLong(Object), Interop.asFloat(Object), Interop.asDouble(Object)
  - fitsInByte
```
public static boolean fitsInByte(Object receiver)
```
    Returns true if the receiver represents a number and its value fits in a Java byte primitive without loss of precision, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as byte or Byte (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.asByte(Object)
  - fitsInShort
```
public static boolean fitsInShort(Object receiver)
```
    Returns true if the receiver represents a number and its value fits in a Java short primitive without loss of precision, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as short or Short (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.asShort(Object)
  - fitsInInt
```
public static boolean fitsInInt(Object receiver)
```
    Returns true if the receiver represents a number and its value fits in a Java int primitive without loss of precision, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as int or Integer (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.asInt(Object)
  - fitsInLong
```
public static boolean fitsInLong(Object receiver)
```
    Returns true if the receiver represents a number and its value fits in a Java long primitive without loss of precision, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as long or Long (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.asLong(Object)
  - fitsInFloat
```
public static boolean fitsInFloat(Object receiver)
```
    Returns true if the receiver represents a number and its value fits in a Java float primitive without loss of precision, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as float or Float (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.asFloat(Object)
  - fitsInDouble
```
public static boolean fitsInDouble(Object receiver)
```
    Returns true if the receiver represents a number and its value fits in a Java double primitive without loss of precision, else false. Invoking this message does not cause any observable side-effects. Foreign objects for which this method returns true, can be polyglot-casted as double or Double (casting to a boxed type always preserves identity).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.asDouble(Object)
  - asByte
```
public static byte asByte(Object receiver)
                   throws UnsupportedMessageException
```
    Returns the receiver value as Java byte primitive if the number fits without loss of precision. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver is not a Interop.isNumber(Object) or it does not fit without less of precision.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.fitsInByte(Object)
  - asShort
```
public static short asShort(Object receiver)
                     throws UnsupportedMessageException
```
    Returns the receiver value as Java short primitive if the number fits without loss of precision. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver is not a Interop.isNumber(Object) or it does not fit without less of precision.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.fitsInShort(Object)
  - asInt
```
public static int asInt(Object receiver)
                 throws UnsupportedMessageException
```
    Returns the receiver value as Java int primitive if the number fits without loss of precision. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver is not a Interop.isNumber(Object) or it does not fit without less of precision.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.fitsInInt(Object)
  - asLong
```
public static long asLong(Object receiver)
                   throws UnsupportedMessageException
```
    Returns the receiver value as Java long primitive if the number fits without loss of precision. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver is not a Interop.isNumber(Object) or it does not fit without less of precision.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.fitsInLong(Object)
  - asFloat
```
public static float asFloat(Object receiver)
                     throws UnsupportedMessageException
```
    Returns the receiver value as Java float primitive if the number fits without loss of precision. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver is not a Interop.isNumber(Object) or it does not fit without less of precision.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.fitsInFloat(Object)
  - asDouble
```
public static double asDouble(Object receiver)
                       throws UnsupportedMessageException
```
    Returns the receiver value as Java double primitive if the number fits without loss of precision. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver is not a Interop.isNumber(Object) or it does not fit without less of precision.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isNumber(Object), Interop.fitsInDouble(Object)
  - isException
```
public static boolean isException(Object receiver)
```
    Returns true if the receiver value represents a throwable exception/error. Invoking this message does not cause any observable side-effects. Returns false by default.
    Objects must only return true if they support Interop.throwException(java.lang.Object) as well. If this method is implemented then also Interop.throwException(Object) must be implemented. Foreign objects for which this method returns true, can be polyglot-casted as ForeignException; identity is preserved.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.throwException(Object)
  - throwException
```
public static RuntimeException throwException(Object receiver)
                                       throws UnsupportedMessageException
```
    Throws the receiver object as an exception of the source language, as if it was thrown by the source language itself. Allows rethrowing exceptions caught by another language. If this method is implemented then also Interop.isException(Object) must be implemented.
    Any interop value can be an exception value and export Interop.throwException(Object).
    Foreign exceptions thrown with this method can be caught as ForeignException. Note that ForeignException can only catch foreign exceptions. Native guest Java exceptions can also be thrown with this method.
```
 assert Interop.isException(foreignException);
 try {
     throw Interop.throwException(foreignException);
 } catch (ForeignException e) {
     log(e.getClass() + ": " + e.getMessage());
     ...
     throw e;
 }
 
```
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isException(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), ForeignException
  - getExceptionType
```
public static ExceptionType getExceptionType(Object receiver)
                                      throws UnsupportedMessageException
```
    Returns exception type of the receiver. Throws UnsupportedMessageException when the receiver is not an exception.
    
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), ExceptionType
  - isExceptionIncompleteSource
```
public static boolean isExceptionIncompleteSource(Object receiver)
                                           throws UnsupportedMessageException
```
    Returns true if receiver value represents an incomplete source exception. Throws UnsupportedMessageException when the receiver is not an exception or the exception is not a ExceptionType.PARSE_ERROR.
    
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.getExceptionType(Object)
  - getExceptionExitStatus
```
public static int getExceptionExitStatus(Object receiver)
                                  throws UnsupportedMessageException
```
    Returns exception exit status of the receiver. Throws UnsupportedMessageException when the receiver is not an exception of the exit type. A return value zero indicates that the execution of the application was successful, a non-zero value that it failed. The individual interpretation of non-zero values depends on the application.
    
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.getExceptionType(Object), ExceptionType
  - hasExceptionCause
```
public static boolean hasExceptionCause(Object receiver)
```
    Returns true if the receiver is an exception with an attached internal cause. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.getExceptionCause(Object)
  - getExceptionCause
```
public static Object getExceptionCause(Object receiver)
                                throws UnsupportedMessageException
```
    Returns the internal cause of the receiver. Throws UnsupportedMessageException when the receiver is not an exception or has no internal cause. The return value of this message is guaranteed to return true for Interop.isException(Object).
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.hasExceptionCause(Object)
  - hasExceptionMessage
```
public static boolean hasExceptionMessage(Object receiver)
```
    Returns true if the receiver is an exception that has an exception message. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.getExceptionMessage(Object)
  - getExceptionMessage
```
public static Object getExceptionMessage(Object receiver)
                                  throws UnsupportedMessageException
```
    Returns exception message of the receiver. Throws UnsupportedMessageException when the receiver is not an exception or has no exception message. The return value of this message is guaranteed to return true for Interop.isString(Object).
    The identity of the returned object is preserved, but its Java type is not necessarily String. The returned value could be a string originated in a foreign language, incompatible with Java's String e.g. rope, mutable, different encoding...
    To correctly convert to a Java String use Interop.asString:
```
 Object maybeForeign = Interop.toDisplayString(foreignObject, false);
 assert Interop.isString(maybeForeign);
 String displayString = Interop.asString(maybeForeign);
 
```
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.hasExceptionMessage(Object)
  - hasExceptionStackTrace
```
public static boolean hasExceptionStackTrace(Object receiver)
```
    Returns true if the receiver is an exception and has a stack trace. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.getExceptionStackTrace(Object)
  - getExceptionStackTrace
```
public static Object getExceptionStackTrace(Object receiver)
                                     throws UnsupportedMessageException
```
    Returns the exception stack trace of the receiver that is of type exception. Returns an array of objects with potentially executable name and declaring meta object of the caller. Throws UnsupportedMessageException when the receiver is not an exception or has no stack trace. Invoking this message or accessing the stack trace elements array must not cause any observable side-effects.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isException(Object), Interop.hasExceptionStackTrace(Object)
  - hasArrayElements
```
public static boolean hasArrayElements(Object receiver)
```
    Returns true if the receiver may have array elements. Therefore, At least one of Interop.readArrayElement(Object, long), Interop.writeArrayElement(Object, long, Object), Interop.removeArrayElement(Object, long) must not throw {#link UnsupportedMessageException. For example, the contents of an array or list datastructure could be interpreted as array elements. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.getArraySize(Object)
  - readArrayElement
```
public static Object readArrayElement(Object receiver,
                                      long index)
                               throws UnsupportedMessageException,
                                      InvalidArrayIndexException
```
    Reads the value of an array element by index. This method must have not observable side-effect.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    The user must convert the result to the expected type:
```
 Object value = Interop.readArrayElement(new int[]{42}, 0);
 assert Interop.fitsInInt(value);
 int intValue = Interop.asInt(value);
 
```
    Throws:
    
    UnsupportedMessageException - when the receiver does not support reading at all. An empty receiver with no readable array elements supports the read operation (even though there is nothing to read), therefore it throws UnknownIdentifierException for all arguments instead.
    
    InvalidArrayIndexException - if the given index is not readable, e.g. when the index is invalid or the index is out of bounds.
    
    Since:
    
    21.0
  - getArraySize
```
public static long getArraySize(Object receiver)
                         throws UnsupportedMessageException
```
    Returns the array size of the receiver.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasArrayElements(Object) returns false.
    
    Since:
    
    21.0
  - isArrayElementReadable
```
public static boolean isArrayElementReadable(Object receiver,
                                             long index)
```
    Returns true if a given array element is readable. This method may only return true if Interop.hasArrayElements(Object) returns true as well. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.readArrayElement(Object, long)
  - writeArrayElement
```
public static void writeArrayElement(Object receiver,
                                     long index,
                                     Object value)
                              throws UnsupportedMessageException,
                                     UnsupportedTypeException,
                                     InvalidArrayIndexException
```
    Writes the value of an array element by index. Writing an array element is allowed if is existing and modifiable, or not existing and insertable. This method must have not observable side-effects other than the changed array element.
    
    Throws:
    
    UnsupportedMessageException - when the receiver does not support writing at all, e.g. when it is immutable.
    
    InvalidArrayIndexException - if the given index is not insertable nor modifiable, e.g. when the index is invalid or the index is out of bounds and the array does not support growing.
    
    UnsupportedTypeException - if the provided value type is not allowed to be written.
    
    Since:
    
    21.0
  - removeArrayElement
```
public static void removeArrayElement(Object receiver,
                                      long index)
                               throws UnsupportedMessageException,
                                      InvalidArrayIndexException
```
    Remove an array element from the receiver object. Removing member is allowed if the array element is removable. This method may only return true if Interop.hasArrayElements(Object) returns true as well and Interop.isArrayElementInsertable(Object, long) returns false. This method does not have observable side-effects other than the removed array element and shift of remaining elements. If shifting is not supported then the array might allow only removal of last element.
    
    Throws:
    
    UnsupportedMessageException - when the receiver does not support removing at all, e.g. when it is immutable.
    
    InvalidArrayIndexException - if the given index is not removable, e.g. when the index is invalid, the index is out of bounds, or the array does not support shifting of remaining elements.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isArrayElementRemovable(Object, long)
  - isArrayElementModifiable
```
public static boolean isArrayElementModifiable(Object receiver,
                                               long index)
```
    Returns true if a given array element index is existing and writable. This method may only return true if Interop.hasArrayElements(Object) returns true as well and Interop.isArrayElementInsertable(Object, long) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.writeArrayElement(Object, long, Object), Interop.isArrayElementInsertable(Object, long)
  - isArrayElementInsertable
```
public static boolean isArrayElementInsertable(Object receiver,
                                               long index)
```
    Returns true if a given array element index is not existing and insertable. This method may only return true if Interop.hasArrayElements(Object) returns true as well and Interop.isArrayElementExisting(Object, long)} returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.writeArrayElement(Object, long, Object), Interop.isArrayElementModifiable(Object, long)
  - isArrayElementRemovable
```
public static boolean isArrayElementRemovable(Object receiver,
                                              long index)
```
    Returns true if a given array element index is existing and removable. This method may only return true if Interop.hasArrayElements(Object) returns true as well and Interop.isArrayElementInsertable(Object, long)} returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.removeArrayElement(Object, long)
  - isArrayElementWritable
```
public static boolean isArrayElementWritable(Object receiver,
                                             long index)
```
    Returns true if the array element is modifiable or insertable.
    
    Since:
    
    21.0
  - isArrayElementExisting
```
public static boolean isArrayElementExisting(Object receiver,
                                             long index)
```
    Returns true if the array element is existing. An array element is existing if it is, modifiable, readable or removable.
    
    Since:
    
    21.0
  - hasMetaObject
```
public static boolean hasMetaObject(Object receiver)
```
    Returns true if the receiver value has a metaobject associated. The metaobject represents a description of the object, reveals its kind and its features. Some information that a metaobject might define includes the base object's type, interface, class, methods, attributes, etc. Should return false when no metaobject is known for this type. Returns false by default.
    An example, for Java objects the returned metaobject is the class instance. In JavaScript this could be the function or class that is associated with the object.
    Metaobjects for primitive values or values of other languages may be provided using language views. While an object is associated with a metaobject in one language, the metaobject might be a different when viewed from another language.
    This method must not cause any observable side-effects. If this method is implemented then also Interop.getMetaObject(Object) must be implemented.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.getMetaObject(Object), Interop.isMetaObject(Object)
  - getMetaObject
```
public static Object getMetaObject(Object receiver)
                            throws UnsupportedMessageException
```
    Returns the metaobject that is associated with this value. The metaobject represents a description of the object, reveals its kind and its features. Some information that a metaobject might define includes the base object's type, interface, class, methods, attributes, etc. When no metaobject is known for this type. Throws UnsupportedMessageException by default.
    The returned object must return true for Interop.isMetaObject(Object) and provide implementations for Interop.getMetaSimpleName(Object), Interop.getMetaQualifiedName(Object), and Interop.isMetaInstance(Object, Object). For all values with metaobjects it must at hold that isMetaInstance(getMetaObject(value), value) == true.
    This method must not cause any observable side-effects. If this method is implemented then also Interop.hasMetaObject(Object) must be implemented.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasMetaObject(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.hasMetaObject(Object)
  - toDisplayString
```
public static Object toDisplayString(Object receiver,
                                     boolean allowSideEffects)
```
    Converts the receiver to a human readable string. Each language may have special formating conventions - even primitive values may not follow the traditional Java rules. The format of the returned string is intended to be interpreted by humans not machines and should therefore not be relied upon by machines. By default the receiver class name and its identity hash code is used as string representation.
    String representations for primitive values or values of other languages may be provided using language views. It is common that languages provide different string representations for primitive and foreign values. To convert the result value to a Java string use Interop.asString(Object).
    The identity of the returned object is preserved, but its Java type is not necessarily String. The returned value could be a string originated in a foreign language, incompatible with Java's String e.g. rope, mutable, different encoding...
    To correctly convert to a Java String use Interop.asString:
```
 Object maybeForeign = Interop.toDisplayString(foreignObject, false);
 assert Interop.isString(maybeForeign);
 String displayString = Interop.asString(maybeForeign);
 
```
    Parameters:
    
    allowSideEffects - whether side-effects are allowed in the production of the string.
    
    Since:
    
    21.0
  - toDisplayString
```
public static Object toDisplayString(Object receiver)
```
    Converts the receiver to a human readable string of the language. Short-cut for toDisplayString(true).
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.toDisplayString(Object, boolean)
  - isMetaObject
```
public static boolean isMetaObject(Object receiver)
```
    Returns true if the receiver value represents a metaobject. Metaobjects may be values that naturally occur in a language or they may be returned by Interop.getMetaObject(Object). A metaobject represents a description of the object, reveals its kind and its features. If a receiver is a metaobject it is often also instantiable, but this is not a requirement.
    Sample interpretations: In Java an instance of the type Class is a metaobject. In JavaScript any function instance is a metaobject. For example, the metaobject of a JavaScript class is the associated constructor function.
    This method must not cause any observable side-effects. If this method is implemented then also Interop.getMetaQualifiedName(Object), Interop.getMetaSimpleName(Object) and Interop.isMetaInstance(Object, Object) must be implemented as well.
    
    Since:
    
    21.0
  - getMetaQualifiedName
```
public static Object getMetaQualifiedName(Object metaObject)
                                   throws UnsupportedMessageException
```
    Returns the qualified name of a metaobject as string.
    Sample interpretations: The qualified name of a Java class includes the package name and its class name. JavaScript does not have the notion of qualified name and therefore returns the simple name instead.
    This method must not cause any observable side-effects. If this method is implemented then also Interop.isMetaObject(Object) must be implemented as well.
    The identity of the returned object is preserved, but its Java type is not necessarily String. The returned value could be a string originated in a foreign language, incompatible with Java's String e.g. rope, mutable, different encoding...
    To correctly convert to a Java String use Interop.asString:
```
 Object maybeForeign = Interop.getMetaQualifiedName(foreignObject);
 assert Interop.isString(maybeForeign);
 String metaQualifiedName = Interop.asString(maybeForeign);
 
```
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isMetaObject(Object) returns false for the same receiver.
    
    Since:
    
    21.0
  - getMetaSimpleName
```
public static Object getMetaSimpleName(Object metaObject)
                                throws UnsupportedMessageException
```
    Returns the simple name of a metaobject as string.
    Sample interpretations: The simple name of a Java class is the class name.
    This method must not cause any observable side-effects. If this method is implemented then also Interop.isMetaObject(Object) must be implemented as well.
    The identity of the returned object is preserved, but its Java type is not necessarily String. The returned value could be a string originated in a foreign language, incompatible with Java's String e.g. rope, mutable, different encoding...
    To correctly convert to a Java String use Interop.asString:
```
 Object maybeForeign = Interop.getMetaSimpleName(foreignObject);
 assert Interop.isString(maybeForeign);
 String metaSimpleName = Interop.asString(maybeForeign);
 
```
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isMetaObject(Object) returns false for the same receiver.
    
    Since:
    
    21.0
  - isMetaInstance
```
public static boolean isMetaInstance(Object receiver,
                                     Object instance)
                              throws UnsupportedMessageException
```
    Returns true if the given instance is of the provided receiver metaobject, else false.
    Sample interpretations: A Java object is an instance of its returned class.
    This method must not cause any observable side-effects. If this method is implemented then also Interop.isMetaObject(Object) must be implemented as well.
    
    Parameters:
    
    instance - the instance object to check.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isMetaObject(Object) returns false for the same receiver.
    
    Since:
    
    21.0
  - isIdentical
```
public static boolean isIdentical(Object receiver,
                                  Object other)
```
    Returns true if two values represent the identical value, else false. Two values are identical if and only if they have specified identity semantics in the target language and refer to the identical instance.
    By default, an interop value does not support identical comparisons, and will return false for any invocation of this method. Use Interop.hasIdentity(Object) to find out whether a receiver supports identity comparisons.
    This method has the following properties:
    - It is not reflexive: for any value x, Interop.isIdentical(x, x) may return false if the object does not support identity, else true. This method is reflexive if x supports identity. A value supports identity if Interop.isIdentical(x, x) returns true. The method Interop.hasIdentity(Object) may be used to document this intent explicitly.
    - It is symmetric: for any values x and y, Interop.isIdentical(x, y) returns true if and only if Interop.isIdentical(y, x) returns true.
    - It is transitive: for any values x, y, and z, if Interop.isIdentical(x, y) returns true and Interop.isIdentical(y, z) returns true, then Interop.isIdentical(x, z) returns true.
    - It is consistent: for any values x and y, multiple invocations of Interop.isIdentical(x, y) consistently returns true or consistently return false.
    Note that the target language identical semantics typically does not map directly to interop identical implementation. Instead target language identity is specified by the language operation, may take multiple other rules into account and may only fallback to interop identical for values without dedicated interop type. For example, in many languages primitives like numbers or strings may be identical, in the target language sense, still identity can only be exposed for objects and non-primitive values. Primitive values like Integer can never be interop identical to other boxed language integers as this would violate the symmetric property.
    This method performs double dispatch by forwarding calls to isIdenticalOrUndefined with receiver and other value first and then with reversed parameters if the result was undefined. This allows the receiver and the other value to negotiate identity semantics.
    This method must not cause any observable side-effects.
    Since:
    
    21.0
  - hasIdentity
```
public static boolean hasIdentity(Object receiver)
```
    Returns true if and only if the receiver specifies identity, else false. This method is a short-cut for isIdentical(receiver, receiver). This message cannot be exported. To add identity support to the receiver export isIdenticalOrUndefined(Object, Object) instead.
    
    Since:
    
    21.0
  - identityHashCode
```
public static int identityHashCode(Object receiver)
                            throws UnsupportedMessageException
```
    Returns an identity hash code for the receiver if it has identity. If the receiver has no identity then an UnsupportedMessageException is thrown. The identity hash code may be used by languages to store foreign values with identity in an identity hash map.
    - Whenever it is invoked on the same object more than once during an execution of a guest context, the identityHashCode method must consistently return the same integer. This integer need not remain consistent from one execution context of a guest application to another execution context of the same application.
    - If two objects are the same according to the Interop.isIdentical(Object, Object) message, then calling the identityHashCode method on each of the two objects must produce the same integer result.
    - As much as is reasonably practical, the identityHashCode message does return distinct integers for objects that are not the same.
    This method must not cause any observable side-effects. If this method is implemented then also isIdenticalOrUndefined(Object, Object) must be implemented.
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasIdentity(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isIdentical(Object, Object)
  - hasMembers
```
public static boolean hasMembers(Object receiver)
```
    Returns true if the receiver may have members. Therefore, at least one of Interop.readMember(Object, String), Interop.writeMember(Object, String, Object), Interop.removeMember(Object, String), Interop.invokeMember(Object, String, Object...) must not throw UnsupportedMessageException. Members are structural elements of a class. For example, a method or field is a member of a class. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.getMembers(Object), Interop.isMemberReadable(Object, String), Interop.isMemberModifiable(Object, String), Interop.isMemberInvocable(Object, String), Interop.isMemberInsertable(Object, String), Interop.isMemberRemovable(Object, String), Interop.readMember(Object, String), Interop.writeMember(Object, String, Object), Interop.removeMember(Object, String), Interop.invokeMember(Object, String, Object...)
  - getMembers
```
public static Object getMembers(Object receiver)
                         throws UnsupportedMessageException
```
    Returns an array of member name strings. The returned value must return true for Interop.hasArrayElements(Object) and every array element must be of type string.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedMessageException - if and only if the receiver does not have any members.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.hasMembers(Object)
  - isMemberReadable
```
public static boolean isMemberReadable(Object receiver,
                                       String member)
```
    Returns true if a given member is readable. This method may only return true if Interop.hasMembers(Object) returns true as well and Interop.isMemberInsertable(Object, String) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.readMember(Object, String)
  - readMember
```
public static Object readMember(Object receiver,
                                String member)
                         throws UnsupportedMessageException,
                                UnknownIdentifierException
```
    Reads the value of a given member. If the member is readable and invocable then the result of reading the member is executable and is bound to this receiver. This method must have not observable side-effects unless Interop.hasMemberReadSideEffects(Object, String) returns true.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedMessageException - if when the receiver does not support reading at all. An empty receiver with no readable members supports the read operation (even though there is nothing to read), therefore it throws UnknownIdentifierException for all arguments instead.
    
    UnknownIdentifierException - if the given member is not readable, e.g. when the member with the given name does not exist.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.hasMemberReadSideEffects(Object, String)
  - isMemberModifiable
```
public static boolean isMemberModifiable(Object receiver,
                                         String member)
```
    Returns true if a given member is existing and writable. This method may only return true if Interop.hasMembers(Object) returns true as well and Interop.isMemberInsertable(Object, String) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.writeMember(Object, String, Object)
  - isMemberInsertable
```
public static boolean isMemberInsertable(Object receiver,
                                         String member)
```
    Returns true if a given member is not existing and writable. This method may only return true if Interop.hasMembers(Object) returns true as well and Interop.isMemberExisting(Object, String) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.writeMember(Object, String, Object)
  - writeMember
```
public static void writeMember(Object receiver,
                               String member,
                               Object value)
                        throws UnsupportedMessageException,
                               UnknownIdentifierException,
                               UnsupportedTypeException
```
    Writes the value of a given member. Writing a member is allowed if is existing and modifiable, or not existing and insertable. This method must have not observable side-effects other than the changed member unless side-effects are allowed.
    
    Throws:
    
    UnsupportedMessageException - when the receiver does not support writing at all, e.g. when it is immutable.
    
    UnknownIdentifierException - if the given member is not modifiable nor insertable.
    
    UnsupportedTypeException - if the provided value type is not allowed to be written.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.hasMemberWriteSideEffects(Object, String)
  - isMemberRemovable
```
public static boolean isMemberRemovable(Object receiver,
                                        String member)
```
    Returns true if a given member is existing and removable. This method may only return true if Interop.hasMembers(Object) returns true as well and Interop.isMemberInsertable(Object, String) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.removeMember(Object, String)
  - removeMember
```
public static void removeMember(Object receiver,
                                String member)
                         throws UnsupportedMessageException,
                                UnknownIdentifierException
```
    Removes a member from the receiver object. Removing member is allowed if is removable. This method does not have not observable side-effects other than the removed member.
    
    Throws:
    
    UnsupportedMessageException - when the receiver does not support removing at all, e.g. when it is immutable.
    
    UnknownIdentifierException - if the given member is not Interop.isMemberRemovable(Object, String) removable}, e.g. the receiver does not have a member with the given name.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isMemberRemovable(Object, String)
  - isMemberInvocable
```
public static boolean isMemberInvocable(Object receiver,
                                        String member)
```
    Returns true if a given member is invocable. This method may only return true if Interop.hasMembers(Object) returns true as well and Interop.isMemberInsertable(Object, String) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.invokeMember(Object, String, Object...)
  - invokeMember
```
public static Object invokeMember(Object receiver,
                                  String member,
                                  Object... arguments)
                           throws UnsupportedMessageException,
                                  ArityException,
                                  UnknownIdentifierException,
                                  UnsupportedTypeException
```
    Invokes a member for a given receiver and arguments.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnknownIdentifierException - if the given member does not exist or is not invocable.
    
    UnsupportedTypeException - if one of the arguments is not compatible to the executable signature. The exception is thrown on best effort basis, dynamic languages may throw their own exceptions if the arguments are wrong.
    
    ArityException - if the number of expected arguments does not match the number of actual arguments.
    
    UnsupportedMessageException - when the receiver does not support invoking at all, e.g. when storing executable members is not allowed.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isMemberInvocable(Object, String)
  - isMemberWritable
```
public static boolean isMemberWritable(Object receiver,
                                       String member)
```
    Returns true if the member is modifiable or insertable.
    
    Since:
    
    21.0
  - isMemberExisting
```
public static boolean isMemberExisting(Object receiver,
                                       String member)
```
    Returns true if the member is existing. A member is existing if it is modifiable, readable, removable or invocable.
    
    Since:
    
    21.0
  - hasMemberReadSideEffects
```
public static boolean hasMemberReadSideEffects(Object receiver,
                                               String member)
```
    Returns true if reading a member may cause a side-effect. Invoking this message does not cause any observable side-effects. A member read does not cause any side-effects by default.
    For instance in JavaScript a property read may have side-effects if the property has a getter function.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.readMember(Object, String)
  - hasMemberWriteSideEffects
```
public static boolean hasMemberWriteSideEffects(Object receiver,
                                                String member)
```
    Returns true if writing a member may cause a side-effect, besides the write operation of the member. Invoking this message does not cause any observable side-effects. A member write does not cause any side-effects by default.
    For instance in JavaScript a property write may have side-effects if the property has a setter function.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.writeMember(Object, String, Object)
  - isPointer
```
public static boolean isPointer(Object receiver)
```
    Returns true if the receiver value represents a native pointer. Native pointers are represented as 64 bit pointers. Invoking this message does not cause any observable side-effects. Returns false by default.
    It is expected that objects should only return true if the native pointer value corresponding to this object already exists, and obtaining it is a cheap operation. If an object can be transformed to a pointer representation, but this hasn't happened yet, the object is expected to return false with Interop.isPointer(Object), and wait for the Interop.toNative(Object) message to trigger the transformation.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.asPointer(Object), Interop.toNative(Object)
  - asPointer
```
public static long asPointer(Object receiver)
                      throws UnsupportedMessageException
```
    Returns the pointer value as long value if the receiver represents a pointer like value.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isPointer(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isPointer(Object)
  - toNative
```
public static void toNative(Object receiver)
```
    Attempts to transform a receiver to a value that represents a raw native pointer. After a successful transformation, the provided receiver returns true for Interop.isPointer(Object) and can be unwrapped using the Interop.asPointer(Object) message. If transformation cannot be done Interop.isPointer(Object) will keep returning false.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isPointer(Object), Interop.asPointer(Object)
  - isExecutable
```
public static boolean isExecutable(Object receiver)
```
    Returns true if the receiver represents an executable value, else false. Functions, methods or closures are common examples of executable values. Invoking this message does not cause any observable side-effects. Note that receiver values which are executable might also be instantiable.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.execute(Object, Object...)
  - execute
```
public static Object execute(Object receiver,
                             Object... arguments)
                      throws UnsupportedTypeException,
                             ArityException,
                             UnsupportedMessageException
```
    Executes an executable value with the given arguments.
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedTypeException - if one of the arguments is not compatible to the executable signature. The exception is thrown on best effort basis, dynamic languages may throw their own exceptions if the arguments are wrong.
    
    ArityException - if the number of expected arguments does not match the number of actual arguments.
    
    UnsupportedMessageException - if and only if Interop.isExecutable(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isExecutable(Object)
  - isInstantiable
```
public static boolean isInstantiable(Object receiver)
```
    Returns true if the receiver represents an instantiable value, else false. Contructors or metaobjects are typical examples of instantiable values. Invoking this message does not cause any observable side-effects. Note that receiver values which are executable might also be instantiable.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.instantiate(Object, Object...), Interop.isMetaObject(Object)
  - instantiate
```
public static Object instantiate(Object receiver,
                                 Object... arguments)
                          throws UnsupportedTypeException,
                                 ArityException,
                                 UnsupportedMessageException
```
    Instantiates the receiver value with the given arguments. The returned object must be initialized correctly according to the language specification (e.g. by calling the constructor or initialization routine).
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedTypeException - if one of the arguments is not compatible to the executable signature
    
    ArityException - if the number of expected arguments does not match the number of actual arguments.
    
    UnsupportedMessageException - if and only if Interop.isInstantiable(Object) returns false for the same receiver.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.isExecutable(Object)
  - hasExecutableName
```
public static boolean hasExecutableName(Object receiver)
```
    Returns true if the receiver has an executable name. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.getExecutableName(Object)
  - getExecutableName
```
public static Object getExecutableName(Object receiver)
                                throws UnsupportedMessageException
```
    Returns executable name of the receiver. Throws UnsupportedMessageException when the receiver is has no executable name. The return value is an interop value that is guaranteed to return true for Interop.isString(Object).
    The identity of the returned object is preserved, but its Java type is not necessarily String. The returned value could be a string originated in a foreign language, incompatible with Java's String e.g. rope, mutable, different encoding...
    To correctly convert to a Java String use Interop.asString:
```
 Object maybeForeign = Interop.getExecutableName(foreignObject);
 assert Interop.isString(maybeForeign);
 String executableName = Interop.asString(maybeForeign);
 
```
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.hasExecutableName(Object)
  - hasDeclaringMetaObject
```
public static boolean hasDeclaringMetaObject(Object receiver)
```
    Returns true if the receiver has a declaring meta object. The declaring meta object is the meta object of the executable or meta object that declares the receiver value. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.getDeclaringMetaObject(Object)
  - getDeclaringMetaObject
```
public static Object getDeclaringMetaObject(Object receiver)
                                     throws UnsupportedMessageException
```
    Returns declaring meta object. The declaring meta object is the meta object of declaring executable or meta object. Throws UnsupportedMessageException when the receiver is has no declaring meta object. The return value is an interop value that is guaranteed to return true for Interop.isMetaObject(Object).
    The identity of the returned value is guaranteed to be preserved but it cannot be assumed that the returned value will have a specific Java type.
    
    Throws:
    
    UnsupportedMessageException
    
    Since:
    
    21.0
    
    See Also:
    
    Interop.hasDeclaringMetaObject(Object)
  - hasBufferElements
```
public static boolean hasBufferElements(Object receiver)
```
    Returns true if the receiver may have buffer elements.
    If this message returns true, then Interop.getBufferSize(Object), Interop.readBufferByte(Object, long), Interop.readBufferShort(Object, ByteOrder, long), Interop.readBufferInt(Object, ByteOrder, long), Interop.readBufferLong(Object, ByteOrder, long), Interop.readBufferFloat(Object, ByteOrder, long) and Interop.readBufferDouble(Object, ByteOrder, long) must not throw UnsupportedMessageException.
    Invoking this message does not cause any observable side-effects.
    By default, it returns false.
    
    Since:
    
    21.1
  - isBufferWritable
```
public static boolean isBufferWritable(Object receiver)
                                throws UnsupportedMessageException
```
    Returns true if the receiver is a modifiable buffer.
    If this message returns true, then Interop.getBufferSize(Object), Interop.writeBufferByte(Object, long, byte), Interop.writeBufferShort(Object, ByteOrder, long, short), Interop.writeBufferInt(Object, ByteOrder, long, int), Interop.writeBufferLong(Object, ByteOrder, long, long), Interop.writeBufferFloat(Object, ByteOrder, long, float) and Interop.writeBufferDouble(Object, ByteOrder, long, double) must not throw UnsupportedMessageException.
    Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - getBufferSize
```
public static long getBufferSize(Object receiver)
                          throws UnsupportedMessageException
```
    Returns the buffer size of the receiver, in bytes.
    Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - readBufferByte
```
public static byte readBufferByte(Object receiver,
                                  long byteOffset)
                           throws UnsupportedMessageException,
                                  InvalidBufferOffsetException
```
    Reads the byte from the receiver object at the given byte offset from the start of the buffer.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    Invoking this message does not cause any observable side-effects.
    
    Returns:
    
    the byte at the given index
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object)
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) returns false returns false
    
    Since:
    
    21.1
  - writeBufferByte
```
public static void writeBufferByte(Object receiver,
                                   long byteOffset,
                                   byte value)
                            throws UnsupportedMessageException,
                                   InvalidBufferOffsetException
```
    Writes the given byte from the receiver object at the given byte offset from the start of the buffer.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object)
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) or Interop.isBufferWritable(java.lang.Object) returns false
    
    Since:
    
    21.1
  - readBufferShort
```
public static short readBufferShort(Object receiver,
                                    ByteOrder order,
                                    long byteOffset)
                             throws UnsupportedMessageException,
                                    InvalidBufferOffsetException
```
    Reads the short from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    Invoking this message does not cause any observable side-effects.
    
    Returns:
    
    the short at the given byte offset from the start of the buffer
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 1
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - writeBufferShort
```
public static void writeBufferShort(Object receiver,
                                    ByteOrder order,
                                    long byteOffset,
                                    short value)
                             throws UnsupportedMessageException,
                                    InvalidBufferOffsetException
```
    Writes the given short from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 1
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) or Interop.isBufferWritable(java.lang.Object) returns false
    
    Since:
    
    21.1
  - readBufferInt
```
public static int readBufferInt(Object receiver,
                                ByteOrder order,
                                long byteOffset)
                         throws UnsupportedMessageException,
                                InvalidBufferOffsetException
```
    Reads the int from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    Invoking this message does not cause any observable side-effects.
    
    Returns:
    
    the int at the given byte offset from the start of the buffer
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 3
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - writeBufferInt
```
public static void writeBufferInt(Object receiver,
                                  ByteOrder order,
                                  long byteOffset,
                                  int value)
                           throws UnsupportedMessageException,
                                  InvalidBufferOffsetException
```
    Writes the given int from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 3
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) or Interop.isBufferWritable(java.lang.Object) returns false
    
    Since:
    
    21.1
  - readBufferLong
```
public static long readBufferLong(Object receiver,
                                  ByteOrder order,
                                  long byteOffset)
                           throws UnsupportedMessageException,
                                  InvalidBufferOffsetException
```
    Reads the long from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    Invoking this message does not cause any observable side-effects.
    
    Returns:
    
    the int at the given byte offset from the start of the buffer
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 7
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - writeBufferLong
```
public static void writeBufferLong(Object receiver,
                                   ByteOrder order,
                                   long byteOffset,
                                   long value)
                            throws UnsupportedMessageException,
                                   InvalidBufferOffsetException
```
    Writes the given long from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 7
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) or Interop.isBufferWritable(java.lang.Object) returns false
    
    Since:
    
    21.1
  - readBufferFloat
```
public static float readBufferFloat(Object receiver,
                                    ByteOrder order,
                                    long byteOffset)
                             throws UnsupportedMessageException,
                                    InvalidBufferOffsetException
```
    Reads the float from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    Invoking this message does not cause any observable side-effects.
    
    Returns:
    
    the float at the given byte offset from the start of the buffer
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 3
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - writeBufferFloat
```
public static void writeBufferFloat(Object receiver,
                                    ByteOrder order,
                                    long byteOffset,
                                    float value)
                             throws UnsupportedMessageException,
                                    InvalidBufferOffsetException
```
    Writes the given float from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 3
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) or Interop.isBufferWritable(java.lang.Object) returns false
    
    Since:
    
    21.1
  - readBufferDouble
```
public static double readBufferDouble(Object receiver,
                                      ByteOrder order,
                                      long byteOffset)
                               throws UnsupportedMessageException,
                                      InvalidBufferOffsetException
```
    Reads the double from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    Invoking this message does not cause any observable side-effects.
    
    Returns:
    
    the double at the given byte offset from the start of the buffer
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 7
    
    UnsupportedMessageException - if and only if Interop.hasBufferElements(Object) returns false
    
    Since:
    
    21.1
  - writeBufferDouble
```
public static void writeBufferDouble(Object receiver,
                                     ByteOrder order,
                                     long byteOffset,
                                     double value)
                              throws UnsupportedMessageException,
                                     InvalidBufferOffsetException
```
    Writes the given double from the receiver object in the given byte order at the given byte offset from the start of the buffer.
    Unaligned accesses are supported.
    The access is not guaranteed to be atomic. Therefore, this message is not thread-safe.
    
    Throws:
    
    InvalidBufferOffsetException - if and only if byteOffset < 0 || byteOffset >= Interop.getBufferSize(Object) - 7
    
    UnsupportedMessageException - if and only if either Interop.hasBufferElements(Object) or Interop.isBufferWritable(java.lang.Object) returns false
    
    Since:
    
    21.1
  - hasIterator
```
public static boolean hasIterator(Object receiver)
```
    Returns true if the receiver provides an iterator. For example, an array or a list provide an iterator over their content. Invoking this message does not cause any observable side-effects. By default returns true for receivers that have array elements.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.getIterator(Object)
  - getIterator
```
public static Object getIterator(Object receiver)
                          throws UnsupportedMessageException
```
    Returns the iterator for the receiver. The return value is always an iterator. Invoking this message does not cause any observable side-effects.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasIterator(Object) returns false for the same receiver.
    
    Since:
    
    21.1
  - isIterator
```
public static boolean isIterator(Object receiver)
```
    Returns true if the receiver represents an iterator. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.hasIterator(Object), Interop.getIterator(Object)
  - hasIteratorNextElement
```
public static boolean hasIteratorNextElement(Object receiver)
                                      throws UnsupportedMessageException
```
    Returns true if the receiver is an iterator which has more elements, else false. Multiple calls to the Interop.hasIteratorNextElement(Object) might lead to different results if the underlying data structure is modified.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.isIterator(Object) returns false for the same receiver.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.isIterator(Object), Interop.getIteratorNextElement(Object)
  - getIteratorNextElement
```
public static Object getIteratorNextElement(Object receiver)
                                     throws UnsupportedMessageException,
                                            StopIterationException
```
    Returns the next element in the iteration. When the underlying data structure is modified the Interop.getIteratorNextElement(Object) may throw the StopIterationException despite the Interop.hasIteratorNextElement(Object) returned true.
    
    Throws:
    
    UnsupportedMessageException - if Interop.isIterator(Object) returns false for the same receiver or when the underlying iterator element exists but is not readable.
    
    StopIterationException - if the iteration has no more elements. Even if the StopIterationException was thrown it might not be thrown again by a next Interop.getIteratorNextElement(Object) invocation on the same receiver due to a modification of an underlying iterable.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.isIterator(Object), Interop.hasIteratorNextElement(Object)
  - hasHashEntries
```
public static boolean hasHashEntries(Object receiver)
```
    Returns true if the receiver may have hash entries. Therefore, at least one of Interop.readHashValue(Object, Object), Interop.writeHashEntry(Object, Object, Object), Interop.removeHashEntry(Object, Object) must not throw UnsupportedMessageException. For example, the contents of a map data structure could be interpreted as hash elements. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.getHashEntriesIterator(Object), Interop.getHashSize(Object), Interop.isHashEntryReadable(Object, Object), Interop.isHashEntryWritable(Object, Object), Interop.isHashEntryInsertable(Object, Object), Interop.isHashEntryRemovable(Object, Object), Interop.readHashValue(Object, Object), Interop.readHashValueOrDefault(Object, Object, Object), Interop.writeHashEntry(Object, Object, Object), Interop.removeHashEntry(Object, Object)
  - getHashSize
```
public static long getHashSize(Object receiver)
                        throws UnsupportedMessageException
```
    Returns the number of receiver entries.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasHashEntries(Object) returns false.
    
    Since:
    
    21.1
  - isHashEntryReadable
```
public static boolean isHashEntryReadable(Object receiver,
                                          Object key)
```
    Returns true if mapping for the specified key exists and is readable. This method may only return true if Interop.hasHashEntries(Object) returns true as well and Interop.isHashEntryInsertable(Object, Object) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.readHashValue(Object, Object)
  - readHashValue
```
public static Object readHashValue(Object receiver,
                                   Object key)
                            throws UnsupportedMessageException,
                                   UnknownKeyException
```
    Reads the value for the specified key.
    
    Throws:
    
    UnsupportedMessageException - if the receiver does not support reading at all. An empty receiver with no readable hash entries supports the read operation (even though there is nothing to read), therefore it throws UnknownKeyException for all arguments instead.
    
    UnknownKeyException - if mapping for the specified key is not readable, e.g. when the hash does not contain specified key.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.isHashEntryReadable(Object, Object), Interop.readHashValueOrDefault(Object, Object, Object)
  - readHashValueOrDefault
```
public static Object readHashValueOrDefault(Object receiver,
                                            Object key,
                                            Object defaultValue)
                                     throws UnsupportedMessageException
```
    Reads the value for the specified key or returns the defaultValue when the mapping for the specified key does not exist or is not readable.
    
    Throws:
    
    UnsupportedMessageException - if the receiver does not support reading at all. An empty receiver with no readable hash entries supports the read operation (even though there is nothing to read), therefore it returns the defaultValue for all arguments instead.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.isHashEntryReadable(Object, Object), Interop.readHashValue(Object, Object)
  - isHashEntryModifiable
```
public static boolean isHashEntryModifiable(Object receiver,
                                            Object key)
```
    Returns true if mapping for the specified key exists and is writable. This method may only return true if Interop.hasHashEntries(Object) returns true as well and Interop.isHashEntryInsertable(Object, Object) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.writeHashEntry(Object, Object, Object)
  - isHashEntryInsertable
```
public static boolean isHashEntryInsertable(Object receiver,
                                            Object key)
```
    Returns true if mapping for the specified key does not exist and is writable. This method may only return true if Interop.hasHashEntries(Object) returns true as well and Interop.isHashEntryExisting(Object, Object) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.writeHashEntry(Object, Object, Object)
  - isHashEntryWritable
```
public static boolean isHashEntryWritable(Object receiver,
                                          Object key)
```
    Returns true if mapping for the specified key is modifiable or insertable.
    
    Since:
    
    21.1
  - writeHashEntry
```
public static void writeHashEntry(Object receiver,
                                  Object key,
                                  Object value)
                           throws UnsupportedMessageException,
                                  UnknownKeyException,
                                  UnsupportedTypeException
```
    Associates the specified value with the specified key in the receiver. Writing the entry is allowed if is existing and modifiable, or not existing and insertable.
    
    Throws:
    
    UnsupportedMessageException - when the receiver does not support writing at all, e.g. when it is immutable.
    
    UnknownKeyException - if mapping for the specified key is not modifiable nor insertable.
    
    UnsupportedTypeException - if the provided key type or value type is not allowed to be written.
    
    Since:
    
    21.1
  - isHashEntryRemovable
```
public static boolean isHashEntryRemovable(Object receiver,
                                           Object key)
```
    Returns true if mapping for the specified key exists and is removable. This method may only return true if Interop.hasHashEntries(Object) returns true as well and Interop.isHashEntryInsertable(Object, Object) returns false. Invoking this message does not cause any observable side-effects. Returns false by default.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.removeHashEntry(Object, Object)
  - removeHashEntry
```
public static void removeHashEntry(Object receiver,
                                   Object key)
                            throws UnsupportedMessageException,
                                   UnknownKeyException
```
    Removes the mapping for a given key from the receiver. Mapping removing is allowed if it is removable.
    
    Throws:
    
    UnsupportedMessageException - when the receiver does not support removing at all, e.g. when it is immutable.
    
    UnknownKeyException - if the given mapping is not removable, e.g. the receiver does not have a mapping for given key.
    
    Since:
    
    21.1
    
    See Also:
    
    Interop.isHashEntryRemovable(Object, Object)
  - isHashEntryExisting
```
public static boolean isHashEntryExisting(Object receiver,
                                          Object key)
```
    Returns true if mapping for a given key is existing. The mapping is existing if it is modifiable, readable or removable.
    
    Since:
    
    21.1
  - getHashEntriesIterator
```
public static Object getHashEntriesIterator(Object receiver)
                                     throws UnsupportedMessageException
```
    Returns the hash entries iterator for the receiver. The return value is always an iterator of array elements. The first array element is a key, the second array element is an associated value. Array returned by the iterator may be modifiable but detached from the hash, updating the array elements may not update the hash. So even if array elements are modifiable always use Interop.writeHashEntry(Object, Object, Object) to update the hash mapping.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasHashEntries(Object) returns false for the same receiver.
    
    Since:
    
    21.1
  - getHashKeysIterator
```
public static Object getHashKeysIterator(Object receiver)
                                  throws UnsupportedMessageException
```
    Returns the hash keys iterator for the receiver. The return value is always an iterator.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasHashEntries(Object) returns false for the same receiver.
    
    Since:
    
    21.1
  - getHashValuesIterator
```
public static Object getHashValuesIterator(Object receiver)
                                    throws UnsupportedMessageException
```
    Returns the hash values iterator for the receiver. The return value is always an iterator.
    
    Throws:
    
    UnsupportedMessageException - if and only if Interop.hasHashEntries(Object) returns false for the same receiver.
    
    Since:
    
    21.1

Class Interop

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isNull

isBoolean

asBoolean

isString

asString

isNumber

fitsInByte

fitsInShort

fitsInInt

fitsInLong

fitsInFloat

fitsInDouble

asByte

asShort

asInt

asLong

asFloat

asDouble

isException

throwException

getExceptionType

isExceptionIncompleteSource

getExceptionExitStatus

hasExceptionCause

getExceptionCause

hasExceptionMessage

getExceptionMessage

hasExceptionStackTrace

getExceptionStackTrace

hasArrayElements

readArrayElement

getArraySize

isArrayElementReadable

writeArrayElement

removeArrayElement

isArrayElementModifiable

isArrayElementInsertable

isArrayElementRemovable

isArrayElementWritable

isArrayElementExisting

hasMetaObject

getMetaObject

toDisplayString

toDisplayString

isMetaObject

getMetaQualifiedName

getMetaSimpleName

isMetaInstance

isIdentical

hasIdentity

identityHashCode

hasMembers

getMembers

isMemberReadable

readMember

isMemberModifiable

isMemberInsertable

writeMember

isMemberRemovable

removeMember

isMemberInvocable

invokeMember

isMemberWritable

isMemberExisting

hasMemberReadSideEffects

hasMemberWriteSideEffects

isPointer

asPointer

toNative

isExecutable

execute

isInstantiable

instantiate

hasExecutableName

getExecutableName

hasDeclaringMetaObject