webcommon/lib.v8debug/src/org/netbeans/lib/v8debug/vars/V8Object.java - netbeans - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.netbeans.lib.v8debug.vars;

 import java.util.Arrays;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import org.netbeans.lib.v8debug.PropertyLong;

 /**
  *
  * @author Martin Entlicher
  */
 public class V8Object extends V8Value {

     private final String className;
     private final PropertyLong constructorFunctionHandle;
     private final PropertyLong protoObjectHandle;
     private final PropertyLong prototypeObjectHandle;
     private final Map<String, Property> properties;
     private final Array array;

     public V8Object(long handle, V8Value.Type type, String className,
                     PropertyLong constructorFunctionHandle,
                     PropertyLong protoObjectHandle, PropertyLong prototypeObjectHandle,
                     Map<String, Property> properties, Array array, String text) {
         super(handle, type, text);
         this.className = className;
         this.constructorFunctionHandle = constructorFunctionHandle;
         this.protoObjectHandle = protoObjectHandle;
         this.prototypeObjectHandle = prototypeObjectHandle;
         this.properties = properties;
         this.array = array;
     }

     protected V8Object(long handle, V8Value.Type type, String className,
                        PropertyLong constructorFunctionHandle,
                        PropertyLong protoObjectHandle, PropertyLong prototypeObjectHandle,
                        Map<String, Property> properties, String text) {
         this(handle, type, className, constructorFunctionHandle,
              protoObjectHandle, prototypeObjectHandle, properties, null, text);
     }

     public String getClassName() {
         return className;
     }

     public PropertyLong getConstructorFunctionHandle() {
         return constructorFunctionHandle;
     }

     public PropertyLong getProtoObjectHandle() {
         return protoObjectHandle;
     }

     public PropertyLong getPrototypeObjectHandle() {
         return prototypeObjectHandle;
     }

     public Map<String, Property> getProperties() {
         return properties;
     }

     public Array getArray() {
         return array;
     }

     public static final class Property {

         public static enum Type {
             Normal,
             Field,
             Constant,
             Callbacks,
             Handler,
             Interceptor,
             Transition,
             Nonexistent
         }

         public static final int ATTR_NONE = 0;
         public static final int ATTR_READ_ONLY = 1;
         public static final int ATTR_DONT_ENUM = 2;
         public static final int ATTR_DONT_DELETE = 4;
         public static final int ATTR_SEALED = ATTR_DONT_DELETE;
         public static final int ATTR_FROZEN = ATTR_SEALED | ATTR_READ_ONLY;
         public static final int ATTR_STRING = 8;
         public static final int ATTR_SYMBOLIC = 16;
         public static final int ATTR_PRIVATE_SYMBOL = 32;
         public static final int ATTR_DONT_SHOW = ATTR_DONT_ENUM | ATTR_SYMBOLIC | ATTR_PRIVATE_SYMBOL;
         public static final int ATTR_ABSENT = 64;

         private final String name;
         private final Type type;
         private final int attributes;
         private final long reference;

         public Property(String name, Type type, int attributes, long reference) {
             this.name = name;
             this.type = type;
             this.attributes = attributes;
             this.reference = reference;
         }

         public String getName() {
             return name;
         }

         public Type getType() {
             return type;
         }

         public int getAttributes() {
             return attributes;
         }

         public long getReference() {
             return reference;
         }

     }

     public static interface Array {

         long getReferenceAt(long index) throws NoSuchElementException;

         IndexIterator getIndexIterator();

         boolean isContiguous();

         long[] getContiguousReferences() throws UnsupportedOperationException;

         long getLength();
     }

     public static interface IndexIterator {

         boolean hasNextIndex();

         long nextIndex() throws NoSuchElementException;
     }

     public static final class DefaultArray implements Array {

         private long[] references;
         private long[] indexes;
         private int length;

         public DefaultArray(long[] references) {
             this.references = references;
             this.indexes = null;
             this.length = references.length;
         }

         public DefaultArray() {
             this.references = new long[0];
             this.indexes = null;
             this.length = 0;
         }

         public void putReferenceAt(long index, long reference) {
             if (indexes == null) {
                 // we're contiguous so far
                 if (index < length) {
                     references[(int) index] = reference;
                 } else if (index == length) {
                     if (references.length <= index) {
                         int newLength = getNewLength();
                         references = Arrays.copyOf(references, newLength);
                     }
                     references[length++] = reference;
                 } else {
                     // switch to non-contiguous
                     int newLength = references.length;
                     if (!(newLength > length)) {
                         newLength = getNewLength();
                         references = Arrays.copyOf(references, newLength);
                     }
                     indexes = new long[newLength];
                     for (int i = 0; i < length; i++) {
                         indexes[i] = i;
                     }
                     indexes[length] = index;
                     references[length] = reference;
                     length++;
                 }
             } else {
                 if (references.length <= length) {
                     int newLength = getNewLength();
                     references = Arrays.copyOf(references, newLength);
                     indexes = Arrays.copyOf(indexes, newLength);
                 }
                 indexes[length] = index;
                 references[length] = reference;
                 length++;
             }
         }

         private int getNewLength() {
             int newLength = length + (length >> 1);
             if (newLength < 10) {
                 newLength = 10;
             }
             if (!(newLength > length)) {
                 // overflow
                 newLength = Integer.MAX_VALUE - 8;
                 if (!(newLength > length)) {
                     if (length == Integer.MAX_VALUE) {
                         throw new OutOfMemoryError("Unable to allocate an array longer than "+Integer.MAX_VALUE+" bytes.");
                     }
                     newLength = Integer.MAX_VALUE;
                 }
             }
             return newLength;
         }

         @Override
         public long getReferenceAt(long index) throws NoSuchElementException {
             if (indexes == null) {
                 if (index >= length) {
                     throw new NoSuchElementException("No reference at "+index+", array length is "+length);
                 }
                 return references[(int) index];
             } else {
                 int pos = getPositionOf(index);
                 if (pos < 0) {
                     throw new NoSuchElementException("No reference at "+index);
                 }
                 return references[pos];
             }
         }

         private int getPositionOf(long index) {
             int p1 = 0;
             int p2 = length - 1;
             while (p1 <= p2) {
                 int p = p1 + (p2 - p1)/2;
                 long pi = indexes[p];
                 if (pi == index) {
                     return p;
                 }
                 if (p1 == p2) {
                     return -1;
                 }
                 if (pi < index) {
                     if (p1 == p) {
                         p1++;
                     } else {
                         p1 = p;
                     }
                 } else {
                     p2 = p;
                 }
             }
             return -1;
         }

         @Override
         public IndexIterator getIndexIterator() {
             return new DefaultIndexIterator();
         }

         @Override
         public boolean isContiguous() {
             return indexes == null;
         }

         @Override
         public long[] getContiguousReferences() throws UnsupportedOperationException {
             if (indexes == null) {
                 if (references.length > length) {
                     // trim
                     references = Arrays.copyOf(references, length);
                 }
                 return references;
             } else {
                 throw new UnsupportedOperationException("The array is not contiguous.");
             }
         }

         @Override
         public long getLength() {
             if (indexes == null) {
                 return length;
             } else {
                 if (length == 0) {
                     return 0;
                 } else {
                     long maxIndex = indexes[length-1];
                     return maxIndex + 1;
                 }
             }
         }

         private final class DefaultIndexIterator implements IndexIterator {

             private int pos = 0;

             @Override
             public boolean hasNextIndex() {
                 return pos < length;
             }

             @Override
             public long nextIndex() throws NoSuchElementException {
                 if (pos >= length) {
                     throw new NoSuchElementException("Length = "+length);
                 }
                 if (indexes == null) {
                     return pos++;
                 } else {
                     return indexes[pos++];
                 }
             }

         }
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.netbeans.lib.v8debug.vars;

	import java.util.Arrays;
	import java.util.Map;
	import java.util.NoSuchElementException;
	import org.netbeans.lib.v8debug.PropertyLong;

	/**
	*
	* @author Martin Entlicher
	*/
	public class V8Object extends V8Value {

	private final String className;
	private final PropertyLong constructorFunctionHandle;
	private final PropertyLong protoObjectHandle;
	private final PropertyLong prototypeObjectHandle;
	private final Map<String, Property> properties;
	private final Array array;

	public V8Object(long handle, V8Value.Type type, String className,
	PropertyLong constructorFunctionHandle,
	PropertyLong protoObjectHandle, PropertyLong prototypeObjectHandle,
	Map<String, Property> properties, Array array, String text) {
	super(handle, type, text);
	this.className = className;
	this.constructorFunctionHandle = constructorFunctionHandle;
	this.protoObjectHandle = protoObjectHandle;
	this.prototypeObjectHandle = prototypeObjectHandle;
	this.properties = properties;
	this.array = array;
	}

	protected V8Object(long handle, V8Value.Type type, String className,
	PropertyLong constructorFunctionHandle,
	PropertyLong protoObjectHandle, PropertyLong prototypeObjectHandle,
	Map<String, Property> properties, String text) {
	this(handle, type, className, constructorFunctionHandle,
	protoObjectHandle, prototypeObjectHandle, properties, null, text);
	}

	public String getClassName() {
	return className;
	}

	public PropertyLong getConstructorFunctionHandle() {
	return constructorFunctionHandle;
	}

	public PropertyLong getProtoObjectHandle() {
	return protoObjectHandle;
	}

	public PropertyLong getPrototypeObjectHandle() {
	return prototypeObjectHandle;
	}

	public Map<String, Property> getProperties() {
	return properties;
	}

	public Array getArray() {
	return array;
	}

	public static final class Property {

	public static enum Type {
	Normal,
	Field,
	Constant,
	Callbacks,
	Handler,
	Interceptor,
	Transition,
	Nonexistent
	}

	public static final int ATTR_NONE = 0;
	public static final int ATTR_READ_ONLY = 1;
	public static final int ATTR_DONT_ENUM = 2;
	public static final int ATTR_DONT_DELETE = 4;
	public static final int ATTR_SEALED = ATTR_DONT_DELETE;
	public static final int ATTR_FROZEN = ATTR_SEALED \| ATTR_READ_ONLY;
	public static final int ATTR_STRING = 8;
	public static final int ATTR_SYMBOLIC = 16;
	public static final int ATTR_PRIVATE_SYMBOL = 32;
	public static final int ATTR_DONT_SHOW = ATTR_DONT_ENUM \| ATTR_SYMBOLIC \| ATTR_PRIVATE_SYMBOL;
	public static final int ATTR_ABSENT = 64;

	private final String name;
	private final Type type;
	private final int attributes;
	private final long reference;

	public Property(String name, Type type, int attributes, long reference) {
	this.name = name;
	this.type = type;
	this.attributes = attributes;
	this.reference = reference;
	}

	public String getName() {
	return name;
	}

	public Type getType() {
	return type;
	}

	public int getAttributes() {
	return attributes;
	}

	public long getReference() {
	return reference;
	}

	}

	public static interface Array {

	long getReferenceAt(long index) throws NoSuchElementException;

	IndexIterator getIndexIterator();

	boolean isContiguous();

	long[] getContiguousReferences() throws UnsupportedOperationException;

	long getLength();
	}

	public static interface IndexIterator {

	boolean hasNextIndex();

	long nextIndex() throws NoSuchElementException;
	}

	public static final class DefaultArray implements Array {

	private long[] references;
	private long[] indexes;
	private int length;

	public DefaultArray(long[] references) {
	this.references = references;
	this.indexes = null;
	this.length = references.length;
	}

	public DefaultArray() {
	this.references = new long[0];
	this.indexes = null;
	this.length = 0;
	}

	public void putReferenceAt(long index, long reference) {
	if (indexes == null) {
	// we're contiguous so far
	if (index < length) {
	references[(int) index] = reference;
	} else if (index == length) {
	if (references.length <= index) {
	int newLength = getNewLength();
	references = Arrays.copyOf(references, newLength);
	}
	references[length++] = reference;
	} else {
	// switch to non-contiguous
	int newLength = references.length;
	if (!(newLength > length)) {
	newLength = getNewLength();
	references = Arrays.copyOf(references, newLength);
	}
	indexes = new long[newLength];
	for (int i = 0; i < length; i++) {
	indexes[i] = i;
	}
	indexes[length] = index;
	references[length] = reference;
	length++;
	}
	} else {
	if (references.length <= length) {
	int newLength = getNewLength();
	references = Arrays.copyOf(references, newLength);
	indexes = Arrays.copyOf(indexes, newLength);
	}
	indexes[length] = index;
	references[length] = reference;
	length++;
	}
	}

	private int getNewLength() {
	int newLength = length + (length >> 1);
	if (newLength < 10) {
	newLength = 10;
	}
	if (!(newLength > length)) {
	// overflow
	newLength = Integer.MAX_VALUE - 8;
	if (!(newLength > length)) {
	if (length == Integer.MAX_VALUE) {
	throw new OutOfMemoryError("Unable to allocate an array longer than "+Integer.MAX_VALUE+" bytes.");
	}
	newLength = Integer.MAX_VALUE;
	}
	}
	return newLength;
	}

	@Override
	public long getReferenceAt(long index) throws NoSuchElementException {
	if (indexes == null) {
	if (index >= length) {
	throw new NoSuchElementException("No reference at "+index+", array length is "+length);
	}
	return references[(int) index];
	} else {
	int pos = getPositionOf(index);
	if (pos < 0) {
	throw new NoSuchElementException("No reference at "+index);
	}
	return references[pos];
	}
	}

	private int getPositionOf(long index) {
	int p1 = 0;
	int p2 = length - 1;
	while (p1 <= p2) {
	int p = p1 + (p2 - p1)/2;
	long pi = indexes[p];
	if (pi == index) {
	return p;
	}
	if (p1 == p2) {
	return -1;
	}
	if (pi < index) {
	if (p1 == p) {
	p1++;
	} else {
	p1 = p;
	}
	} else {
	p2 = p;
	}
	}
	return -1;
	}

	@Override
	public IndexIterator getIndexIterator() {
	return new DefaultIndexIterator();
	}

	@Override
	public boolean isContiguous() {
	return indexes == null;
	}

	@Override
	public long[] getContiguousReferences() throws UnsupportedOperationException {
	if (indexes == null) {
	if (references.length > length) {
	// trim
	references = Arrays.copyOf(references, length);
	}
	return references;
	} else {
	throw new UnsupportedOperationException("The array is not contiguous.");
	}
	}

	@Override
	public long getLength() {
	if (indexes == null) {
	return length;
	} else {
	if (length == 0) {
	return 0;
	} else {
	long maxIndex = indexes[length-1];
	return maxIndex + 1;
	}
	}
	}

	private final class DefaultIndexIterator implements IndexIterator {

	private int pos = 0;

	@Override
	public boolean hasNextIndex() {
	return pos < length;
	}

	@Override
	public long nextIndex() throws NoSuchElementException {
	if (pos >= length) {
	throw new NoSuchElementException("Length = "+length);
	}
	if (indexes == null) {
	return pos++;
	} else {
	return indexes[pos++];
	}
	}

	}
	}

	}