objectextvalue.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,740 行 · 第 1/3 页

    if (delegate != null)
      return delegate.getValueIterator(env, this);

    return new ValueIterator(_entries);
  }

  //
  // method calls
  //

  /**
   * Finds the method name.
   */
  @Override
  public AbstractFunction findFunction(String methodName)
  {
    return _quercusClass.findFunction(methodName);
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethod(Env env, int hash, char []name, int nameLen,
                          Expr []args)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);
      
      if (fun != null)
        return fun.callMethod(env, this, args);
      else if (_quercusClass.getCall() != null) {
        Expr []newArgs = new Expr[args.length + 1];
        newArgs[0] = new StringLiteralExpr(toMethod(name, nameLen));
        System.arraycopy(args, 0, newArgs, 1, args.length);
        
        return _quercusClass.getCall().callMethod(env, this, newArgs);
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethod(Env env, int hash, char []name, int nameLen,
                          Value []args)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this, args);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl(args));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethod(Env env, int hash, char []name, int nameLen)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl());
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethod(Env env, int hash, char []name, int nameLen,
                          Value a1)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this, a1);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl()
                  .append(a1));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethod(Env env, int hash, char []name, int nameLen,
                          Value a1, Value a2)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this, a1, a2);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl()
                  .append(a1)
                  .append(a2));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * calls the function.
   */
  @Override
  public Value callMethod(Env env, 
                          int hash, char []name, int nameLen,
			  Value a1, Value a2, Value a3)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this, a1, a2, a3);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl()
                  .append(a1)
                  .append(a2)
                  .append(a3));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }  

  /**
   * calls the function.
   */
  @Override
  public Value callMethod(Env env, 
                          int hash, char []name, int nameLen,
			  Value a1, Value a2, Value a3, Value a4)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this, a1, a2, a3, a4);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl()
                  .append(a1)
                  .append(a2)
                  .append(a3)
                  .append(a4));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }  

  /**
   * calls the function.
   */
  @Override
  public Value callMethod(Env env,
                          int hash, char []name, int nameLen,
			  Value a1, Value a2, Value a3, Value a4, Value a5)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethod(env, this, a1, a2, a3, a4, a5);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethod(env,
                  this,
                  env.createString(name, nameLen),
                  new ArrayValueImpl()
                  .append(a1)
                  .append(a2)
                  .append(a3)
                  .append(a4)
                  .append(a5));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }  

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Expr []args)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      return _quercusClass.callMethodRef(env, this, hash, name, nameLen, args);
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value []args)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this, args);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl(args));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl());
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a1)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this, a1);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl()
                     .append(a1));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a1, Value a2)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this, a1, a2);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl()
                     .append(a1)
                     .append(a2));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a1, Value a2, Value a3)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this, a1, a2, a3);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl()
                     .append(a1)
                     .append(a2)
                     .append(a3));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a1, Value a2, Value a3, Value a4)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this, a1, a2, a3, a4);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl()
                     .append(a1)
                     .append(a2)
                     .append(a3)
                     .append(a4));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a1, Value a2, Value a3, Value a4, Value a5)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      AbstractFunction fun = _methodMap.get(hash, name, nameLen);

      if (fun != null)
        return fun.callMethodRef(env, this, a1, a2, a3, a4, a5);
      else if ((fun = _quercusClass.getCall()) != null) {
        return fun.callMethodRef(env,
                     this,
                     env.createString(name, nameLen),
                     new ArrayValueImpl()
                     .append(a1)
                     .append(a2)
                     .append(a3)
                     .append(a4)
                     .append(a5));
      }
      else
        return env.error(L.l("Call to undefined method {0}::{1}()",
                             getName(), toMethod(name, nameLen)));
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Evaluates a method.
   */
  @Override
  public Value callClassMethod(Env env, AbstractFunction fun, Value []args)
  {
    String oldClassName = env.setCallingClassName(_className);
    
    try {
      return fun.callMethod(env, this, args);
    } finally {
      env.setCallingClassName(oldClassName);
    }
  }

  /**
   * Returns the value for the variable, creating an object if the var
   * is unset.
   */
  @Override
  public Value getObject(Env env)
  {
    return this;
  }

  @Override
  public Value getObject(Env env, Value index)
  {
    // php/3d92

    env.error(L.l("Can't use object '{0}' as array", getName()));

    return NullValue.NULL;
  }

  /**
   * Copy for assignment.
   */
  @Override
  public Value copy()
  {
    return this;
  }

  /**
   * Copy for serialization
   */
  @Override
  public Value copy(Env env, IdentityHashMap<Value,Value> map)
  {
    Value oldValue = map.get(this);

    if (oldValue != null)
      return oldValue;

    // XXX:
    // return new ObjectExtValue(env, map, _cl, getArray());

    return this;
  }

  /**
   * Copy for serialization
   */
  @Override
  public Value copyTree(Env env, CopyRoot root)
  {
    return new CopyObjectExtValue(env, this, root);
  }

  /**
   * Clone the object
   */
  @Override
  public Value clone()
  {
    ObjectExtValue newObject = new ObjectExtValue(_quercusClass);

    for (Map.Entry<Value,Value> entry : entrySet()) {
      newObject.putThisField(null,
			     (StringValue) entry.getKey(),
			     entry.getValue());
    }

    return newObject;
  }

  // XXX: need to check the other copy, e.g. for sessions

  /*
   * Serializes the value.
   * 
   * @param sb holds result of serialization