Quadcap Embeddable Database

com/quadcap/sql/types/ValueInteger.java

Go to the documentation of this file.

package com.quadcap.sql.types;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

import com.quadcap.util.Util;

import com.quadcap.sql.io.Extern;
import com.quadcap.sql.io.Externable;
import com.quadcap.sql.io.ExternalizeProxy;

/**
 * An <b>int</b> value.
 *
 * @author Stan Bailes
 */
public class ValueInteger extends Value
implements Externalizable, ExternalizeProxy, Externable {
    public static ValueInteger          MINUS_ONE
    =                                   new ValueInteger(-1);
    public static ValueInteger          ZERO
    =                                   new ValueInteger(0);
    public static ValueInteger          PLUS_ONE
    =                                   new ValueInteger(1);
    public static ValueInteger          MIN_VALUE
    =                                   new ValueInteger(Integer.MIN_VALUE);

    int                                 val;

    public ValueInteger() {}
    
    public ValueInteger(int val) { this.val = val; }

    public int intValue() { return val; }
    
    public Value unop(int op) throws ValueException {
        switch (op) {
        case Op.NULL:
            return ValueBoolean.falseBoolean;
        case Op.PLUS:
            return this;
        case Op.MINUS:
            return new ValueInteger(0 - val);
        default:
            throw new ValueException("Unary op: " + Op.toString(op) +
                                     " not implemented for this type");
        }
    }
    
    public Value binop(int op, Value l) throws ValueException {
        return l.binop(op, this);
    }

    public Value binop(int op, ValueNull r) throws ValueException {
        switch (op) {
        case Op.EQ:
        case Op.NE:
        case Op.LT:
        case Op.LE:
        case Op.GT:
        case Op.GE:
            return ValueUnknown.valueUnknown;
        case Op.PLUS:
        case Op.MINUS:
        case Op.TIMES:
        case Op.DIVIDE:
        case Op.EXP:
            return r;
        case Op.COMPARE:
            return r.valCmpNull();
        default:
            throw badBinop(op, r);
        }
    }

    public Value binop(int op, ValueInteger r) throws ValueException {
        return ValueInteger.binop(op, this, r);
    }

    public Value binop(int op, ValueScaledInteger r) throws ValueException {
        return ValueScaledInteger.binop(op, new ValueScaledInteger(val), r);
    }

    public Value binop(int op, ValueShort r) throws ValueException {
        return ValueInteger.binop(op, this, new ValueInteger(r.val));
    }

    public Value binop(int op, ValueByte r) throws ValueException {
        return ValueInteger.binop(op, this, new ValueInteger(r.val));
    }

    public Value binop(int op, ValueDouble r) throws ValueException {
        return ValueDouble.binop(op, new ValueDouble(val), r);
    }

    public Value binop(int op, ValueLong r) throws ValueException {
        return ValueLong.binop(op, new ValueLong(val), r);
    }

    public Value binop(int op, ValueFloat r) throws ValueException {
        return ValueFloat.binop(op, new ValueFloat(val), r);
    }

    public static final Value binop(int op, ValueInteger e, ValueInteger f)
        throws ValueException
    {
        switch (op) {
        case Op.DIVIDE:
            try {
                return new ValueInteger(e.val / f.val);
            } catch (ArithmeticException ex) {
                throw new ValueException("divide by zero");
            }
        case Op.EQ:
            return new ValueBoolean(e.val == f.val);
        case Op.EXP:
            return new ValueInteger((int)(Math.pow(e.val, f.val)));
        case Op.GE:
            return new ValueBoolean(e.val >= f.val);
        case Op.GT:
            return new ValueBoolean(e.val > f.val);         
        case Op.LE:
            return new ValueBoolean(e.val <= f.val);        
        case Op.LT:
            return new ValueBoolean(e.val < f.val);         
        case Op.MINUS:
            return new ValueInteger(e.val - f.val);
        case Op.NE:
            return new ValueBoolean(e.val != f.val);        
        case Op.PLUS:
            return new ValueInteger(e.val + f.val);
        case Op.TIMES:
            return new ValueInteger(e.val * f.val);
        case Op.COMPARE:
            if (e.val < f.val) return MINUS_ONE;
            if (e.val > f.val) return PLUS_ONE;
            return ZERO;
            
        default:
            throw badBinop(op, e, f);
        }
    } 

    public void readExternal(ObjectInput in) throws IOException {
        val = in.readInt();
    }
    
    public void writeExternal(ObjectOutput out)
        throws IOException
    {
        out.writeInt(val);
    }

    public Object readObject(ObjectInput in)
        throws IOException, ClassNotFoundException
    {
        ValueInteger v = new ValueInteger();
        v.readExternal(in);
        return v;
    }

    public void writeObject(ObjectOutput out, Object object)
        throws IOException
    {
        ((ValueInteger)object).writeExternal(out);
    }

    public Object asJavaObject() {
        return new Integer(val);
    }

    public void fromJavaObject(Object obj) throws ValueException {
        if (obj instanceof Integer) {
            val = ((Integer)obj).intValue();
        } else {
            throw new ValueException("bad type: " + obj);
        }
    }

    public String toString() { return Integer.toString(val); }

    public Value convert(TypeBoolean type) throws ValueException {
        return TypeBoolean.convertNumber(val);
    }

    public Value convert(TypeTinyInt type) throws ValueException {
        return TypeTinyInt.convertNumber(val);
    }

    public Value convert(TypeSmallInt type) throws ValueException {
        return TypeSmallInt.convertNumber(val);
    }

    public Value convert(TypeInt type) throws ValueException {
        return this;
    }

    public Value convert(TypeBigInt type) throws ValueException {
        return new ValueLong(val);
    }

    public Value convert(TypeDecimal type) throws ValueException {
        return type.convertNumber((long)val);
    }

    public Value convert(TypeReal type) throws ValueException {
        if (type.getMaxPrecision() >= 32) {
            return new ValueDouble((double)val);
        } else {
            return new ValueFloat((float)val);
        }
    }

    public Type getType() {
        return TypeInt.typeInt;
    }

    public void serializeKey(KeyStream out) throws IOException {
        out.writeInt(val);
    }

    static Extern                       extern = null;
    public Extern getExtern() { return extern; }
    public void setExtern(Extern extern) { ValueInteger.extern = extern; }
        
}