luastate.java

luajava应用

  }

  public synchronized void getGlobal(String global)
  {
//    pushString(global);
//    getTable(LUA_GLOBALSINDEX.intValue());
    _getGlobal(luaState, global);
  }

  public synchronized void setGlobal(String name)
  {
    //pushString(name);
    //insert(-2);
    //setTable(LUA_GLOBALSINDEX.intValue());
	_setGlobal(luaState, name);
  }
  
  // Functions to open lua libraries
  public void openBase()
  {
    _openBase(luaState);
  }
  public void openTable()
  {
    _openTable(luaState);
  }
  public void openIo()
  {
    _openIo(luaState);
  }
  public void openOs()
  {
	  _openOs(luaState);
  }
  public void openString()
  {
    _openString(luaState);
  }
  public void openMath()
  {
    _openMath(luaState);
  }
  public void openDebug()
  {
    _openDebug(luaState);
  }
  public void openPackage()
  {
	  _openPackage(luaState);
  }
  public void openLibs()
  {
    _openLibs(luaState);
  }


  /********************** Luajava API Library **********************/

  /**
   * Initializes lua State to be used by luajava
   * @param cptr
   * @param stateId
   */
  private synchronized native void luajava_open(CPtr cptr, int stateId);
  /**
   * Gets a Object from a userdata
   * @param L
   * @param idx index of the lua stack
   * @return Object
   */
  private synchronized native Object _getObjectFromUserdata(CPtr L, int idx) throws LuaException;

  /**
   * Returns whether a userdata contains a Java Object
   * @param L
   * @param idx index of the lua stack
   * @return boolean
   */
  private synchronized native boolean _isObject(CPtr L, int idx);

  /**
   * Pushes a Java Object into the state stack
   * @param L
   * @param obj
   */
  private synchronized native void _pushJavaObject(CPtr L, Object obj);

  /**
   * Pushes a JavaFunction into the state stack
   * @param L
   * @param func
   */
  private synchronized native void _pushJavaFunction(CPtr L, JavaFunction func) throws LuaException;

  /**
   * Returns whether a userdata contains a Java Function
   * @param L
   * @param idx index of the lua stack
   * @return boolean
   */
  private synchronized native boolean _isJavaFunction(CPtr L, int idx);

  /**
   * Gets a Object from Lua
   * @param idx index of the lua stack
   * @return Object
   * @throws LuaException if the lua object does not represent a java object.
   */
  public Object getObjectFromUserdata(int idx) throws LuaException
  {
    return _getObjectFromUserdata(luaState, idx);
  }

  /**
   * Tells whether a lua index contains a java Object
   * @param idx index of the lua stack
   * @return boolean
   */
  public boolean isObject(int idx)
  {
    return _isObject(luaState, idx);
  }

  /**
   * Pushes a Java Object into the lua stack.<br>
   * This function does not check if the object is from a class that could
   * be represented by a lua type. Eg: java.lang.String could be a lua string.
   * @param obj Object to be pushed into lua
   */
  public void pushJavaObject(Object obj)
  {
    _pushJavaObject(luaState, obj);
  }

  /**
   * Pushes a JavaFunction into the state stack
   * @param func
   */
  public void pushJavaFunction(JavaFunction func) throws LuaException
  {
    _pushJavaFunction(luaState, func);
  }

  /**
   * Returns whether a userdata contains a Java Function
   * @param idx index of the lua stack
   * @return boolean
   */
  public boolean isJavaFunction(int idx)
  {
    return _isJavaFunction(luaState, idx);
  }

  /**
   * Pushes into the stack any object value.<br>
   * This function checks if the object could be pushed as a lua type, if not
   * pushes the java object.
   * @param obj
   */
  public void pushObjectValue(Object obj) throws LuaException
  {
    if (obj == null)
    {
      pushNil();
    }
    else if (obj instanceof Boolean)
    {
      Boolean bool = (Boolean) obj;
      pushBoolean(bool.booleanValue());
    }
    else if (obj instanceof Number)
    {
      pushNumber(((Number) obj).doubleValue());
    }
    else if (obj instanceof String)
    {
      pushString((String) obj);
    }
    else if (obj instanceof JavaFunction)
    {
      JavaFunction func = (JavaFunction) obj;
      pushJavaFunction(func);
    }
    else if (obj instanceof LuaObject)
    {
      LuaObject ref = (LuaObject) obj;
      ref.push();
    }
    else if (obj instanceof byte[])
    {
      pushString((byte[]) obj);
    }
    else
    {
      pushJavaObject(obj);
    }
  }

  /**
   * Function that returns a Java Object equivalent to the one in the given
   * position of the Lua Stack.
   * @param idx Index in the Lua Stack
   * @return Java object equivalent to the Lua one
   */
	public synchronized Object toJavaObject( int idx ) throws LuaException
	{
		Object obj = null;

		if (isBoolean(idx))
		{
			obj = new Boolean(toBoolean(idx));
		}
		else if (type(idx) == LuaState.LUA_TSTRING.intValue())
		{
			obj = toString(idx);
		}
		else if (isFunction(idx))
		{
			obj = getLuaObject(idx);
		}
		else if (isTable(idx))
		{
			obj = getLuaObject(idx);
		}
		else if (type(idx) == LuaState.LUA_TNUMBER.intValue())
		{
				obj = new Double(toNumber(idx));
		}
		else if (isUserdata(idx))
		{
			if (isObject(idx))
			{
				obj = getObjectFromUserdata(idx);
			}
			else
			{
				obj = getLuaObject(idx);
			}
		}
		else if (isNil(idx))
		{
			obj = null;
		}

		return obj;
	}

	/**
	 * Creates a reference to an object in the variable globalName
	 * @param globalName
	 * @return LuaObject
	 */
	public LuaObject getLuaObject(String globalName)
	{
		return new LuaObject(this, globalName);
	}

	/**
	 * Creates a reference to an object inside another object
     * @param parent The Lua Table or Userdata that contains the Field.
     * @param name The name that index the field
	 * @return LuaObject
	 * @throws LuaException if parent is not a table or userdata
	 */
	public LuaObject getLuaObject(LuaObject parent, String name)
		throws LuaException
	{
		if (parent.L.getCPtrPeer() != luaState.getPeer())
			throw new LuaException("Object must have the same LuaState as the parent!");

		return new LuaObject(parent, name);
	}

	/**
	 * This constructor creates a LuaObject from a table that is indexed by a number.
	 * @param parent The Lua Table or Userdata that contains the Field.
	 * @param name The name (number) that index the field
	 * @return LuaObject
	 * @throws LuaException When the parent object isn't a Table or Userdata
	 */
	public LuaObject getLuaObject(LuaObject parent, Number name)
		throws LuaException
	{
		if (parent.L.getCPtrPeer() != luaState.getPeer())
			throw new LuaException("Object must have the same LuaState as the parent!");

		return new LuaObject(parent, name);
	}
	
	/**
	 * This constructor creates a LuaObject from a table that is indexed by any LuaObject.
	 * @param parent The Lua Table or Userdata that contains the Field.
	 * @param name The name (LuaObject) that index the field
	 * @return LuaObject
	 * @throws LuaException When the parent object isn't a Table or Userdata
	 */
	public LuaObject getLuaObject(LuaObject parent, LuaObject name)
		throws LuaException
	{
	  if (parent.getLuaState().getCPtrPeer() != luaState.getPeer() ||
	      parent.getLuaState().getCPtrPeer() != name.getLuaState().getCPtrPeer())
	    throw new LuaException("Object must have the same LuaState as the parent!");

	  return new LuaObject(parent, name);
	}

	/**
	 * Creates a reference to an object in the <code>index</code> position
	 * of the stack
	 * @param index position on the stack
	 * @return LuaObject
	 */
	public LuaObject getLuaObject(int index)
	{
		return new LuaObject(this, index);
	}

	/**
	 * When you call a function in lua, it may return a number, and the
	 * number will be interpreted as a <code>Double</code>.<br>
	 * This function converts the number into a type specified by 
	 * <code>retType</code>
	 * @param db lua number to be converted
	 * @param retType type to convert to
	 * @return The converted number
	 */
	public static Number convertLuaNumber(Double db, Class retType)
	{
	  // checks if retType is a primitive type
    if (retType.isPrimitive())
    {
      if (retType == Integer.TYPE)
      {
        return new Integer(db.intValue());
      }
      else if (retType == Long.TYPE)
      {
        return new Long(db.longValue());
      }
      else if (retType == Float.TYPE)
      {
        return new Float(db.floatValue());
      }
      else if (retType == Double.TYPE)
      {
        return db;
      }
      else if (retType == Byte.TYPE)
      {
        return new Byte(db.byteValue());
      }
      else if (retType == Short.TYPE)
      {
        return new Short(db.shortValue());
      }
    }
    else if (retType.isAssignableFrom(Number.class))
    {
      // Checks all possibilities of number types
      if (retType.isAssignableFrom(Integer.class))
      {
        return new Integer(db.intValue());
      }
      else if (retType.isAssignableFrom(Long.class))
      {
        return new Long(db.longValue());
      }
      else if (retType.isAssignableFrom(Float.class))
      {
        return new Float(db.floatValue());
      }
      else if (retType.isAssignableFrom(Double.class))
      {
        return db;
      }
      else if (retType.isAssignableFrom(Byte.class))
      {
        return new Byte(db.byteValue());
      }
      else if (retType.isAssignableFrom(Short.class))
      {
        return new Short(db.shortValue());
      }
    }
    
    // if all checks fail, return null
    return null;	  
	}
}