variant.java

一个简单的visio程序。

package HECore.stddata;
import HPCore.Exception.*;
import java.util.*;
public class Variant implements Cloneable{
  private VArray array=null;
  public static final short V_EMPTY = 1;
  public static final short V_BYTE = 2;
  public static final short V_BOL = 3;
  public static final short V_INT = 4;
  public static final short V_LONG = 5;
  public static final short V_SINGLE = 6;
  public static final short V_DBL = 7;
  public static final short V_STR = 9;
  public static final short V_FIX_STR = 8;
  public static final short V_CURR  = 10;
  public static final short V_DATE = 11;
  public static final short V_OBJ = 12;
  public static final short V_NULL = 19;
  public static final short V_ERR = 20;
  public static final short V_ARR = 21;
  public static final short V_UDT = 22;
  public static final short V_CTL = 23;

  public static final short V_VAR = 30;
  private VObject vobj=null;
  public Variant()
  {
   array = null; 
   vobj=null;
  }
  
   /**
    *  Create a variant for an array
    */

  public Variant(VArray array) {
    this.array =  array;
   }

  public VArray getArray(){
   return array;
   }
  public Object objValue() throws HpException
  {
      if(vobj!=null)
		  return vobj.objValue();
	  else
		  return null;

  }
  public static Variant newNull(){
  return new VNull();
  }

  public void setArray(VArray array){
    this.array=array;
   }

   /**
    *  De
	clared a variable was a variant, then redeclared it
    *  is a variant array.
    */

  public void var2array(int dim ,int type)
   {
      array = new VArray(dim ,type);
   }

  public short intValue() throws HpException
  {
    return 0;
  }

  public double dblValue() throws HpException
  {
        return 0.0;
  }

  public boolean boolValue() throws HpException
  {
     return false;
  }

  public String toString()  {
    return "";         
  }

  public String strValue()
  {
      return "";

  }
 
  
  public short byteValue() throws HpException 
  {
       return 0;
  }
 
  
  public  float sglValue() throws HpException
  {
     return 0f;
   
  }

 
  public HDate dateValue()
		{
		   return new HDate(0.0);
		}
		
		public HCurr currValue()
		{
		  return new HCurr(0.0);
		}

		public int lngValue () throws HpException
  {
      return 0;
  }
  
   /**
     * Returns a integer represents a variant type.
     * return array type if this object is a array 
     * otherwise return <code>Empty</code> type.
     */
  
  public short getType()
  {
     return (array == null)? V_EMPTY : V_ARR;
  }

 public Variant Add(Variant b) throws HpException
 {
    if(b.getType()==V_NULL)
	 return new VNull();     
	 return b;
 }

 public Variant Sub(Variant b) throws HpException
 {
    
	if(b.getType()==V_NULL)
	 return new VNull();    
	 if(b.getType()==V_STR)
	 return new VDouble(0-b.dblValue());
	else
	 if(b.getType()==V_DBL)
       return new VDouble(0-b.dblValue());
    else
       return new VInt(0-b.dblValue());
 }
 public  VString Link(Variant b) 
 {
    if(b.getType()==V_NULL)
	 return new VString("");
    else
	 return new VString(b.toString());
 }

    
  public  Variant Mult(Variant b) throws HpException 
  {
    if(b.getType()==V_NULL)
	 return new VNull();     
	return new  VInt(0);
  }
 
  public  Variant Div(Variant b) throws HpException 
  {
      if(b.getType()==V_NULL)
	   return new VNull();   
	  if(b.dblValue() ==0.0)
		throw new HpException(11,"Division by Zero.");
	  return new  VInt(0);

  }
  public  Variant DDiv(Variant b) throws HpException 
  {
      if(b.getType()==V_NULL)
	    return new VNull();     
	  if(b.dblValue() ==0.0)
	    throw new HpException(11,"Divsion by Zero.");
	  return new VInt(0);

  }
  public Variant Like(Variant a) throws HpException
  {
    if(a.getType()==V_NULL)
	  return new VNull();  
	else
	 if(a.getType()==V_EMPTY) 
     return new VBoolean(true);
    else
     return new VBoolean(false);     
   
  }
  
  public Variant Xor(Variant a) throws HpException
  {
    if(a.getType()==V_NULL)
	 return new VNull();      
	return new VInt(a.dblValue());;
  }

  public Variant Or(Variant a) throws HpException
  {

   	if(a.getType()==V_NULL)
	  return new VNull();
	 if (a.getType()==V_EMPTY ||this.getType()==V_EMPTY) 
	    return new VLong(a.lngValue());   
	return new VInt(a.dblValue());
  }

  public Variant And(Variant a) throws HpException
  {
     return new VInt(0);
  }

  public Variant Eqv(Variant a) throws HpException
  {
    if(a.getType()==V_NULL)
	 return  new VNull();    
	int bvalue= (int)a.dblValue();
    double value = (double)(~((int)0 ^ bvalue)); 
    VLong result=new VLong(value);
    return result;   


  }
 
  public Variant Imp(Variant a) throws HpException
  {
      return new VInt(-1);
  }

  public Variant Mod(Variant a) throws HpException
  {
    if(a.dblValue() ==0)
		throw new HpException(11,"Division by Zero.");
	if(a.getType()==V_NULL)
	 return new VNull();   
	return new VInt(0);;     
  }
    
  public Variant Not() 
  {  
        if(getType()==V_EMPTY)
			  return new VInt(-1);
	    else
			return null;
     
  }
 
  public Variant Pow(Variant b) throws HpException
  {
    
	if(b.getType()==V_NULL)
	 return new VNull();    
	else
	 if(b.getType()==V_EMPTY)
		return new VInt(1);
	else
	 if(b.dblValue()==0)
    	return new VInt(1);
	else
		return new VInt(0);
  }

  
  public Variant Great(Variant b,boolean flag) throws HpException
  {
      if(b.getType()==V_NULL)
	   return new VNull();
      return new VBoolean(false);
  }
 
 
 public Variant Less(Variant b,boolean flag)  throws HpException
 {  
       
        if(b.getType()==V_NULL)
		 return new VNull();
        if(b.getType()==V_EMPTY)
			return new VBoolean(false);
		    return new VBoolean(true);
     
 }

 
 public Variant Equal(Variant b,boolean flag) throws HpException
 {  
        if(b.getType()==V_NULL)
		      return new VNull();   
        if(b.getType()==V_EMPTY)
			         return new VBoolean(true);
	           return new VBoolean(false);
 } 
 public Variant GreatEqual(Variant b,boolean flag) throws HpException
 {  
        if(b.getType()==V_NULL)
		        return  new VNull();   
        if(b.getType()==V_EMPTY)
			        return new VBoolean(true);
	          return new VBoolean(false);     
 } 
 public Variant LessEqual(Variant b,boolean flag) throws HpException
 {  
   if(b.getType()==V_NULL)
		  return new VNull();   
	   return new VBoolean(true);     
 }

 public Variant NotEqual(Variant b,boolean flag) throws HpException
 {  
        if(b.getType()==V_NULL)
		    return new VNull();   
        if(b.getType()==V_EMPTY)
			        return new VBoolean(false);
	          return new VBoolean(true);    
     
 } 

 /*************************************


  ************************************/
 
  
  
    /**
      *  Create a variant object of number. 
      */

    public static Variant newVariant(short type, double db) {
         switch(type) {
 	     case V_BYTE :   return new VByte(db);
	     case V_INT :    return new VInt(db);
	     case V_LONG :   return new VLong(db);
	     case V_SINGLE : return new VSingle(db);
		 case V_BOL    : return new VBoolean(db);
		 case V_DBL :    return new VDouble(db);
         case V_DATE:    return new VDate(db);
         case V_CURR:    return new VCurr(db);
         case V_STR:     return new VString(String.valueOf(db));
         case V_FIX_STR: return new VString(String.valueOf(db).getBytes());
         default : return null;
         }
      }
   
     /**
      * Create a variant object of String. 
      */

    public static Variant newVariant(String val) {
      return new VString(val);  
      }
    
    /**
      * Create a variant object of fixed-String. 
      */

    public static Variant newVariant(fixedString val) {
       return new VString(val);
    
      }

    /**
      * Create a variant object of Boolean. 
      */

    public static Variant newVariant(boolean val) {
      return new VBoolean(val);
      }


       
	public void dynamic(int num) {
      if(array != null)
       array.dynamic(num);
	}

    public VArray push(double ldim,double hdim)
	{
       return array.push(ldim,hdim);
	}

	
 	
	public VArray popr(short dim) throws HpException
	{
     if(array!=null)  
	  return array.popr(dim);
     else
     {
       //throw new Exception("Run-time error 13:Type mismatch");
         return null;

     }
	}
    
	public VArray popr(int dim) throws HpException
	{
       
	 if(array!=null) 
         return array.popr(dim);
     else
      return null;
	}

	public VArray popr(float dim) throws HpException
	{
     if(array!=null) 
	  return array.popr(dim);
     else
      return null;
	}

	public VArray popr(double dim) throws HpException
	{
     if(array!=null) 
	  return array.popr(dim);
     else
      return null;
	}
	

	public VArray popr(Variant dim) throws HpException
	{
      if(array!=null)
        return array.popr(dim);