src/main/java/org/luaj/vm3/WeakTable.java - minecraft/opencomputers - Rivoreo Source Code Repositories

 /*******************************************************************************
  * Copyright (c) 2009-2011, 2013 Luaj.org. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  ******************************************************************************/
 package org.luaj.vm3;

 import java.lang.ref.WeakReference;

 import org.luaj.vm3.LuaTable.Slot;
 import org.luaj.vm3.LuaTable.StrongSlot;

 /**
  * Subclass of {@link LuaTable} that provides weak key and weak value semantics.
  * <p>
  * Normally these are not created directly, but indirectly when changing the mode
  * of a {@link LuaTable} as lua script executes.
  * <p>
  * However, calling the constructors directly when weak tables are required from
  * Java will reduce overhead.
  */
 public class WeakTable implements Metatable {

 	private boolean weakkeys, weakvalues;
 	private LuaValue backing;

 	public static LuaTable make(boolean weakkeys, boolean weakvalues) {
 		LuaString mode;
 		if (weakkeys && weakvalues) {
 			mode = LuaString.valueOf("kv");
 		} else if (weakkeys) {
 			mode = LuaString.valueOf("k");
 		} else if (weakvalues) {
 			mode = LuaString.valueOf("v");
 		} else {
 			return LuaTable.tableOf();
 		}
 		LuaTable table = LuaTable.tableOf();
 		LuaTable mt = LuaTable.tableOf(new LuaValue[] { LuaValue.MODE, mode });
 		table.setmetatable(mt);
 		return table;
 	}

 	/**
 	 * Construct a table with weak keys, weak values, or both
 	 * @param weakkeys true to let the table have weak keys
 	 * @param weakvalues true to let the table have weak values
 	 */
 	public WeakTable(boolean weakkeys, boolean weakvalues, LuaValue backing) {
 		this.weakkeys = weakkeys;
 		this.weakvalues = weakvalues;
 		this.backing = backing;
 	}

 	public boolean useWeakKeys() {
 		return weakkeys;
 	}

 	public boolean useWeakValues() {
 		return weakvalues;
 	}

 	public LuaValue toLuaValue() {
 		return backing;
 	}

 	public Slot entry(LuaValue key, LuaValue value) {
 		value = value.strongvalue();
 		if (value == null)
 			return null;
 		if (weakkeys && !(key.isnumber() || key.isstring() || key.isboolean())) {
 			if (weakvalues && !(value.isnumber() || value.isstring() || value.isboolean())) {
 				return new WeakKeyAndValueSlot(key, value, null);
 			} else {
 				return new WeakKeySlot(key, value, null);
 			}
 		}
 		if (weakvalues && !(value.isnumber() || value.isstring() || value.isboolean())) {
 			return new WeakValueSlot(key, value, null);
 		}
 		return LuaTable.defaultEntry(key, value);
 	}

 	public static abstract class WeakSlot implements Slot {

 		protected Object key;
 		protected Object value;
 		protected Slot next;

 		protected WeakSlot(Object key, Object value, Slot next) {
 			this.key = key;
 			this.value = value;
 			this.next = next;
 		}

 		public abstract int keyindex(int hashMask);

 		public abstract Slot set(LuaValue value);

 		public StrongSlot first() {
 			LuaValue key = strongkey();
 			LuaValue value = strongvalue();
 			if (key != null && value != null) {
 				return new LuaTable.NormalEntry(key, value);
 			} else {
 				this.key = null;
 				this.value = null;
 				return null;
 			}
 		}

 		public StrongSlot find(LuaValue key) {
 			StrongSlot first = first();
 			return (first != null) ? first.find(key) : null;
 		}

 		public boolean keyeq(LuaValue key) {
 			StrongSlot first = first();
 			return (first != null) && first.keyeq(key);
 		}

 		public Slot rest() {
 			return next;
 		}

 		public int arraykey(int max) {
 			// Integer keys can never be weak.
 			return 0;
 		}

 		public Slot set(StrongSlot target, LuaValue value) {
 			LuaValue key = strongkey();
 			if (key != null && target.find(key) != null) {
 				return set(value);
 			} else if (key != null) {
 				// Our key is still good.
 				next = next.set(target, value);
 				return this;
 			} else {
 				// our key was dropped, remove ourselves from the chain.
 				return next.set(target, value);
 			}
 		}

 		public Slot add(Slot entry) {
 			next = (next != null) ? next.add(entry) : entry;
 			if (strongkey() != null && strongvalue() != null) {
 				return this;
 			} else {
 				return next;
 			}
 		}

 		public Slot remove(StrongSlot target) {
 			LuaValue key = strongkey();
 			if (key == null) {
 				return next.remove(target);
 			} else if (target.keyeq(key)) {
 				this.value = null;
 				return this;
 			} else {
 				next = next.remove(target);
 				return this;
 			}
 		}

 		public Slot relink(Slot rest) {
 			if (strongkey() != null && strongvalue() != null) {
 				if (rest == null && this.next == null) {
 					return this;
 				} else {
 					return copy(rest);
 				}
 			} else {
 				return rest;
 			}
 		}

 		public LuaValue strongkey() {
 			return (LuaValue) key;
 		}

 		public LuaValue strongvalue() {
 			return (LuaValue) value;
 		}

 		protected abstract WeakSlot copy(Slot next);
 	}

 	static class WeakKeySlot extends WeakSlot {

 		private final int keyhash;

 		protected WeakKeySlot(LuaValue key, LuaValue value, Slot next) {
 			super(weaken(key), value, next);
 			keyhash = key.hashCode();
 		}

 		protected WeakKeySlot(WeakKeySlot copyFrom, Slot next) {
 			super(copyFrom.key, copyFrom.value, next);
 			this.keyhash = copyFrom.keyhash;
 		}

 		public int keyindex(int mask) {
 			return LuaTable.hashmod(keyhash, mask);
 		}

 		public Slot set(LuaValue value) {
 			this.value = value;
 			return this;
 		}

 		public LuaValue strongkey() {
 			return strengthen(key);
 		}

 		protected WeakSlot copy(Slot rest) {
 			return new WeakKeySlot(this, rest);
 		}
 	}

 	static class WeakValueSlot extends WeakSlot {

 		protected WeakValueSlot(LuaValue key, LuaValue value, Slot next) {
 			super(key, weaken(value), next);
 		}

 		protected WeakValueSlot(WeakValueSlot copyFrom, Slot next) {
 			super(copyFrom.key, copyFrom.value, next);
 		}

 		public int keyindex(int mask) {
 			return LuaTable.hashSlot(strongkey(), mask);
 		}

 		public Slot set(LuaValue value) {
 			this.value = weaken(value);
 			return this;
 		}

 		public LuaValue strongvalue() {
 			return strengthen(value);
 		}

 		protected WeakSlot copy(Slot next) {
 			return new WeakValueSlot(this, next);
 		}
 	}

 	static class WeakKeyAndValueSlot extends WeakSlot {

 		private final int keyhash;

 		protected WeakKeyAndValueSlot(LuaValue key, LuaValue value, Slot next) {
 			super(weaken(key), weaken(value), next);
 			keyhash = key.hashCode();
 		}

 		protected WeakKeyAndValueSlot(WeakKeyAndValueSlot copyFrom, Slot next) {
 			super(copyFrom.key, copyFrom.value, next);
 			keyhash = copyFrom.keyhash;
 		}

 		public int keyindex(int hashMask) {
 			return LuaTable.hashmod(keyhash, hashMask);
 		}

 		public Slot set(LuaValue value) {
 			this.value = weaken(value);
 			return this;
 		}

 		public LuaValue strongkey() {
 			return strengthen(key);
 		}

 		public LuaValue strongvalue() {
 			return strengthen(value);
 		}

 		protected WeakSlot copy(Slot next) {
 			return new WeakKeyAndValueSlot(this, next);
 		}
 	}

 	/**
 	 * Self-sent message to convert a value to its weak counterpart
 	 * @param value value to convert
 	 * @return {@link LuaValue} that is a strong or weak reference, depending on type of {@code value}
 	 */
 	protected static LuaValue weaken(LuaValue value) {
 		switch (value.type()) {
 		case LuaValue.TFUNCTION:
 		case LuaValue.TTHREAD:
 		case LuaValue.TTABLE:
 			return new WeakValue(value);
 		case LuaValue.TUSERDATA:
 			return new WeakUserdata(value);
 		default:
 			return value;
 		}
 	}

 	/**
 	 * Unwrap a LuaValue from a WeakReference and/or WeakUserdata.
 	 * @param ref reference to convert
 	 * @return LuaValue or null
 	 * @see #weaken(LuaValue)
 	 */
 	protected static LuaValue strengthen(Object ref) {
 		if (ref instanceof WeakReference) {
 			ref = ((WeakReference) ref).get();
 		}
 		if (ref instanceof WeakValue) {
 			return ((WeakValue) ref).strongvalue();
 		}
 		return (LuaValue) ref;
 	}

 	/** Internal class to implement weak values.
 	 * @see WeakTable
 	 */
 	static class WeakValue extends LuaValue {
 		WeakReference ref;

 		protected WeakValue(LuaValue value) {
 			ref = new WeakReference(value);
 		}

 		public int type() {
 			illegal("type", "weak value");
 			return 0;
 		}

 		public String typename() {
 			illegal("typename", "weak value");
 			return null;
 		}

 		public String toString() {
 			return "weak<" + ref.get() + ">";
 		}

 		public LuaValue strongvalue() {
 			Object o = ref.get();
 			return (LuaValue) o;
 		}

 		public boolean raweq(LuaValue rhs) {
 			Object o = ref.get();
 			return o != null && rhs.raweq((LuaValue) o);
 		}
 	}

 	/** Internal class to implement weak userdata values.
 	 * @see WeakTable
 	 */
 	static final class WeakUserdata extends WeakValue {
 		private final WeakReference ob;
 		private final LuaValue mt;

 		private WeakUserdata(LuaValue value) {
 			super(value);
 			ob = new WeakReference(value.touserdata());
 			mt = value.getmetatable();
 		}

 		public LuaValue strongvalue() {
 			Object u = ref.get();
 			if (u != null)
 				return (LuaValue) u;
 			Object o = ob.get();
 			if (o != null) {
 				LuaValue ud = LuaValue.userdataOf(o, mt);
 				ref = new WeakReference(ud);
 				return ud;
 			} else {
 				return null;
 			}
 		}
 	}

 	public LuaValue wrap(LuaValue value) {
 		return weakvalues ? weaken(value) : value;
 	}

 	public LuaValue arrayget(LuaValue[] array, int index) {
 		LuaValue value = array[index];
 		if (value != null) {
 			value = strengthen(value);
 			if (value == null) {
 				array[index] = null;
 			}
 		}
 		return value;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009-2011, 2013 Luaj.org. All rights reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	******************************************************************************/
	package org.luaj.vm3;

	import java.lang.ref.WeakReference;

	import org.luaj.vm3.LuaTable.Slot;
	import org.luaj.vm3.LuaTable.StrongSlot;

	/**
	* Subclass of {@link LuaTable} that provides weak key and weak value semantics.
	* <p>
	* Normally these are not created directly, but indirectly when changing the mode
	* of a {@link LuaTable} as lua script executes.
	* <p>
	* However, calling the constructors directly when weak tables are required from
	* Java will reduce overhead.
	*/
	public class WeakTable implements Metatable {

	private boolean weakkeys, weakvalues;
	private LuaValue backing;

	public static LuaTable make(boolean weakkeys, boolean weakvalues) {
	LuaString mode;
	if (weakkeys && weakvalues) {
	mode = LuaString.valueOf("kv");
	} else if (weakkeys) {
	mode = LuaString.valueOf("k");
	} else if (weakvalues) {
	mode = LuaString.valueOf("v");
	} else {
	return LuaTable.tableOf();
	}
	LuaTable table = LuaTable.tableOf();
	LuaTable mt = LuaTable.tableOf(new LuaValue[] { LuaValue.MODE, mode });
	table.setmetatable(mt);
	return table;
	}

	/**
	* Construct a table with weak keys, weak values, or both
	* @param weakkeys true to let the table have weak keys
	* @param weakvalues true to let the table have weak values
	*/
	public WeakTable(boolean weakkeys, boolean weakvalues, LuaValue backing) {
	this.weakkeys = weakkeys;
	this.weakvalues = weakvalues;
	this.backing = backing;
	}

	public boolean useWeakKeys() {
	return weakkeys;
	}

	public boolean useWeakValues() {
	return weakvalues;
	}

	public LuaValue toLuaValue() {
	return backing;
	}

	public Slot entry(LuaValue key, LuaValue value) {
	value = value.strongvalue();
	if (value == null)
	return null;
	if (weakkeys && !(key.isnumber() \|\| key.isstring() \|\| key.isboolean())) {
	if (weakvalues && !(value.isnumber() \|\| value.isstring() \|\| value.isboolean())) {
	return new WeakKeyAndValueSlot(key, value, null);
	} else {
	return new WeakKeySlot(key, value, null);
	}
	}
	if (weakvalues && !(value.isnumber() \|\| value.isstring() \|\| value.isboolean())) {
	return new WeakValueSlot(key, value, null);
	}
	return LuaTable.defaultEntry(key, value);
	}

	public static abstract class WeakSlot implements Slot {

	protected Object key;
	protected Object value;
	protected Slot next;

	protected WeakSlot(Object key, Object value, Slot next) {
	this.key = key;
	this.value = value;
	this.next = next;
	}

	public abstract int keyindex(int hashMask);

	public abstract Slot set(LuaValue value);

	public StrongSlot first() {
	LuaValue key = strongkey();
	LuaValue value = strongvalue();
	if (key != null && value != null) {
	return new LuaTable.NormalEntry(key, value);
	} else {
	this.key = null;
	this.value = null;
	return null;
	}
	}

	public StrongSlot find(LuaValue key) {
	StrongSlot first = first();
	return (first != null) ? first.find(key) : null;
	}

	public boolean keyeq(LuaValue key) {
	StrongSlot first = first();
	return (first != null) && first.keyeq(key);
	}

	public Slot rest() {
	return next;
	}

	public int arraykey(int max) {
	// Integer keys can never be weak.
	return 0;
	}

	public Slot set(StrongSlot target, LuaValue value) {
	LuaValue key = strongkey();
	if (key != null && target.find(key) != null) {
	return set(value);
	} else if (key != null) {
	// Our key is still good.
	next = next.set(target, value);
	return this;
	} else {
	// our key was dropped, remove ourselves from the chain.
	return next.set(target, value);
	}
	}

	public Slot add(Slot entry) {
	next = (next != null) ? next.add(entry) : entry;
	if (strongkey() != null && strongvalue() != null) {
	return this;
	} else {
	return next;
	}
	}

	public Slot remove(StrongSlot target) {
	LuaValue key = strongkey();
	if (key == null) {
	return next.remove(target);
	} else if (target.keyeq(key)) {
	this.value = null;
	return this;
	} else {
	next = next.remove(target);
	return this;
	}
	}

	public Slot relink(Slot rest) {
	if (strongkey() != null && strongvalue() != null) {
	if (rest == null && this.next == null) {
	return this;
	} else {
	return copy(rest);
	}
	} else {
	return rest;
	}
	}

	public LuaValue strongkey() {
	return (LuaValue) key;
	}

	public LuaValue strongvalue() {
	return (LuaValue) value;
	}

	protected abstract WeakSlot copy(Slot next);
	}

	static class WeakKeySlot extends WeakSlot {

	private final int keyhash;

	protected WeakKeySlot(LuaValue key, LuaValue value, Slot next) {
	super(weaken(key), value, next);
	keyhash = key.hashCode();
	}

	protected WeakKeySlot(WeakKeySlot copyFrom, Slot next) {
	super(copyFrom.key, copyFrom.value, next);
	this.keyhash = copyFrom.keyhash;
	}

	public int keyindex(int mask) {
	return LuaTable.hashmod(keyhash, mask);
	}

	public Slot set(LuaValue value) {
	this.value = value;
	return this;
	}

	public LuaValue strongkey() {
	return strengthen(key);
	}

	protected WeakSlot copy(Slot rest) {
	return new WeakKeySlot(this, rest);
	}
	}

	static class WeakValueSlot extends WeakSlot {

	protected WeakValueSlot(LuaValue key, LuaValue value, Slot next) {
	super(key, weaken(value), next);
	}

	protected WeakValueSlot(WeakValueSlot copyFrom, Slot next) {
	super(copyFrom.key, copyFrom.value, next);
	}

	public int keyindex(int mask) {
	return LuaTable.hashSlot(strongkey(), mask);
	}

	public Slot set(LuaValue value) {
	this.value = weaken(value);
	return this;
	}

	public LuaValue strongvalue() {
	return strengthen(value);
	}

	protected WeakSlot copy(Slot next) {
	return new WeakValueSlot(this, next);
	}
	}

	static class WeakKeyAndValueSlot extends WeakSlot {

	private final int keyhash;

	protected WeakKeyAndValueSlot(LuaValue key, LuaValue value, Slot next) {
	super(weaken(key), weaken(value), next);
	keyhash = key.hashCode();
	}

	protected WeakKeyAndValueSlot(WeakKeyAndValueSlot copyFrom, Slot next) {
	super(copyFrom.key, copyFrom.value, next);
	keyhash = copyFrom.keyhash;
	}

	public int keyindex(int hashMask) {
	return LuaTable.hashmod(keyhash, hashMask);
	}

	public Slot set(LuaValue value) {
	this.value = weaken(value);
	return this;
	}

	public LuaValue strongkey() {
	return strengthen(key);
	}

	public LuaValue strongvalue() {
	return strengthen(value);
	}

	protected WeakSlot copy(Slot next) {
	return new WeakKeyAndValueSlot(this, next);
	}
	}

	/**
	* Self-sent message to convert a value to its weak counterpart
	* @param value value to convert
	* @return {@link LuaValue} that is a strong or weak reference, depending on type of {@code value}
	*/
	protected static LuaValue weaken(LuaValue value) {
	switch (value.type()) {
	case LuaValue.TFUNCTION:
	case LuaValue.TTHREAD:
	case LuaValue.TTABLE:
	return new WeakValue(value);
	case LuaValue.TUSERDATA:
	return new WeakUserdata(value);
	default:
	return value;
	}
	}

	/**
	* Unwrap a LuaValue from a WeakReference and/or WeakUserdata.
	* @param ref reference to convert
	* @return LuaValue or null
	* @see #weaken(LuaValue)
	*/
	protected static LuaValue strengthen(Object ref) {
	if (ref instanceof WeakReference) {
	ref = ((WeakReference) ref).get();
	}
	if (ref instanceof WeakValue) {
	return ((WeakValue) ref).strongvalue();
	}
	return (LuaValue) ref;
	}

	/** Internal class to implement weak values.
	* @see WeakTable
	*/
	static class WeakValue extends LuaValue {
	WeakReference ref;

	protected WeakValue(LuaValue value) {
	ref = new WeakReference(value);
	}

	public int type() {
	illegal("type", "weak value");
	return 0;
	}

	public String typename() {
	illegal("typename", "weak value");
	return null;
	}

	public String toString() {
	return "weak<" + ref.get() + ">";
	}

	public LuaValue strongvalue() {
	Object o = ref.get();
	return (LuaValue) o;
	}

	public boolean raweq(LuaValue rhs) {
	Object o = ref.get();
	return o != null && rhs.raweq((LuaValue) o);
	}
	}

	/** Internal class to implement weak userdata values.
	* @see WeakTable
	*/
	static final class WeakUserdata extends WeakValue {
	private final WeakReference ob;
	private final LuaValue mt;

	private WeakUserdata(LuaValue value) {
	super(value);
	ob = new WeakReference(value.touserdata());
	mt = value.getmetatable();
	}

	public LuaValue strongvalue() {
	Object u = ref.get();
	if (u != null)
	return (LuaValue) u;
	Object o = ob.get();
	if (o != null) {
	LuaValue ud = LuaValue.userdataOf(o, mt);
	ref = new WeakReference(ud);
	return ud;
	} else {
	return null;
	}
	}
	}

	public LuaValue wrap(LuaValue value) {
	return weakvalues ? weaken(value) : value;
	}

	public LuaValue arrayget(LuaValue[] array, int index) {
	LuaValue value = array[index];
	if (value != null) {
	value = strengthen(value);
	if (value == null) {
	array[index] = null;
	}
	}
	return value;
	}
	}