value.java

RESIN 3.2 最新源码

  /**
   * Converts to a Java Calendar.
   */
  public Calendar toJavaCalendar()
  {
    Calendar cal = Calendar.getInstance();
    
    cal.setTimeInMillis(toLong());
    
    return cal;
  }
  
  /**
   * Converts to a Java Date.
   */
  public Date toJavaDate()
  {
    return new Date(toLong());
  }
  
  /**
   * Converts to a Java URL.
   */
  public URL toJavaURL(Env env)
  {
    try {
      return new URL(toString());
    }
    catch (MalformedURLException e) {
      env.warning(L.l(e.getMessage()));
      return null;
    }
  }
  
  /**
   * Converts to a Java BigDecimal.
   */
  public BigDecimal toBigDecimal()
  {
    return new BigDecimal(toString());
  }
  
  /**
   * Converts to a Java BigInteger.
   */
  public BigInteger toBigInteger()
  {
    return new BigInteger(toString());
  }

  /**
   * Converts to an exception.
   */
  public QuercusException toException(Env env, String file, int line)
  {
    putField(env, env.createString("file"), env.createString(file));
    putField(env, env.createString("line"), LongValue.create(line));
    
    return new QuercusLanguageException(this);
  }

  /**
   * Converts to a raw value.
   */
  public Value toValue()
  {
    return this;
  }

  /**
   * Converts to a key.
   */
  public Value toKey()
  {
    throw new QuercusRuntimeException(L.l("{0} is not a valid key", this));
  }

  /**
   * Convert to a ref.
   */
  public Value toRef()
  {
    return this;
  }

  /**
   * Convert to a function argument value, e.g. for
   *
   * function foo($a)
   *
   * where $a is never assigned or modified
   */
  public Value toArgValueReadOnly()
  {
    return this;
  }

  /**
   * Convert to a function argument value, e.g. for
   *
   * function foo($a)
   *
   * where $a is never assigned, but might be modified, e.g. $a[3] = 9
   */
  public Value toArgValue()
  {
    return this;
  }

  /**
   * Convert to a function argument reference value, e.g. for
   *
   * function foo(&$a)
   *
   * where $a is never assigned in the function
   */
  public Value toRefValue()
  {
    return this;
  }

  /**
   * Convert to a function argument value, e.g. for
   *
   * function foo($a)
   *
   * where $a is used as a variable in the function
   */
  public Var toVar()
  {
    return new Var(toArgValue());
  }

  /**
   * Convert to a function argument reference value, e.g. for
   *
   * function foo(&$a)
   *
   * where $a is used as a variable in the function
   */
  public Var toRefVar()
  {
    return new Var(this);
  }

  /**
   * Converts to a StringValue.
   */
  public StringValue toStringValue()
  {
    return Env.getInstance().createString(toString());
  }

  /**
   * Converts to a UnicodeValue.
   */
  public StringValue toUnicodeValue()
  {
    return toUnicodeValue(Env.getInstance());
  }

  /**
   * Converts to a UnicodeValue.
   */
  public StringValue toUnicodeValue(Env env)
  {
    return env.createString(toString());
  }

  /**
   * Converts to a BinaryValue.
   */
  public StringValue toBinaryValue()
  {
    return toBinaryValue(Env.getInstance());
  }

  /**
   * Converts to a BinaryValue.
   */
  public StringValue toBinaryValue(Env env)
  {
    StringValue bb = env.createBinaryBuilder();

    bb.append(this);

    return bb;
      
      /*
    try {
      int length = 0;
      while (true) {
        bb.ensureCapacity(bb.getLength() + 256);

        int sublen = is.read(bb.getBuffer(),
                             bb.getOffset(),
                             bb.getLength() - bb.getOffset());

        if (sublen <= 0)
          return bb;
        else {
          length += sublen;
          bb.setOffset(length);
        }
      }
    } catch (IOException e) {
      throw new QuercusException(e);
    }
      */
  }

  /**
   * Returns a byteArrayInputStream for the value.
   * See TempBufferStringValue for how this can be overriden
   *
   * @return InputStream
   */
  public InputStream toInputStream()
  {
    return new StringInputStream(toString());
  }

  /**
   * Converts to a string builder
   */
  public StringValue toStringBuilder()
  {
    // XXX: should be illegal?
    return new UnicodeBuilderValue(toString(), 32);
  }

  /**
   * Converts to a string builder
   */
  public StringValue toStringBuilder(Env env)
  {
    return env.createUnicodeBuilder().appendUnicode(this);
  }

  /**
   * Converts to a long vaule
   */
  public LongValue toLongValue()
  {
    return new LongValue(toLong());
  }

  /**
   * Converts to a double vaule
   */
  public DoubleValue toDoubleValue()
  {
    return new DoubleValue(toDouble());
  }

  //
  // Operations
  //

  /**
   * Append to a string builder.
   */
  public StringValue appendTo(UnicodeBuilderValue sb)
  {
    return sb.append(toString());
  }

  /**
   * Append to a binary builder.
   */
  public StringValue appendTo(StringBuilderValue sb)
  {
    return sb.append(toString());
  }

  /**
   * Append to a binary builder.
   */
  public StringValue appendTo(BinaryBuilderValue sb)
  {
    return sb.appendBytes(toString());
  }
  
  /**
   * Append to a binary builder.
   */
  public StringValue appendTo(LargeStringBuilderValue sb)
  {
    return sb.append(toString());
  }

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

  /**
   * Copy as an array item
   */
  public Value copyArrayItem()
  {
    return copy();
  }

  /**
   * Copy as a return value
   */
  public Value copyReturn()
  {
    // php/3a5d

    return this;
  }

  /**
   * Copy for serialization
   */
  public final Value copy(Env env)
  {
    return copy(env, new IdentityHashMap<Value,Value>());
  }

  /**
   * Copy for serialization
   */
  public Value copy(Env env, IdentityHashMap<Value,Value> map)
  {
    return this;
  }

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

  /**
   * Clone for the clone keyword
   */
  public Value clone()
  {
    return this;
  }

  /**
   * Returns the type.
   */
  public String getType()
  {
    return "value";
  }
  
  /*
   * Returns the resource type.
   */
  public String getResourceType()
  {
    return null;
  }

  /**
   * Returns the current key
   */
  public Value key()
  {
    return NullValue.NULL;
  }

  /**
   * Returns the current value
   */
  public Value current()
  {
    return NullValue.NULL;
  }

  /**
   * Returns the current value
   */
  public Value next()
  {
    return BooleanValue.FALSE;
  }

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

  //
  // Methods from hash parameters
  //

  /**
   * Evaluates a method.
   */
  public Value callMethod(Env env,
                          int hash, char []name, int nameLen,
                          Expr []args)
  {
    Value []value = new Value[args.length];

    for (int i = 0; i < args.length; i++) {
      value[i] = args[i].eval(env);
    }

    return callMethod(env, hash, name, nameLen,
                      value);
  }

  /**
   * Evaluates a method.
   */
  public Value callMethod(Env env,
                          int hash, char []name, int nameLen,
                          Value []args)
  {
    switch (args.length) {
    case 0:
      return callMethod(env, hash, name, nameLen);

    case 1:
      return callMethod(env, hash, name, nameLen,
                        args[0]);

    case 2:
      return callMethod(env, hash, name, nameLen,
                        args[0], args[1]);

    case 3:
      return callMethod(env, hash, name, nameLen,
                        args[0], args[1], args[2]);

    case 4:
      return callMethod(env, hash, name, nameLen,
                        args[0], args[1], args[2], args[3]);

    case 5:
      return callMethod(env, hash, name, nameLen,
                        args[0], args[1], args[2], args[3], args[4]);

    default:
      return errorNoMethod(env, name, nameLen);
    }
  }

  /**
   * Evaluates a method with 0 args.
   */
  public Value callMethod(Env env,
                          int hash, char []name, int nameLen)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 1 arg.
   */
  public Value callMethod(Env env,
                          int hash, char []name, int nameLen,
                          Value a0)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 1 arg.
   */
  public Value callMethod(Env env,
                          int hash, char []name, int nameLen,
                          Value a0, Value a1)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 3 args.
   */
  public Value callMethod(Env env, 
                          int hash, char []name, int nameLen,
			  Value a0, Value a1, Value a2)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 4 args.
   */
  public Value callMethod(Env env, 
                          int hash, char []name, int nameLen,
			  Value a0, Value a1, Value a2, Value a3)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 5 args.
   */
  public Value callMethod(Env env, 
                          int hash, char []name, int nameLen,
			  Value a0, Value a1, Value a2, Value a3, Value a5)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method.
   */
  public Value callMethodRef(Env env, 
                             int hash, char []name, int nameLen,
                             Expr []args)
  {
    Value []value = new Value[args.length];

    for (int i = 0; i < args.length; i++) {
      value[i] = args[i].eval(env);
    }

    return callMethodRef(env, hash, name, nameLen, value);
  }

  /**
   * Evaluates a method.
   */
  public Value callMethodRef(Env env,
                             int hash, char []name, int nameLen,
                             Value []args)
  {
    switch (args.length) {
    case 0:
      return callMethodRef(env, hash, name, nameLen);

    case 1:
      return callMethodRef(env, hash, name, nameLen,
                           args[0]);

    case 2:
      return callMethodRef(env, hash, name, nameLen,
                           args[0], args[1]);

    case 3:
      return callMethodRef(env, hash, name, nameLen,
                           args[0], args[1], args[2]);

    case 4:
      return callMethodRef(env, hash, name, nameLen,
                           args[0], args[1], args[2], args[3]);

    case 5:
      return callMethodRef(env, hash, name, nameLen,
                           args[0], args[1], args[2], args[3], args[4]);

    default:
      return errorNoMethod(env, name, nameLen);
    }
  }

  /**
   * Evaluates a method with 0 args.
   */
  public Value callMethodRef(Env env, int hash, char []name, int nameLen)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 1 arg.
   */
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a0)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**
   * Evaluates a method with 1 arg.
   */
  public Value callMethodRef(Env env, int hash, char []name, int nameLen,
                             Value a0, Value a1)
  {
    return errorNoMethod(env, name, nameLen);
  }

  /**