Java Code Examples for jdk.nashorn.internal.runtime.arrays.ArrayIndex#getArrayIndex()

@Override
public void set(final int key, final long value, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(key);

    if (ArrayIndex.isValidArrayIndex(index)) {
        if (getArray().has(index)) {
            setArray(getArray().set(index, value, strict));
        } else {
            doesNotHave(index, value, strict);
        }

        return;
    }

    set(JSType.toObject(key), JSType.toObject(value), strict);
}
 

@Override
public boolean has(final double key) {
    final int index = ArrayIndex.getArrayIndex(key);

    if (ArrayIndex.isValidArrayIndex(index)) {
        for (ScriptObject self = this; self != null; self = self.getProto()) {
            if (self.getArray().has(index)) {
                return true;
            }
        }
    }

    final FindProperty find = findProperty(JSType.toString(key), true);

    return find != null;
}
 

@Override
public Object get(final Object key) {
    final Object primitiveKey = JSType.toPrimitive(key, String.class);
    final int index = ArrayIndex.getArrayIndex(primitiveKey);
    if (index >= 0 && index < value.length()) {
        return String.valueOf(value.charAt(index));
    }
    return super.get(primitiveKey);
}
 

private static void setPropertyValue(final ScriptObject sobj, final String name, final Object value, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(name);
    if (ArrayIndex.isValidArrayIndex(index)) {
        // array index key
        sobj.defineOwnProperty(index, value);
    } else if (sobj.getMap().findProperty(name) != null) {
        // pre-existing non-inherited property, call set
        sobj.set(name, value, strict);
    } else {
        // add new property
        sobj.addOwnProperty(name, Property.WRITABLE_ENUMERABLE_CONFIGURABLE, value);
    }
}
 

@Override
public int getInt(final long key) {
    final int index = ArrayIndex.getArrayIndex(key);
    final ArrayData array = getArray();

    if (array.has(index)) {
        return array.getInt(index);
    }

    return getInt(index, JSType.toString(key));
}
 

@Override
public Object getOwnPropertyDescriptor(final String key) {
    final int index = ArrayIndex.getArrayIndex(key);
    if (index >= 0 && index < value.length()) {
        final Global global = Global.instance();
        return global.newDataDescriptor(String.valueOf(value.charAt(index)), false, true, false);
    }

    return super.getOwnPropertyDescriptor(key);
}
 

private static void setPropertyValue(final ScriptObject sobj, final String name, final Object value, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(name);
    if (ArrayIndex.isValidArrayIndex(index)) {
        // array index key
        sobj.defineOwnProperty(index, value);
    } else if (sobj.getMap().findProperty(name) != null) {
        // pre-existing non-inherited property, call set
        sobj.set(name, value, strict);
    } else {
        // add new property
        sobj.addOwnProperty(name, Property.WRITABLE_ENUMERABLE_CONFIGURABLE, value);
    }
}
 

@Override
public boolean delete(final Object key, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(key);
    final ArrayData array = getArray();

    if (array.has(index)) {
        if (array.canDelete(index, strict)) {
            setArray(array.delete(index));
            return true;
        }
        return false;
    }

    return deleteObject(key, strict);
}
 

/**
 * ECMA 15.4.5.1 [[DefineOwnProperty]] ( P, Desc, Throw ) as specialized in
 * ECMA 10.6 for Arguments object.
 */
@Override
public boolean defineOwnProperty(final String key, final Object propertyDesc, final boolean reject) {
    final int index = ArrayIndex.getArrayIndex(key);
    if (index >= 0) {
        final boolean isMapped = isMapped(index);
        final Object oldValue = isMapped ? getArray().getObject(index) : null;

        if (!super.defineOwnProperty(key, propertyDesc, false)) {
            if (reject) {
                throw typeError("cant.redefine.property",  key, ScriptRuntime.safeToString(this));
            }
            return false;
        }

        if (isMapped) {
            // When mapped argument is redefined, if new descriptor is accessor property
            // or data-non-writable property, we have to "unmap" (unlink).
            final PropertyDescriptor desc = toPropertyDescriptor(Global.instance(), propertyDesc);
            if (desc.type() == PropertyDescriptor.ACCESSOR) {
                setDeleted(index, oldValue);
            } else if (desc.has(PropertyDescriptor.WRITABLE) && !desc.isWritable()) {
                // delete and set value from new descriptor if it has one, otherwise use old value
                setDeleted(index, desc.has(PropertyDescriptor.VALUE) ? desc.getValue() : oldValue);
            } else if (desc.has(PropertyDescriptor.VALUE)) {
                setArray(getArray().set(index, desc.getValue(), false));
            }
        }

        return true;
    }

    return super.defineOwnProperty(key, propertyDesc, reject);
}
 

@Override
public long getLong(final Object key) {
    final int index = ArrayIndex.getArrayIndex(key);
    final ArrayData array = getArray();

    if (array.has(index)) {
        return array.getLong(index);
    }

    return getLong(index, JSType.toString(key));
}
 

@SuppressWarnings("unused")
private static Object get(final Object self, final Object key) {
    final CharSequence cs = JSType.toCharSequence(self);
    final int index = ArrayIndex.getArrayIndex(key);
    if (index >= 0 && index < cs.length()) {
        return String.valueOf(cs.charAt(index));
    }
    return ((ScriptObject) Global.toObject(self)).get(key);
}
 

@Override
public int getInt(final Object key) {
    final int index = ArrayIndex.getArrayIndex(key);
    final ArrayData array = getArray();

    if (array.has(index)) {
        return array.getInt(index);
    }

    return getInt(index, JSType.toString(key));
}
 

@Override
public boolean delete(final double key, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(key);
    return isMapped(index) ? deleteMapped(index, strict) : super.delete(key, strict);
}
 

@Override
public boolean delete(final double key, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(key);
    return isMapped(index) ? deleteMapped(index, strict) : super.delete(key, strict);
}
 

/**
 * ECMA 15.4.5.1 [[DefineOwnProperty]] ( P, Desc, Throw )
 */
@Override
public boolean defineOwnProperty(final String key, final Object propertyDesc, final boolean reject) {
    final PropertyDescriptor desc = toPropertyDescriptor(Global.instance(), propertyDesc);

    // never be undefined as "length" is always defined and can't be deleted for arrays
    // Step 1
    final PropertyDescriptor oldLenDesc = (PropertyDescriptor) super.getOwnPropertyDescriptor("length");

    // Step 2
    // get old length and convert to long. Always a Long/Uint32 but we take the safe road.
    final long oldLen = JSType.toUint32(oldLenDesc.getValue());

    // Step 3
    if ("length".equals(key)) {
        // check for length being made non-writable
        final boolean result = defineLength(oldLen, oldLenDesc, desc, reject);
        if (desc.has(WRITABLE) && !desc.isWritable()) {
            setIsLengthNotWritable();
        }
        return result;
    }

    // Step 4a
    final int index = ArrayIndex.getArrayIndex(key);
    if (ArrayIndex.isValidArrayIndex(index)) {
        final long longIndex = ArrayIndex.toLongIndex(index);
        // Step 4b
        // setting an element beyond current length, but 'length' is not writable
        if (longIndex >= oldLen && !oldLenDesc.isWritable()) {
            if (reject) {
                throw typeError("property.not.writable", Long.toString(longIndex), ScriptRuntime.safeToString(this));
            }
            return false;
        }

        // Step 4c
        // set the new array element
        final boolean succeeded = super.defineOwnProperty(key, desc, false);

        // Step 4d
        if (!succeeded) {
            if (reject) {
                throw typeError("cant.redefine.property", key, ScriptRuntime.safeToString(this));
            }
            return false;
        }

        // Step 4e -- adjust new length based on new element index that is set
        if (longIndex >= oldLen) {
            oldLenDesc.setValue(longIndex + 1);
            super.defineOwnProperty("length", oldLenDesc, false);
        }

        // Step 4f
        return true;
    }

    // not an index property
    return super.defineOwnProperty(key, desc, reject);
}
 

@Override
public boolean hasOwnProperty(final double key) {
    final int index = ArrayIndex.getArrayIndex(key);
    return isValidStringIndex(index) || super.hasOwnProperty(key);
}
 

@Override
public boolean delete(final int key, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(key);
    return isMapped(index) ? deleteMapped(index, strict) : super.delete(key, strict);
}
 

@Override
public boolean delete(final Object key, final boolean strict) {
    final Object primitiveKey = JSType.toPrimitive(key, String.class);
    final int index = ArrayIndex.getArrayIndex(primitiveKey);
    return isMapped(index) ? deleteMapped(index, strict) : super.delete(primitiveKey, strict);
}
 

@Override
public boolean delete(final int key, final boolean strict) {
    final int index = ArrayIndex.getArrayIndex(key);
    return isMapped(index) ? deleteMapped(index, strict) : super.delete(key, strict);
}
 

/**
 * ECMA 15.4.5.1 [[DefineOwnProperty]] ( P, Desc, Throw )
 */
@Override
public boolean defineOwnProperty(final String key, final Object propertyDesc, final boolean reject) {
    final PropertyDescriptor desc = toPropertyDescriptor(Global.instance(), propertyDesc);

    // never be undefined as "length" is always defined and can't be deleted for arrays
    // Step 1
    final PropertyDescriptor oldLenDesc = (PropertyDescriptor) super.getOwnPropertyDescriptor("length");

    // Step 2
    // get old length and convert to long. Always a Long/Uint32 but we take the safe road.
    final long oldLen = JSType.toUint32(oldLenDesc.getValue());

    // Step 3
    if ("length".equals(key)) {
        // check for length being made non-writable
        final boolean result = defineLength(oldLen, oldLenDesc, desc, reject);
        if (desc.has(WRITABLE) && !desc.isWritable()) {
            setIsLengthNotWritable();
        }
        return result;
    }

    // Step 4a
    final int index = ArrayIndex.getArrayIndex(key);
    if (ArrayIndex.isValidArrayIndex(index)) {
        final long longIndex = ArrayIndex.toLongIndex(index);
        // Step 4b
        // setting an element beyond current length, but 'length' is not writable
        if (longIndex >= oldLen && !oldLenDesc.isWritable()) {
            if (reject) {
                throw typeError("property.not.writable", Long.toString(longIndex), ScriptRuntime.safeToString(this));
            }
            return false;
        }

        // Step 4c
        // set the new array element
        final boolean succeeded = super.defineOwnProperty(key, desc, false);

        // Step 4d
        if (!succeeded) {
            if (reject) {
                throw typeError("cant.redefine.property", key, ScriptRuntime.safeToString(this));
            }
            return false;
        }

        // Step 4e -- adjust new length based on new element index that is set
        if (longIndex >= oldLen) {
            oldLenDesc.setValue(longIndex + 1);
            super.defineOwnProperty("length", oldLenDesc, false);
        }

        // Step 4f
        return true;
    }

    // not an index property
    return super.defineOwnProperty(key, desc, reject);
}