any.java

来自「OTP是开放电信平台的简称」· Java 代码 · 共 1,022 行 · 第 1/2 页

/* ``The contents of this file are subject to the Erlang Public License,
 * Version 1.1, (the "License"); you may not use this file except in
 * compliance with the License. You should have received a copy of the
 * Erlang Public License along with this software. If not, it can be
 * retrieved via the world wide web at http://www.erlang.org/.
 * 
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 * 
 * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
 * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
 * AB. All Rights Reserved.''
 * 
 *     $Id$
 */
package com.ericsson.otp.ic;


/**

The Any class is the java mapping of the any OMG-IDL type. 


**/


public class Any { 

  // Typecode value holder
  protected TypeCode tcV;

  // Primitive value holder
  protected java.lang.String stringV;
  protected byte byteV;
  protected boolean booleanV;
  protected char charV;
  protected short shortV;
  protected int intV;
  protected long longV;
  protected float floatV;
  protected double doubleV;

  // Streams used for user defined types
  protected com.ericsson.otp.erlang.OtpInputStream is;
  protected com.ericsson.otp.erlang.OtpOutputStream os;


  // Constructor
  public Any() {
    tcV = null;
  }

  // Equal function

  /**
    Any comparison method
    @return true if the input Any is equal to the object, false otherwize 
  **/
  public boolean equal(com.ericsson.otp.ic.Any _any) {
    
    int _is1Len,_is2Len;
    byte _compressed[];
    com.ericsson.otp.erlang.OtpInputStream _is1,_is2;
    TypeCode _tc = _any.type();
    
    if (!tcV.equal(_tc))
      return false;

    try {
    
      TCKind _tck = _tc.kind();
      
      switch (_tck.value()) {
	
      case TCKind._tk_short:
	return (_any.extract_short() == shortV);

      case TCKind._tk_ushort:
	return (_any.extract_ushort() == shortV);
	
      case TCKind._tk_long:	
	return (_any.extract_long() == intV);
	
      case TCKind._tk_longlong:	
	return (_any.extract_longlong() == longV);

      case TCKind._tk_ulong:
	return (_any.extract_ulong() == intV);

      case TCKind._tk_ulonglong:
	return (_any.extract_ulonglong() == longV);

      case TCKind._tk_float:
	return equal(_any.extract_float(),floatV);
	
      case TCKind._tk_double:
	return equal(_any.extract_double(),doubleV);
	
      case TCKind._tk_boolean:
	return (_any.extract_boolean() == booleanV);
	
      case TCKind._tk_char:
	return (_any.extract_char() == charV);
	
      case TCKind._tk_wchar:
	return (_any.extract_wchar() == charV);
	
      case TCKind._tk_octet:
	return (_any.extract_octet() == byteV);
	
      case TCKind._tk_string:
	return (_any.extract_string().compareTo(stringV) == 0);

      case TCKind._tk_wstring:
	return (_any.extract_wstring().compareTo(stringV) == 0);
	
      case TCKind._tk_sequence:

	_is1 = new com.ericsson.otp.erlang.OtpInputStream(os.toByteArray());

	_is2 = _any.extract_Streamable();

	if (_is1.peek() != _is2.peek()) {
	  
	  // _is1's sequence is compressed to string
	  if(_is1.peek() == com.ericsson.otp.erlang.OtpExternal.stringTag) {

	    _compressed = (_is1.read_string()).getBytes();
	    _is1Len = _compressed.length;
	    
	    _is2.read_list_head();
	    
	    for(int i = 0; i < _is1Len; i++) {
	      if ((long)(_compressed[i] & 0xff) != _is2.read_long())
		return false;
	    }
	    
	    _is2.read_nil();
	  }
	  else { // _is2's sequence is compressed to string

	    _compressed = (_is2.read_string()).getBytes();
	    _is2Len = _compressed.length;

	    _is1.read_list_head();

	    for(int i = 0; i < _is2Len; i++) 
	      if ((long)(_compressed[i] & 0xff) != _is1.read_long())
		return false;

	    _is1.read_nil();
	  }
	}
	else { // None of them is compressed
	  
	  _is2Len = _is2.available();

	  if (_is1.available() !=  _is2Len)
	    return false;
	    
	  for(int i = 0; i < _is2Len; i++) {
	    if (_is1.read() != _is2.read())
	      return false;
	  }
	}

	return true;

      case TCKind._tk_struct:      
      case TCKind._tk_union:
      case TCKind._tk_array:
      case TCKind._tk_enum:
	
	_is1 = new com.ericsson.otp.erlang.OtpInputStream(os.toByteArray());

	_is2 = _any.extract_Streamable();

	_is2Len = _is2.available();

	if (_is1.available() !=  _is2Len)
	  return false;

	for(int i = 0; i < _is2Len; i++) {
	  if (_is1.read() != _is2.read())
	    return false;
	}

	return true;
	
	// Not used in real
      case TCKind._tk_any:
      case TCKind._tk_void:
      case TCKind._tk_atom:
      case TCKind._tk_null:
      case TCKind._tk_TypeCode:
      case TCKind._tk_Principal:
      case TCKind._tk_objref:
      case TCKind._tk_alias:
      case TCKind._tk_except:
      case TCKind._tk_longdouble:
      case TCKind._tk_fixed:
	return true;
	
    default :
      return false;
      
      }
    } catch (Exception e) {
      //e.printStackTrace();
      return false;
    }
    
  }

  
  /* Equal function for floats ( relative diff ) */
  boolean equal(float x, float y) {
    
    if (x != 0)
      return (java.lang.Math.abs((x-y)/x) < 1.0E-15);

    if (y != 0)
      return (java.lang.Math.abs((y-x)/y) < 1.0E-15);

    return (x==y);
  }

  /* Equal function for doubles ( relative diff ) */
  boolean equal(double x, double y) {
        
    if (x != 0)
      return (java.lang.Math.abs((x-y)/x) < 1.0E-15);

    if (y != 0)
      return (java.lang.Math.abs((y-x)/y) < 1.0E-15);

    return (x==y);
  }



  /**
    TypeCode accessor method
    @return the Any's TypeCode 
    **/
  public TypeCode type() {
    return tcV;
  }
  
  
  /**
    TypeCode insertion method  
    **/
  public void type(TypeCode _tc) {
    tcV = _tc;
  }


  /* Value accessors */

  /**
    Reads a value from the stream, according to the inserted TypeCode 
    **/
  public void read_value(com.ericsson.otp.erlang.OtpInputStream _is,
			 TypeCode _tc) 
    throws java.lang.Exception {

      tcV = _tc;
       
      switch(tcV.kind().value()) {
	
      case TCKind._tk_short :
	shortV = _is.read_short();
	break;
      case TCKind._tk_ushort : 
	shortV = _is.read_ushort();
	break;
      case TCKind._tk_long : 
	intV = _is.read_int();
	break;
      case TCKind._tk_ulong : 
	intV = _is.read_uint();
	break;
      case TCKind._tk_longlong : 
	longV = _is.read_long();
	break;
      case TCKind._tk_ulonglong : 
	longV = _is.read_ulong();
	break;
      case TCKind._tk_float : 
	floatV = _is.read_float();
	break;
      case TCKind._tk_double : 
	doubleV = _is.read_double();
	break;
      case TCKind._tk_boolean : 
	booleanV = _is.read_boolean();
	break;
      case TCKind._tk_char : 
      case TCKind._tk_wchar : 
	charV = _is.read_char();
	break;
      case TCKind._tk_octet : 
	byteV = _is.read_byte();
	break;
      case TCKind._tk_string : 
      case TCKind._tk_wstring : 
	stringV = _is.read_string();
	break;
      case TCKind._tk_atom : 
	stringV = _is.read_atom();
	break;
      case TCKind._tk_void :
	_is.read_atom();
	break;

	 /*
	  * Not supported types
	  */
      case TCKind._tk_any :
      case TCKind._tk_null : 
      case TCKind._tk_TypeCode : 
      case TCKind._tk_Principal : 
      case TCKind._tk_objref : 
      case TCKind._tk_alias : 
      case TCKind._tk_except :  
      case TCKind._tk_longdouble :  
      case TCKind._tk_fixed :
	throw new java.lang.Exception("Unsupported type");
	
      default: // User defined type

	if (os == null)
	  os = new com.ericsson.otp.erlang.OtpOutputStream();
	else
	  os.reset();

	try {
	  read_user_defined(_is, _tc);
	  is = new com.ericsson.otp.erlang.OtpInputStream(os.toByteArray());
	} catch (Exception e) {
	  throw new java.lang.Exception("BAD VALUE");
	}
      }

  }

  void read_user_defined(com.ericsson.otp.erlang.OtpInputStream _is, TypeCode _tc) 
    throws java.lang.Exception {
      
      TypeCode memberTC = null;
      int len = -1;
      int __tag;
      
      switch(_tc.kind().value()) {

      case TCKind._tk_short :
	os.write_short(_is.read_short());
	break;
      case TCKind._tk_ushort : 
	os.write_ushort(_is.read_ushort());
	break;
      case TCKind._tk_long :
	os.write_int(_is.read_int());
	break;
      case TCKind._tk_longlong :
	os.write_long(_is.read_long());
	break;
      case TCKind._tk_ulong :
	os.write_uint(_is.read_uint());
	break;
      case TCKind._tk_ulonglong :
	os.write_ulong(_is.read_ulong());
	break;
      case TCKind._tk_float :
	os.write_float(_is.read_float());
	break;
      case TCKind._tk_double :
	os.write_double(_is.read_double());
	break;
      case TCKind._tk_boolean : 
	os.write_boolean(_is.read_boolean());
	break;
      case TCKind._tk_char : 
      case TCKind._tk_wchar : 
	os.write_char(_is.read_char());
	break;
      case TCKind._tk_octet :
	os.write_byte(_is.read_byte());
	break;
      case TCKind._tk_string :
      case TCKind._tk_wstring :
	os.write_string(_is.read_string());
	break;
      
      case TCKind._tk_struct:	
	len = _is.read_tuple_head();
	os.write_tuple_head(len);
	os.write_atom(_is.read_atom());
	// Member list
	len -=1;
	for(int i=0; i<len; i++) 
	  read_user_defined(_is,_tc.member_type(i));
	break;

      case TCKind._tk_union:
	os.write_tuple_head(_is.read_tuple_head());
	os.write_atom(_is.read_atom());

	int __mlen = _tc.member_count();
	__tag = _is.peek();
	boolean __found = false;

	switch (__tag) {
	case (com.ericsson.otp.erlang.OtpExternal.atomTag):
	  java.lang.String __elabel = _is.read_atom(); // Enumerant or Boolean
	  os.write_atom(__elabel);

	  for (int i=0; i<__mlen; i++) {
	    java.lang.String __mlabel;
	    if (_tc.member_label(i).type().kind().value() == TCKind._tk_string)
	      __mlabel = _tc.member_label(i).extract_string();
	    else   // Default 
	      __mlabel = _tc.member_label(i).extract_atom();
	    
	    if (__elabel.compareTo(__mlabel)==0) {
	      read_user_defined(_is,_tc.member_type(i));
	      i = __mlen;
	      __found = true;
	    }
	  }
	  break;

	default: // Integer type
	  long __ilabel = _is.read_long();
	  os.write_long(__ilabel);

	  for (int i=0; i<__mlen; i++) {
	    boolean __itype = true;
	    long __mlabel = 0;

	    switch (_tc.member_label(i).type().kind().value()) {

	    case TCKind._tk_short :
	      __mlabel = _tc.member_label(i).extract_short();
	      break;
	    case TCKind._tk_ushort :
	      __mlabel = _tc.member_label(i).extract_ushort();
	      break;
	    case TCKind._tk_long :
	      __mlabel = _tc.member_label(i).extract_long();
	      break;
	    case TCKind._tk_longlong :
	      __mlabel = _tc.member_label(i).extract_longlong();
	      break;
	    case TCKind._tk_ulong :
	      __mlabel = _tc.member_label(i).extract_ulong();
	      break;
	    case TCKind._tk_ulonglong :
	      __mlabel = _tc.member_label(i).extract_ulonglong();
	      break;
	    case TCKind._tk_char :
	      __mlabel = _tc.member_label(i).extract_char();
	      break;
	    case TCKind._tk_wchar :
	      __mlabel = _tc.member_label(i).extract_wchar();
	      break;
	      
	    default :  // Default label
	      __itype = false;
	      
	    }
	    
	    if (__itype) {
	      if (__ilabel == __mlabel) {
		read_user_defined(_is,_tc.member_type(i));
		i = __mlen;
		__found = true;
	      }
	    }
	  } 
	}

	// Use the default label instead
	if (!__found)
	  read_user_defined(_is,_tc.member_type(_tc.default_index()));
	
	break;
	
      case TCKind._tk_sequence:
	__tag = _is.peek();

	switch(__tag) {
	case com.ericsson.otp.erlang.OtpExternal.stringTag:
	  os.write_string(_is.read_string());
	  break;
	default:
	  len = _is.read_list_head();
	  os.write_list_head(len);

	  for (int i=0; i<len; i++)
	    read_user_defined(_is,_tc.content_type());

	  _is.read_nil();
	  os.write_nil();
	}
	break;

      case TCKind._tk_array: