planetiler/planetiler-experimental/src/main/java/org/luaj/vm2/LuaInteger.java

/*******************************************************************************
 * Copyright (c) 2009 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.vm2;

import org.luaj.vm2.lib.MathLib;

/**
 * Modified version of {@link LuaInteger} with race condition fixes.
 * <p>
 * Extension of {@link LuaNumber} which can hold a Java int as its value.
 * <p>
 * These instance are not instantiated directly by clients, but indirectly via the static functions
 * {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(double)} functions. This ensures that policies regarding
 * pooling of instances are encapsulated.
 * <p>
 * There are no API's specific to LuaInteger that are useful beyond what is already exposed in {@link LuaValue}.
 *
 * @see LuaValue
 * @see LuaNumber
 * @see LuaDouble
 * @see LuaValue#valueOf(int)
 * @see LuaValue#valueOf(double)
 */
public class LuaInteger extends LuaNumber {
  // planetiler change: move int values into nested class to avoid race condition
  // since LuaInteger extends LuaValue, but LuaValue calls LuaInteger.valueOf
  private static class IntValues {

    private static final LuaInteger[] intValues = new LuaInteger[512];
    static {
      for (int i = 0; i < 512; i++)
        intValues[i] = new LuaInteger(i - 256);
    }
  }

  public static LuaInteger valueOf(int i) {
    return i <= 255 && i >= -256 ? IntValues.intValues[i + 256] : new LuaInteger(i);
  };

  // TODO consider moving this to LuaValue
  /**
   * Return a LuaNumber that represents the value provided
   *
   * @param l long value to represent.
   * @return LuaNumber that is eithe LuaInteger or LuaDouble representing l
   * @see LuaValue#valueOf(int)
   * @see LuaValue#valueOf(double)
   */
  public static LuaNumber valueOf(long l) {
    int i = (int) l;
    return l == i ? (i <= 255 && i >= -256 ? IntValues.intValues[i + 256] :
      (LuaNumber) new LuaInteger(i)) :
      (LuaNumber) LuaDouble.valueOf(l);
  }

  /** The value being held by this instance. */
  public final int v;

  /**
   * Package protected constructor.
   *
   * @see LuaValue#valueOf(int)
   **/
  LuaInteger(int i) {
    this.v = i;
  }

  public boolean isint() {
    return true;
  }

  public boolean isinttype() {
    return true;
  }

  public boolean islong() {
    return true;
  }

  public byte tobyte() {
    return (byte) v;
  }

  public char tochar() {
    return (char) v;
  }

  public double todouble() {
    return v;
  }

  public float tofloat() {
    return v;
  }

  public int toint() {
    return v;
  }

  public long tolong() {
    return v;
  }

  public short toshort() {
    return (short) v;
  }

  public double optdouble(double defval) {
    return v;
  }

  public int optint(int defval) {
    return v;
  }

  public LuaInteger optinteger(LuaInteger defval) {
    return this;
  }

  public long optlong(long defval) {
    return v;
  }

  public String tojstring() {
    return Integer.toString(v);
  }

  public LuaString strvalue() {
    return LuaString.valueOf(Integer.toString(v));
  }

  public LuaString optstring(LuaString defval) {
    return LuaString.valueOf(Integer.toString(v));
  }

  public LuaValue tostring() {
    return LuaString.valueOf(Integer.toString(v));
  }

  public String optjstring(String defval) {
    return Integer.toString(v);
  }

  public LuaInteger checkinteger() {
    return this;
  }

  public boolean isstring() {
    return true;
  }

  public int hashCode() {
    return v;
  }

  public static int hashCode(int x) {
    return x;
  }

  // unary operators
  public LuaValue neg() {
    return valueOf(-(long) v);
  }

  // object equality, used for key comparison
  public boolean equals(Object o) {
    return o instanceof LuaInteger ? ((LuaInteger) o).v == v : false;
  }

  // equality w/ metatable processing
  public LuaValue eq(LuaValue val) {
    return val.raweq(v) ? TRUE : FALSE;
  }

  public boolean eq_b(LuaValue val) {
    return val.raweq(v);
  }

  // equality w/o metatable processing
  public boolean raweq(LuaValue val) {
    return val.raweq(v);
  }

  public boolean raweq(double val) {
    return v == val;
  }

  public boolean raweq(int val) {
    return v == val;
  }

  // arithmetic operators
  public LuaValue add(LuaValue rhs) {
    return rhs.add(v);
  }

  public LuaValue add(double lhs) {
    return LuaDouble.valueOf(lhs + v);
  }

  public LuaValue add(int lhs) {
    return LuaInteger.valueOf(lhs + (long) v);
  }

  public LuaValue sub(LuaValue rhs) {
    return rhs.subFrom(v);
  }

  public LuaValue sub(double rhs) {
    return LuaDouble.valueOf(v - rhs);
  }

  public LuaValue sub(int rhs) {
    return LuaDouble.valueOf(v - rhs);
  }

  public LuaValue subFrom(double lhs) {
    return LuaDouble.valueOf(lhs - v);
  }

  public LuaValue subFrom(int lhs) {
    return LuaInteger.valueOf(lhs - (long) v);
  }

  public LuaValue mul(LuaValue rhs) {
    return rhs.mul(v);
  }

  public LuaValue mul(double lhs) {
    return LuaDouble.valueOf(lhs * v);
  }

  public LuaValue mul(int lhs) {
    return LuaInteger.valueOf(lhs * (long) v);
  }

  public LuaValue pow(LuaValue rhs) {
    return rhs.powWith(v);
  }

  public LuaValue pow(double rhs) {
    return MathLib.dpow(v, rhs);
  }

  public LuaValue pow(int rhs) {
    return MathLib.dpow(v, rhs);
  }

  public LuaValue powWith(double lhs) {
    return MathLib.dpow(lhs, v);
  }

  public LuaValue powWith(int lhs) {
    return MathLib.dpow(lhs, v);
  }

  public LuaValue div(LuaValue rhs) {
    return rhs.divInto(v);
  }

  public LuaValue div(double rhs) {
    return LuaDouble.ddiv(v, rhs);
  }

  public LuaValue div(int rhs) {
    return LuaDouble.ddiv(v, rhs);
  }

  public LuaValue divInto(double lhs) {
    return LuaDouble.ddiv(lhs, v);
  }

  public LuaValue mod(LuaValue rhs) {
    return rhs.modFrom(v);
  }

  public LuaValue mod(double rhs) {
    return LuaDouble.dmod(v, rhs);
  }

  public LuaValue mod(int rhs) {
    return LuaDouble.dmod(v, rhs);
  }

  public LuaValue modFrom(double lhs) {
    return LuaDouble.dmod(lhs, v);
  }

  // relational operators
  public LuaValue lt(LuaValue rhs) {
    return rhs.gt_b(v) ? TRUE : FALSE;
  }

  public LuaValue lt(double rhs) {
    return v < rhs ? TRUE : FALSE;
  }

  public LuaValue lt(int rhs) {
    return v < rhs ? TRUE : FALSE;
  }

  public boolean lt_b(LuaValue rhs) {
    return rhs.gt_b(v);
  }

  public boolean lt_b(int rhs) {
    return v < rhs;
  }

  public boolean lt_b(double rhs) {
    return v < rhs;
  }

  public LuaValue lteq(LuaValue rhs) {
    return rhs.gteq_b(v) ? TRUE : FALSE;
  }

  public LuaValue lteq(double rhs) {
    return v <= rhs ? TRUE : FALSE;
  }

  public LuaValue lteq(int rhs) {
    return v <= rhs ? TRUE : FALSE;
  }

  public boolean lteq_b(LuaValue rhs) {
    return rhs.gteq_b(v);
  }

  public boolean lteq_b(int rhs) {
    return v <= rhs;
  }

  public boolean lteq_b(double rhs) {
    return v <= rhs;
  }

  public LuaValue gt(LuaValue rhs) {
    return rhs.lt_b(v) ? TRUE : FALSE;
  }

  public LuaValue gt(double rhs) {
    return v > rhs ? TRUE : FALSE;
  }

  public LuaValue gt(int rhs) {
    return v > rhs ? TRUE : FALSE;
  }

  public boolean gt_b(LuaValue rhs) {
    return rhs.lt_b(v);
  }

  public boolean gt_b(int rhs) {
    return v > rhs;
  }

  public boolean gt_b(double rhs) {
    return v > rhs;
  }

  public LuaValue gteq(LuaValue rhs) {
    return rhs.lteq_b(v) ? TRUE : FALSE;
  }

  public LuaValue gteq(double rhs) {
    return v >= rhs ? TRUE : FALSE;
  }

  public LuaValue gteq(int rhs) {
    return v >= rhs ? TRUE : FALSE;
  }

  public boolean gteq_b(LuaValue rhs) {
    return rhs.lteq_b(v);
  }

  public boolean gteq_b(int rhs) {
    return v >= rhs;
  }

  public boolean gteq_b(double rhs) {
    return v >= rhs;
  }

  // string comparison
  public int strcmp(LuaString rhs) {
    typerror("attempt to compare number with string");
    return 0;
  }

  public int checkint() {
    return v;
  }

  public long checklong() {
    return v;
  }

  public double checkdouble() {
    return v;
  }

  public String checkjstring() {
    return String.valueOf(v);
  }

  public LuaString checkstring() {
    return valueOf(String.valueOf(v));
  }

}