diff options
| author | Erlang/OTP <[email protected]> | 2009-11-20 14:54:40 +0000 |
|---|---|---|
| committer | Erlang/OTP <[email protected]> | 2009-11-20 14:54:40 +0000 |
| commit | 84adefa331c4159d432d22840663c38f155cd4c1 (patch) | |
| tree | bff9a9c66adda4df2106dfd0e5c053ab182a12bd /lib/ic/java_src/com/ericsson | |
| download | otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2 otp-84adefa331c4159d432d22840663c38f155cd4c1.zip | |
The R13B03 release.OTP_R13B03
Diffstat (limited to 'lib/ic/java_src/com/ericsson')
30 files changed, 5474 insertions, 0 deletions
diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Any.java b/lib/ic/java_src/com/ericsson/otp/ic/Any.java new file mode 100644 index 0000000000..7337241908 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Any.java @@ -0,0 +1,1023 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +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: + len = _is.read_tuple_head(); + os.write_tuple_head(len); + for (int i=0; i<len; i++) + read_user_defined(_is,_tc.content_type()); + break; + + case TCKind._tk_enum: + os.write_atom(_is.read_atom()); + break; + + case TCKind._tk_void : + os.write_atom(_is.read_atom()); + break; + + case TCKind._tk_any : + AnyHelper.marshal(os,AnyHelper.unmarshal(_is)); + break; + + /* + * Not supported types + */ + default : + throw new java.lang.Exception(""); + + } + + } + + + /** + Writes the Any's value to the ouput stream + **/ + public void write_value(com.ericsson.otp.erlang.OtpOutputStream _os) + throws java.lang.Exception { + + switch(tcV.kind().value()) { + + case TCKind._tk_short : + _os.write_short(shortV); + break; + case TCKind._tk_ushort : + _os.write_ushort(shortV); + break; + case TCKind._tk_long : + _os.write_int(intV); + break; + case TCKind._tk_ulong : + _os.write_uint(intV); + break; + case TCKind._tk_longlong : + _os.write_long(longV); + break; + case TCKind._tk_ulonglong : + _os.write_ulong(longV); + break; + case TCKind._tk_float : + _os.write_float(floatV); + break; + case TCKind._tk_double : + _os.write_double(doubleV); + break; + case TCKind._tk_boolean : + _os.write_boolean(booleanV); + break; + case TCKind._tk_char : + case TCKind._tk_wchar : + _os.write_char(charV); + break; + case TCKind._tk_octet : + _os.write_byte(byteV); + break; + case TCKind._tk_string : + case TCKind._tk_wstring : + _os.write_string(stringV); + break; + case TCKind._tk_atom : + _os.write_atom(stringV); + break; + case TCKind._tk_void : + _os.write_atom("ok"); + 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("BAD KIND"); + + default: + _os.write(os.toByteArray()); + } + } + + + /* + * Insert and extract each primitive type + */ + + /* short */ + + /** + Short value extractor method + @return short, the value of Any + **/ + public short extract_short() + throws java.lang.Exception { + if (tcV.kind() == TCKind.tk_short) + return shortV; + + throw new java.lang.Exception(""); + } + + /** + Short value insertion method + **/ + public void insert_short(short s) { + shortV = s; + tcV = new TypeCode(TCKind.tk_short); + }; + + + /* long */ + /** + Long value extractor method + @return int, the value of Any + **/ + public int extract_long() + throws java.lang.Exception { + if (tcV.kind() == TCKind.tk_long) + return intV; + + throw new java.lang.Exception(""); + } + + /** + Long value insertion method + **/ + public void insert_long(int i){ + intV = i; + tcV = new TypeCode(TCKind.tk_long); + } + + + + /* long long */ + /** + Long Long value extractor method + @return long, the value of Any + **/ + public long extract_longlong() + throws java.lang.Exception { + if (tcV.kind() == TCKind.tk_longlong) + return longV; + + throw new java.lang.Exception(""); + } + + /** + Long Long value insertion method + **/ + public void insert_longlong(long l){ + longV = l; + tcV = new TypeCode(TCKind.tk_longlong); + } + + + /* ushort */ + /** + Unsigned Short value extractor method + @return short, the value of Any + **/ + public short extract_ushort() + throws java.lang.Exception { + if (tcV.kind() == TCKind.tk_ushort) + return shortV; + + throw new java.lang.Exception(""); + } + + /** + Unsigned Short value insertion method + **/ + public void insert_ushort(short s){ + shortV = s; + tcV = new TypeCode(TCKind.tk_ushort); + } + + + /* ulong */ + + /** + Unsigned Long value extractor method + @return int, the value of Any + **/ + public int extract_ulong() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_ulong) + return intV; + + throw new java.lang.Exception(""); + } + + /** + Unsigned Long value insertion method + **/ + public void insert_ulong(int i){ + intV = i; + tcV = new TypeCode(TCKind.tk_ulong); + } + + + + + /* unsigned long long */ + /** + Unsigned Long Long value extractor method + @return long, the value of Any + **/ + public long extract_ulonglong() + throws java.lang.Exception { + if (tcV.kind() == TCKind.tk_ulonglong) + return longV; + + throw new java.lang.Exception(""); + } + + /** + Unsigned Long Long value insertion method + **/ + public void insert_ulonglong(long l){ + longV = l; + tcV = new TypeCode(TCKind.tk_ulonglong); + } + + + /* float */ + /** + Float value extractor method + @return float, the value of Any + **/ + public float extract_float() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_float) + return floatV; + + throw new java.lang.Exception(""); + } + + /** + Float value insertion method + **/ + public void insert_float(float f){ + floatV = f; + tcV = new TypeCode(TCKind.tk_float); + } + + + /* double */ + /** + Double value extractor method + @return double, the value of Any + **/ + public double extract_double() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_double) + return doubleV; + + throw new java.lang.Exception(""); + } + + /** + Double value insertion method + **/ + public void insert_double(double d){ + doubleV = d; + tcV = new TypeCode(TCKind.tk_double); + } + + + /* boolean */ + /** + Boolean value extractor method + @return boolean, the value of Any + **/ + public boolean extract_boolean() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_boolean) + return booleanV; + + throw new java.lang.Exception(""); + } + + /** + Boolean value insertion method + **/ + public void insert_boolean(boolean b){ + booleanV = b; + tcV = new TypeCode(TCKind.tk_boolean); + } + + + + /* char */ + /** + Char value extractor method + @return char, the value of Any + **/ + public char extract_char() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_char) + return charV; + + throw new java.lang.Exception(""); + } + + /** + Char value insertion method + **/ + public void insert_char(char c) { + charV = c; + tcV = new TypeCode(TCKind.tk_char); + } + + + /* wchar */ + /** + Wchar value extractor method + @return char, the value of Any + **/ + public char extract_wchar() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_wchar) + return charV; + + throw new java.lang.Exception(""); + } + + /** + Wchar value insertion method + **/ + public void insert_wchar(char c) { + charV = c; + tcV = new TypeCode(TCKind.tk_wchar); + } + + + + /* octet */ + /** + Octet value extractor method + @return byte, the value of Any + **/ + public byte extract_octet() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_octet) + return byteV; + + throw new java.lang.Exception(""); + } + + /** + Octet value insertion method + **/ + public void insert_octet(byte b){ + byteV = b; + tcV = new TypeCode(TCKind.tk_octet); + } + + + /* string */ + /** + String value extractor method + @return String, the value of Any + **/ + public java.lang.String extract_string() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_string) + return stringV; + + throw new java.lang.Exception(""); + } + + /** + String value insertion method + **/ + public void insert_string(java.lang.String s) { + stringV = s; + tcV = new TypeCode(TCKind.tk_string); + } + + + + /* wstring */ + /** + Wstring value extractor method + @return String, the value of Any + **/ + public java.lang.String extract_wstring() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_wstring) + return stringV; + + throw new java.lang.Exception(""); + } + + /** + Wstring value insertion method + **/ + public void insert_wstring(java.lang.String s) { + stringV = s; + tcV = new TypeCode(TCKind.tk_wstring); + } + + + + /* atom */ + /** + Atom value extractor method + @return atom, the value of Any + **/ + public java.lang.String extract_atom() + throws java.lang.Exception{ + if (tcV.kind() == TCKind.tk_atom) + return stringV; + + throw new java.lang.Exception(""); + } + + /** + Atom value insertion method + **/ + public void insert_atom(java.lang.String s) { + stringV = s; + tcV = new TypeCode(TCKind.tk_atom); + } + + + /** + Object Stream insertion method + **/ + public void insert_Streamable(com.ericsson.otp.erlang.OtpOutputStream _os) { + os = _os; + } + + /** + Object Stream extractor method + @return OtpInputStream, the stream value of Any + **/ + public com.ericsson.otp.erlang.OtpInputStream extract_Streamable() { + + if (is == null) { + if (os == null) + return null; + else { + is = new com.ericsson.otp.erlang.OtpInputStream(os.toByteArray()); + } + } + + is.reset(); + return is; + } + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/AnyHelper.java b/lib/ic/java_src/com/ericsson/otp/ic/AnyHelper.java new file mode 100644 index 0000000000..d80d299db8 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/AnyHelper.java @@ -0,0 +1,78 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + +Helper class for Any, according to OMG-IDL java mapping. +<p>Instead for write,read methods, the methods marshal respective +unmarshal are used to denote the implementation difference. + +**/ + + +public class AnyHelper { + + // Constructors + private AnyHelper() {} + + // Methods + /** + Marshal method for the Any class, encodes the Any object to the output stream. + **/ + public static void marshal(com.ericsson.otp.erlang.OtpOutputStream _out, Any _any) + throws java.lang.Exception { + + TypeCode _tc = _any.type(); + + _out.write_tuple_head(3); + _out.write_atom("any"); + + TypeCode.marshal(_out, _tc); + _any.write_value(_out); + + } + + /** + Unmarshal method for the Any class, decodes an Any object from the stream. + @return Any, read from the input stream + **/ + public static Any unmarshal(com.ericsson.otp.erlang.OtpInputStream _in) + throws java.lang.Exception { + + Any _value; + TypeCode _tc; + + _in.read_tuple_head(); + + if ((_in.read_atom()).compareTo("any") != 0) + throw new java.lang.Exception(""); + + _tc = TypeCode.unmarshal(_in); + _value = new Any(); + _value.read_value(_in,_tc); + + return _value; + } + +} + + + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/AnyHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/AnyHolder.java new file mode 100644 index 0000000000..fa28bd0e5d --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/AnyHolder.java @@ -0,0 +1,60 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Any, according to OMG-IDL java mapping. +<p>Instead for _write,_read methods, the methods _marshal respective +_unmarshal are used to denote the implementation difference. + +**/ + +final public class AnyHolder { + + // Instance variables + public Any value; + + // Constructors + public AnyHolder() {} + + public AnyHolder(Any initial) { + value = initial; + } + + // Methods + /** + Marshal method for the Any class, encodes the Any object to the output stream. + **/ + public void _marshal(com.ericsson.otp.erlang.OtpOutputStream out) + throws java.lang.Exception { + AnyHelper.marshal(out, value); + } + + /** + Unmarshal method for the Any class, decodes an Any object from the stream and + assigns it to the Holder value. + **/ + public void _unmarshal(com.ericsson.otp.erlang.OtpInputStream in) + throws java.lang.Exception { + value = AnyHelper.unmarshal(in); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/BooleanHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/BooleanHolder.java new file mode 100644 index 0000000000..5e91ae81af --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/BooleanHolder.java @@ -0,0 +1,62 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for boolean + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Boolean, according to OMG-IDL java mapping. + +**/ + + +final public class BooleanHolder implements Holder { + public boolean value; + + public BooleanHolder() {} + + public BooleanHolder(boolean initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Booleans. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Boolean ) + return ( value == ((Boolean)obj).booleanValue()); + else + return false; + } + + /** + Comparisson method for Booleans. + @return true if the input boolean value equals the value of the current object, false otherwize + **/ + public boolean equals( boolean b ) { + return ( value == b ); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/ByteHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/ByteHolder.java new file mode 100644 index 0000000000..cd70573ab4 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/ByteHolder.java @@ -0,0 +1,61 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for byte + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Byte, according to OMG-IDL java mapping. + +**/ + +final public class ByteHolder implements Holder { + public byte value; + + public ByteHolder() {} + + public ByteHolder(byte initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Bytes. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Byte ) + return ( value == ((Byte)obj).byteValue()); + else + return false; + } + + /** + Comparisson method for Byte. + @return true if the input boolean value equals the value of the current object, false otherwize + **/ + public boolean equals( byte b ) { + return ( value == b); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/CharHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/CharHolder.java new file mode 100644 index 0000000000..6005269a38 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/CharHolder.java @@ -0,0 +1,63 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for char + * + */ +package com.ericsson.otp.ic; + + +/** + +Holder class for Char, according to OMG-IDL java mapping. + +**/ + + +final public class CharHolder implements Holder { + public char value; + + public CharHolder() {} + + public CharHolder(char initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Chars. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Character ) + return ( value == ((Character)obj).charValue()); + else + return false; + } + + /** + Comparisson method for Chars. + @return true if the input char value equals the value of the current object, false otherwize + **/ + public boolean equals( char c ) { + return ( value == c); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/DoubleHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/DoubleHolder.java new file mode 100644 index 0000000000..d0da72cc2c --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/DoubleHolder.java @@ -0,0 +1,61 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for double + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Double, according to OMG-IDL java mapping. + +**/ + +final public class DoubleHolder implements Holder { + public double value; + + public DoubleHolder() {} + + public DoubleHolder(double initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Doubles. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Double ) + return ( value == ((Double)obj).doubleValue()); + else + return false; + } + + /** + Comparisson method for Doubles. + @return true if the input double value equals the value of the current object, false otherwize + **/ + public boolean equals( double d ) { + return ( value == d); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Environment.java b/lib/ic/java_src/com/ericsson/otp/ic/Environment.java new file mode 100644 index 0000000000..f0c66f0726 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Environment.java @@ -0,0 +1,475 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * The Environment class for Java IDL + * + */ +package com.ericsson.otp.ic; + +/** + + The Environment class handles communication + setup and stub state. The methods of this class + are specially designed for the generated stubs. + This class must be used when designing asynchronous + message passing. + + **/ + + +public class Environment { + + // Private variables + private com.ericsson.otp.erlang.OtpSelf self; + private com.ericsson.otp.erlang.OtpPeer peer; + private java.lang.Object server; + private java.lang.String cookie; + private com.ericsson.otp.erlang.OtpConnection connection; + private com.ericsson.otp.erlang.OtpErlangRef send_ref; /* Client side send reference */ + private com.ericsson.otp.erlang.OtpErlangRef receive_ref; /* Client side received reference */ + private com.ericsson.otp.erlang.OtpErlangPid clientP; + private com.ericsson.otp.erlang.OtpErlangPid serverP; + private com.ericsson.otp.erlang.OtpOutputStream os; /* Output stream */ + private com.ericsson.otp.erlang.OtpInputStream is; /* Input stream */ + private boolean stopped; + + // Private variables used by server only + private int tag; + private java.lang.String operation; + private java.lang.String type; + private com.ericsson.otp.erlang.OtpErlangRef ref; /* Server side client reference */ + private com.ericsson.otp.erlang.OtpErlangPid caller; /* Server side client pid */ + + // Tags to distiguish client / server environments + private boolean clientT; + private boolean serverT; + + + /** + Client stub side constructor. + **/ + public Environment(com.ericsson.otp.erlang.OtpSelf _Self, + com.ericsson.otp.erlang.OtpPeer _Peer, + java.lang.Object _Server) throws java.lang.Exception { + + init(); + clientT = true; + self = _Self; + peer = _Peer; + server = _Server; + os = new com.ericsson.otp.erlang.OtpOutputStream(); + } + + + /** + Client stub side constructor. + **/ + public Environment(java.lang.String _SelfNode, + java.lang.String _PeerNode, + java.lang.String _Cookie, + java.lang.Object _Server) throws java.lang.Exception { + + init(); + clientT = true; + self = new com.ericsson.otp.erlang.OtpSelf(_SelfNode, _Cookie); + peer = new com.ericsson.otp.erlang.OtpPeer(_PeerNode); + cookie = _Cookie; + server = _Server; + os = new com.ericsson.otp.erlang.OtpOutputStream(); + } + + + /** + Client stub side constructor. + **/ + public Environment(com.ericsson.otp.erlang.OtpConnection _connection, + java.lang.Object _Server) throws java.lang.Exception { + + init(); + clientT = true; + self = _connection.self(); + peer = _connection.peer(); + connection = _connection; + server = _Server; + os = new com.ericsson.otp.erlang.OtpOutputStream(); + } + + + /** + Server skeleton side constructor. + **/ + public Environment() throws java.lang.Exception { + + init(); + serverT = true; + stopped = false; + os = new com.ericsson.otp.erlang.OtpOutputStream(); + + } + + + /* Communication toolbox */ + + /** + Client stub side connector. + **/ + public void connect() throws java.lang.Exception { + + if (connection == null) + connection = self.connect(peer); + + clientP = new com.ericsson.otp.erlang.OtpErlangPid(self); /* This is not perfect */ + send_ref = new com.ericsson.otp.erlang.OtpErlangRef(self); + + } + + /** + Reconnects a client by closing existing connection + and connecting. + **/ + public void reconnect() throws java.lang.Exception { + + if (connection.isConnected()) + connection.close(); + + connection = self.connect(peer); + + } + + /** + Closes the established connection. + **/ + public void disconnect() { + + connection.close(); + + } + + + /** + Client side message sender. + **/ + public void send() throws java.lang.Exception { + + if (server instanceof java.lang.String) + connection.sendBuf((java.lang.String)server, os); + else + connection.sendBuf((com.ericsson.otp.erlang.OtpErlangPid)server, os); + + } + + + /** + Client message receiver. + **/ + public void receive() throws java.lang.Exception { + + is = connection.receiveBuf(); + + if (clientT) { // If client, decode message reference too + is.read_tuple_head(); + receive_ref = is.read_ref(); + } + } + + + /** + Universal message receiver. + **/ + public void receive(com.ericsson.otp.erlang.OtpConnection _connection) throws java.lang.Exception { + + is = _connection.receiveBuf(); + + if (clientT) { // If client, decode message reference too + is.read_tuple_head(); + receive_ref = is.read_ref(); + } + } + + + /* Accessors */ + + /** + Server RegName/OtpErlangPid accessor. + Used to access the server Reg/Pid, which + initiated the connection. + @return java.lang.Object, the server for the active OtpConnection. + **/ + public java.lang.Object server() { + + return server; + + } + + /** + Caller identity accessor. Used by a server stub to access the + caller identity of the received message. + @return OtpErlangPid, the caller identity. + **/ + public com.ericsson.otp.erlang.OtpErlangPid caller_pid() { + + return clientP; + + } + + + /** + Received message reference accessor. Used by a server stub to access the + reference of the received message. + @return OtpErlangRef, the reference of the received message. + **/ + public com.ericsson.otp.erlang.OtpErlangRef received_ref() { + + return receive_ref; + + } + + + /* Encoders */ + + /** + Client Pid Encoder. Used by a server stub to encode the + enclosed client process identity. + **/ + public void write_client_pid() { + + os.write_pid(clientP.node(),clientP.id(),clientP.serial(),clientP.creation()); + + } + + /** + Client Ref Encoder. Used by a server stub to encode the + enclosed client message reference. + **/ + public void write_client_ref() { + + os.write_ref(send_ref.node(),send_ref.id(),send_ref.creation()); + + } + + + + /* Field access functions */ + + /** + Output Stream accessor. + @return OtpOutputStream, the enclosed output stream. + **/ + public com.ericsson.otp.erlang.OtpOutputStream getOs() { + return os; + } + + /** + Input Stream accessor. + @return OtpInputStream, the enclosed input stream. + **/ + public com.ericsson.otp.erlang.OtpInputStream getIs() { + return is; + } + + /** + Server skeleton side client (caller) pid accessor. + @return OtpErlangPid, the caller process identity. + **/ + public com.ericsson.otp.erlang.OtpErlangPid getScaller() { + return caller; + } + + /** + Server skeleton side client call reference accessor. + @return OtpErlangRef, the latest call message reference. + **/ + public com.ericsson.otp.erlang.OtpErlangRef getSref() { + return ref; + } + + + + /* Field modifiers */ + + + + /* Decoders */ + + /** + Decodes the message head from existing stream. + Assignes message data to private variables of the Environment Object. + **/ + public void uHead() throws java.lang.Exception { + uHead(is); + } + + /** + Decodes the message head and writes over input stream. + Assignes message data to private variables of the Environment Object. + **/ + public void uHead(com.ericsson.otp.erlang.OtpInputStream _is) throws java.lang.Exception { + + is = _is; + is.read_tuple_head(); + type = is.read_atom(); + + if (type.equals("$gen_call")) { // Call type operation + is.read_tuple_head(); + caller = is.read_pid(); + ref = is.read_ref(); + tag = is.peek(); + + switch (tag) { + case com.ericsson.otp.erlang.OtpExternal.atomTag: + operation = is.read_atom(); + break; + default: + is.read_tuple_head(); + operation = is.read_atom(); + } + } else { // Cast type operation + tag = is.peek(); + switch (tag) { + case com.ericsson.otp.erlang.OtpExternal.atomTag: + operation = is.read_atom(); + break; + default: + is.read_tuple_head(); + operation = is.read_atom(); + } + } + } + + /** + Operation label accessor. + @return int, the label hash value. + **/ + public int uLabel(java.util.Dictionary _operations) { + + java.lang.Integer __label = + (java.lang.Integer) _operations.get(operation); + + if(__label == null) + return -1; + + return __label.intValue(); + } + + + + /* Controllers */ + + /** + Operation controller. + @return boolean, true if the operation variable found in Environment class + is supported in the input operation dictionary, false otherwize. + **/ + public boolean validOp(java.util.Dictionary _operations) { + + if((_operations.get(operation)) == null) + return false; + + return true; + } + + + /** + Server stop request controller. + @return boolean, true if there is a client request for the server + to be stopped, false otherwize. + **/ + public boolean isStopped() { + return stopped; + }; + + + + /* Destroy functions */ + + /* + Creates and sends a stop message. + Called by client stub to terminate the server. + */ + public void client_stop_server() + throws java.lang.Exception { + + // Message header assembly + os.reset(); + os.write_tuple_head(2); + os.write_atom("$gen_cast"); + + os.write_atom("stop"); + + send(); + + } + + /* + Sets the stop flag for the server. + Called by server skeleton when stop message is received. + */ + public void server_stop_server() { + + // Note at server is dead ! + stopped = true; + } + + + /* Private methods */ + + /** + Private variable initialization. + **/ + public void init() { + + clientT = false; + serverT = false; + stopped = false; + self = null; + peer = null; + server = null; + cookie = null; + connection = null; + clientP = null; + serverP = null; + send_ref = null; + receive_ref = null; + os = null; + is = null; + + tag = -1; + operation = null; + type = null; + + }; + +} + + + + + + + + + + + + + + + + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/FloatHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/FloatHolder.java new file mode 100644 index 0000000000..4904fd5fc1 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/FloatHolder.java @@ -0,0 +1,62 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for float + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Float, according to OMG-IDL java mapping. + +**/ + + +final public class FloatHolder implements Holder { + public float value; + + public FloatHolder() {} + + public FloatHolder(float initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Floats. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Float ) + return ( value == ((Float)obj).floatValue()); + else + return false; + } + + /** + Comparisson method for Floats. + @return true if the input float value equals the value of the current object, false otherwize + **/ + public boolean equals( float f ) { + return ( value == f); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Holder.java b/lib/ic/java_src/com/ericsson/otp/ic/Holder.java new file mode 100644 index 0000000000..a00efcef68 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Holder.java @@ -0,0 +1,33 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * Holder interface class. +*/ +package com.ericsson.otp.ic; +import java.io.Serializable; + +/** + Holder interface class. + **/ + +public interface Holder extends Serializable +{ + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/IntHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/IntHolder.java new file mode 100644 index 0000000000..1037af4f08 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/IntHolder.java @@ -0,0 +1,62 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for long + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Int, according to OMG-IDL java mapping. + +**/ + +final public class IntHolder implements Holder { + public int value; + + public IntHolder() {} + + public IntHolder(int initial) { + value = initial; + } + + /* Extra methods not in standard. */ + + /** + Comparisson method for Ints. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Integer ) + return ( value == ((Integer)obj).intValue()); + else + return false; + } + + /** + Comparisson method for Ints. + @return true if the input int value equals the value of the current object, false otherwize + **/ + public boolean equals( int i ) { + return ( value == i); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/LongHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/LongHolder.java new file mode 100644 index 0000000000..8fa4430018 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/LongHolder.java @@ -0,0 +1,60 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for long + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Long, used by the Term class. + +**/ + +final public class LongHolder implements Holder { + public long value; + + public LongHolder() {} + + public LongHolder(long initial) { + value = initial; + } + + /** + Comparisson method for Longs. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Long ) + return ( value == ((Long)obj).longValue()); + else + return false; + } + + /** + Comparisson method for Longs. + @return true if the input long value equals the value of the current object, false otherwize + **/ + public boolean equals( long l ) { + return ( value == l); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Makefile b/lib/ic/java_src/com/ericsson/otp/ic/Makefile new file mode 100644 index 0000000000..f730749ccb --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Makefile @@ -0,0 +1,118 @@ +# +# %CopyrightBegin% +# +# Copyright Ericsson AB 1999-2009. All Rights Reserved. +# +# 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 online 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. +# +# %CopyrightEnd% +# +# +include $(ERL_TOP)/make/target.mk + + +JAVA_DEST_ROOT = $(ERL_TOP)/lib/ic/priv/ +JAVA_SRC_ROOT = $(ERL_TOP)/lib/ic/java_src/ +JAVA_CLASS_SUBDIR = com/ericsson/otp/ic/ +JAVA_INCL_ROOT = $(ERL_TOP)/lib/jinterface/priv/ + +include $(ERL_TOP)/make/$(TARGET)/otp.mk + +# ---------------------------------------------------- +# Application version +# ---------------------------------------------------- +include $(ERL_TOP)/lib/ic/vsn.mk +VSN=$(IC_VSN) + +# ---------------------------------------------------- +# Release directory specification +# ---------------------------------------------------- +RELSYSDIR = $(RELEASE_PATH)/lib/ic-$(VSN) + +# +# JAVA macros +# +JAVA_CLASSES = \ + Holder \ + BooleanHolder \ + ByteHolder \ + CharHolder \ + DoubleHolder \ + FloatHolder \ + IntHolder \ + LongHolder \ + ShortHolder \ + StringHolder \ + Environment \ + Any \ + AnyHelper \ + AnyHolder \ + TypeCode \ + TCKind \ + Pid \ + PidHolder \ + PidHelper \ + Ref \ + RefHolder \ + RefHelper \ + Port \ + PortHolder \ + PortHelper \ + Term \ + TermHolder \ + TermHelper + +TARGET_FILES= $(JAVA_CLASSES:%=$(JAVA_DEST_ROOT)$(JAVA_CLASS_SUBDIR)%.class) +JAVA_FILES= $(JAVA_CLASSES:%=%.java) + +JARFILE= ic.jar + +# ---------------------------------------------------- +# Programs and Flags +# ---------------------------------------------------- +CLASSPATH = $(JAVA_SRC_ROOT):$(JAVA_INCL_ROOT) + +JAR= jar + +JAVADOCFLAGS=-d $(DOCDIR) +JAVAFLAGS=-d $(JAVA_DEST_ROOT) +JARFLAGS= -cvf + +JAVA_OPTIONS = + +# ---------------------------------------------------- +# Make Rules +# ---------------------------------------------------- + +debug opt: $(JAVA_DEST_ROOT)$(JARFILE) + +$(JAVA_DEST_ROOT)$(JARFILE): $(TARGET_FILES) + @(cd $(JAVA_DEST_ROOT) ; $(JAR) $(JARFLAGS) $(JARFILE) $(JAVA_CLASS_SUBDIR)) + +clean: + rm -f $(TARGET_FILES) *~ + +docs: + +# ---------------------------------------------------- +# Release Targets +# ---------------------------------------------------- +include $(ERL_TOP)/make/otp_release_targets.mk + +release_spec: opt + $(INSTALL_DIR) $(RELSYSDIR)/java_src/com/ericsson/otp/ic + $(INSTALL_DATA) $(JAVA_FILES) $(RELSYSDIR)/java_src/com/ericsson/otp/ic + $(INSTALL_DIR) $(RELSYSDIR)/priv + $(INSTALL_DATA) $(JAVA_DEST_ROOT)$(JARFILE) $(RELSYSDIR)/priv + +release_docs_spec: + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Pid.java b/lib/ic/java_src/com/ericsson/otp/ic/Pid.java new file mode 100644 index 0000000000..8d0608bf58 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Pid.java @@ -0,0 +1,55 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + + +/** + +Pid class mapps the built-in erlang type pid, a process identity. + +**/ + + +final public class Pid extends com.ericsson.otp.erlang.OtpErlangPid { + + public Pid(com.ericsson.otp.erlang.OtpSelf self) { + super(self); + } + + public Pid(com.ericsson.otp.erlang.OtpInputStream buf) + throws com.ericsson.otp.erlang.OtpErlangDecodeException { + super(buf); + } + + + public Pid(String node, int id, int serial, int creation) { + super(node,id,serial,creation); + } + + + /** + Comparisson method for Pid. + @return true if the input Pid value equals the value of the current object, false otherwize + **/ + public boolean equal(Pid _pid) { + return super.equals(_pid); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/PidHelper.java b/lib/ic/java_src/com/ericsson/otp/ic/PidHelper.java new file mode 100644 index 0000000000..a51ff2fe80 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/PidHelper.java @@ -0,0 +1,144 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Helper class for Pid. + **/ + +public class PidHelper { + + // constructors + private PidHelper() {} + + // methods + /** + Marshal method for the Pid class, encodes the Pid object to the output stream. + **/ + public static void marshal(com.ericsson.otp.erlang.OtpOutputStream _out, Pid _value) + throws java.lang.Exception { + + _out.write_pid(_value.node(),_value.id(),_value.serial(),_value.creation()); + } + + /** + Unmarshal method for the Pid class, decodes a Pid object from the stream. + @return Pid, read from the input stream + **/ + public static Pid unmarshal(com.ericsson.otp.erlang.OtpInputStream _in) + throws java.lang.Exception { + + // Double job is done here, there should be + // a function returning a Pid instead of an + // OtpErlangPid + com.ericsson.otp.erlang.OtpErlangPid oep = _in.read_pid(); + + return new Pid(oep.node(),oep.id(),oep.serial(),oep.creation()); + } + + /** + Standard method that returns the interface repository identity. + @return String containing the interface repository identity of Pid + **/ + public static String id() { + return "IDL:com/ericsson/otp/ic/Pid:1.0"; + } + + /** + Standard method that returns the Pid class name. + @return String containing the class name of Pid + **/ + public static String name() { + return "Pid"; + } + + /** + Holds the TypeCode + **/ + private static com.ericsson.otp.ic.TypeCode _tc; + + /** + Standard TypeCode accessor method. + @return the TypeCode for Pid + **/ + synchronized public static com.ericsson.otp.ic.TypeCode type() { + + if (_tc != null) + return _tc; + + com.ericsson.otp.ic.TypeCode _tc0 = + new com.ericsson.otp.ic.TypeCode(); + _tc0.kind(com.ericsson.otp.ic.TCKind.tk_struct); + _tc0.id("IDL:com/ericsson/otp/ic/Pid:1.0"); + _tc0.name("Pid"); + _tc0.member_count(4); + _tc0.member_name(0,"node"); + com.ericsson.otp.ic.TypeCode _tc1 = + new com.ericsson.otp.ic.TypeCode(); + _tc1.kind(com.ericsson.otp.ic.TCKind.tk_string); + _tc1.length(256); + _tc0.member_type(0,_tc1); + _tc0.member_name(1,"num"); + com.ericsson.otp.ic.TypeCode _tc2 = + new com.ericsson.otp.ic.TypeCode(); + _tc2.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(1,_tc2); + _tc0.member_name(2,"serial"); + com.ericsson.otp.ic.TypeCode _tc3 = + new com.ericsson.otp.ic.TypeCode(); + _tc3.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(2,_tc3); + _tc0.member_name(3,"creation"); + com.ericsson.otp.ic.TypeCode _tc4 = + new com.ericsson.otp.ic.TypeCode(); + _tc4.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(3,_tc4); + + _tc = _tc0; + + return _tc0; + } + + + /** + Standard method for inserting a Pid to an Any. + **/ + public static void insert(com.ericsson.otp.ic.Any _any, Pid _this) + throws java.lang.Exception { + + com.ericsson.otp.erlang.OtpOutputStream _os = + new com.ericsson.otp.erlang.OtpOutputStream(); + + _any.type(type()); + marshal(_os, _this); + _any.insert_Streamable(_os); + } + + /** + Standard method for extracting a Pid from an Any. + @return Pid, the value found in an Any contained stream. + **/ + public static Pid extract(com.ericsson.otp.ic.Any _any) + throws java.lang.Exception { + + return unmarshal(_any.extract_Streamable()); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/PidHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/PidHolder.java new file mode 100644 index 0000000000..9e42385dec --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/PidHolder.java @@ -0,0 +1,54 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Holder class for Pid. + **/ + +final public class PidHolder { + + /** + Pid instance variable. + **/ + public Pid value; + + // constructors + public PidHolder() {} + public PidHolder(Pid initial) { + value = initial; + } + + // methods + /** + Marshal method for the PidHolder class, encodes the Pid object value to the output stream. + **/ + public void _marshal(com.ericsson.otp.erlang.OtpOutputStream out) throws java.lang.Exception { + PidHelper.marshal(out, value); + } + + /** + Unmarshal method for the PidHolder class, decodes a Pid object from the output stream + and assigns it to the Holder value field. + **/ + public void _unmarshal(com.ericsson.otp.erlang.OtpInputStream in) throws java.lang.Exception { + value = PidHelper.unmarshal(in); + } +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Port.java b/lib/ic/java_src/com/ericsson/otp/ic/Port.java new file mode 100644 index 0000000000..e830365d5c --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Port.java @@ -0,0 +1,48 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + +Port class mapps the built-in erlang type port, a process port. + +**/ + +final public class Port extends com.ericsson.otp.erlang.OtpErlangPort { + + public Port(com.ericsson.otp.erlang.OtpInputStream buf) + throws com.ericsson.otp.erlang.OtpErlangDecodeException { + super(buf); + } + + public Port(String node, int id, int creation) { + super(node,id,creation); + } + + /** + Comparisson method for Port. + @return true if the input Port value equals the value of the current object, false otherwize + **/ + public boolean equal(Port _port) { + return super.equals(_port); + } + + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/PortHelper.java b/lib/ic/java_src/com/ericsson/otp/ic/PortHelper.java new file mode 100644 index 0000000000..26c79713e0 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/PortHelper.java @@ -0,0 +1,140 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Helper class for Port. + **/ + +public class PortHelper { + + // constructors + private PortHelper() {} + + // methods + + /** + Marshal method for the Port class, encodes the Port object to the output stream. + **/ + public static void marshal(com.ericsson.otp.erlang.OtpOutputStream _out, Port _value) + throws java.lang.Exception { + + _out.write_port(_value.node(),_value.id(),_value.creation()); + } + + /** + Unmarshal method for the Port class, decodes a Port object from the stream. + @return Port, read from the input stream + **/ + public static Port unmarshal(com.ericsson.otp.erlang.OtpInputStream _in) + throws java.lang.Exception { + + // Double job is done here, there should be + // a function returning a Port instead of an + // OtpErlangPort + com.ericsson.otp.erlang.OtpErlangPort oep = _in.read_port(); + + return new Port(oep.node(),oep.id(),oep.creation()); + } + + /** + Standard method that returns the interface repository identity. + @return String containing the interface repository identity of Port + **/ + public static String id() { + return "IDL:com/ericsson/otp/ic/Port:1.0"; + } + + /** + Standard method that returns the Port class name. + @return String containing the class name of Port + **/ + public static String name() { + return "Port"; + } + + /** + Holds the TypeCode + **/ + private static com.ericsson.otp.ic.TypeCode _tc; + + /** + Standard TypeCode accessor method. + @return the TypeCode for Port + **/ + synchronized public static com.ericsson.otp.ic.TypeCode type() { + + if (_tc != null) + return _tc; + + com.ericsson.otp.ic.TypeCode _tc0 = + new com.ericsson.otp.ic.TypeCode(); + _tc0.kind(com.ericsson.otp.ic.TCKind.tk_struct); + _tc0.id("IDL:com/ericsson/otp/ic/Port:1.0"); + _tc0.name("Port"); + _tc0.member_count(3); + _tc0.member_name(0,"node"); + com.ericsson.otp.ic.TypeCode _tc1 = + new com.ericsson.otp.ic.TypeCode(); + _tc1.kind(com.ericsson.otp.ic.TCKind.tk_string); + _tc1.length(256); + _tc0.member_type(0,_tc1); + _tc0.member_name(1,"id"); + com.ericsson.otp.ic.TypeCode _tc2 = + new com.ericsson.otp.ic.TypeCode(); + _tc2.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(1,_tc2); + _tc0.member_name(2,"creation"); + com.ericsson.otp.ic.TypeCode _tc3 = + new com.ericsson.otp.ic.TypeCode(); + _tc3.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(2,_tc3); + + _tc = _tc0; + + return _tc0; + } + + + /** + Standard method for inserting a Port to an Any. + **/ + public static void insert(com.ericsson.otp.ic.Any _any, Port _this) + throws java.lang.Exception { + + com.ericsson.otp.erlang.OtpOutputStream _os = + new com.ericsson.otp.erlang.OtpOutputStream(); + + _any.type(type()); + marshal(_os, _this); + _any.insert_Streamable(_os); + } + + /** + Standard method for extracting a Port from an Any. + @return Port, the value found in an Any contained stream. + **/ + public static Port extract(com.ericsson.otp.ic.Any _any) + throws java.lang.Exception { + + return unmarshal(_any.extract_Streamable()); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/PortHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/PortHolder.java new file mode 100644 index 0000000000..80744f223f --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/PortHolder.java @@ -0,0 +1,56 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Holder class for Port. + **/ + +final public class PortHolder { + + /** + Port instance variable. + **/ + public Port value; + + // constructors + public PortHolder() {} + public PortHolder(Port initial) { + value = initial; + } + + // methods + /** + Marshal method for the PortHolder class, encodes the Port object value to the output stream. + **/ + public void _marshal(com.ericsson.otp.erlang.OtpOutputStream out) + throws java.lang.Exception { + PortHelper.marshal(out, value); + } + + /** + Unmarshal method for the PortHolder class, decodes a Port object from the output stream + and assigns it to the Holder value field. + **/ + public void _unmarshal(com.ericsson.otp.erlang.OtpInputStream in) + throws java.lang.Exception { + value = PortHelper.unmarshal(in); + } +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Ref.java b/lib/ic/java_src/com/ericsson/otp/ic/Ref.java new file mode 100644 index 0000000000..0a3876989e --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Ref.java @@ -0,0 +1,60 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + +Ref class mapps the built-in erlang type Ref, a message reference. + +**/ + +final public class Ref extends com.ericsson.otp.erlang.OtpErlangRef { + + public Ref(com.ericsson.otp.erlang.OtpSelf self) { + super(self); + } + + + public Ref(com.ericsson.otp.erlang.OtpInputStream buf) + throws com.ericsson.otp.erlang.OtpErlangDecodeException { + super(buf); + } + + /** + Old style Ref costructor. Costructs an Ref that coresponds to the + old erlang Ref type. + **/ + public Ref(String node, int id, int creation) { + super(node,id,creation); + } + + public Ref(String node, int[] ids, int creation) { + super(node,ids,creation); + } + + /** + Comparisson method for Ref. + @return true if the input Ref value equals the value of the current object, false otherwize + **/ + public boolean equal(Ref _ref) { + return super.equals(_ref); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/RefHelper.java b/lib/ic/java_src/com/ericsson/otp/ic/RefHelper.java new file mode 100644 index 0000000000..a58dec7905 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/RefHelper.java @@ -0,0 +1,141 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Helper class for Ref. + **/ + +public class RefHelper { + + // constructors + private RefHelper() {} + + // methods + /** + Marshal method for the Ref class, encodes the Ref object to the output stream. + **/ + public static void marshal(com.ericsson.otp.erlang.OtpOutputStream _out, Ref _value) + throws java.lang.Exception { + + _out.write_ref(_value.node(),_value.id(),_value.creation()); + } + + /** + Unmarshal method for the Ref class, decodes a Ref object from the stream. + @return Ref, read from the input stream + **/ + public static Ref unmarshal(com.ericsson.otp.erlang.OtpInputStream _in) + throws java.lang.Exception { + + // Double job is done here, there should be + // a function returning a Ref instead of an + // OtpErlangRef + com.ericsson.otp.erlang.OtpErlangRef oer = _in.read_ref(); + + if (oer.isNewRef()) + return new Ref(oer.node(),oer.ids(),oer.creation()); + else + return new Ref(oer.node(),oer.id(),oer.creation()); + } + + /** + Standard method that returns the interface repository identity. + @return String containing the interface repository identity of Ref + **/ + public static String id() { + return "IDL:com/ericsson/otp/ic/Ref:1.0"; + } + + /** + Standard method that returns the Ref class name. + @return String containing the class name of Ref + **/ + public static String name() { + return "Ref"; + } + + /** + Holds the TypeCode + **/ + private static com.ericsson.otp.ic.TypeCode _tc; + + /** + Standard TypeCode accessor method. + @return the TypeCode for Ref + **/ + synchronized public static com.ericsson.otp.ic.TypeCode type() { + + if (_tc != null) + return _tc; + + com.ericsson.otp.ic.TypeCode _tc0 = + new com.ericsson.otp.ic.TypeCode(); + _tc0.kind(com.ericsson.otp.ic.TCKind.tk_struct); + _tc0.id("IDL:com/ericsson/otp/ic/Ref:1.0"); + _tc0.name("Ref"); + _tc0.member_count(3); + _tc0.member_name(0,"node"); + com.ericsson.otp.ic.TypeCode _tc1 = + new com.ericsson.otp.ic.TypeCode(); + _tc1.kind(com.ericsson.otp.ic.TCKind.tk_string); + _tc1.length(256); + _tc0.member_type(0,_tc1); + _tc0.member_name(1,"id"); + com.ericsson.otp.ic.TypeCode _tc2 = + new com.ericsson.otp.ic.TypeCode(); + _tc2.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(1,_tc2); + _tc0.member_name(2,"creation"); + com.ericsson.otp.ic.TypeCode _tc3 = + new com.ericsson.otp.ic.TypeCode(); + _tc3.kind(com.ericsson.otp.ic.TCKind.tk_ulong); + _tc0.member_type(2,_tc3); + + _tc = _tc0; + + return _tc0; + } + + /** + Standard method for inserting a Ref to an Any. + **/ + public static void insert(com.ericsson.otp.ic.Any _any, Ref _this) + throws java.lang.Exception { + + com.ericsson.otp.erlang.OtpOutputStream _os = + new com.ericsson.otp.erlang.OtpOutputStream(); + + _any.type(type()); + marshal(_os, _this); + _any.insert_Streamable(_os); + } + + /** + Standard method for extracting a Ref from an Any. + @return Ref, the value found in an Any contained stream. + **/ + public static Ref extract(com.ericsson.otp.ic.Any _any) + throws java.lang.Exception { + + return unmarshal(_any.extract_Streamable()); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/RefHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/RefHolder.java new file mode 100644 index 0000000000..2dc3f4b42a --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/RefHolder.java @@ -0,0 +1,54 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Holder class for Ref. + **/ + +final public class RefHolder { + + /** + Ref instance variable. + **/ + public Ref value; + + // constructors + public RefHolder() {} + public RefHolder(Ref initial) { + value = initial; + } + + // methods + /** + Marshal method for the RefHolder class, encodes the Ref object value to the output stream. + **/ + public void _marshal(com.ericsson.otp.erlang.OtpOutputStream out) throws java.lang.Exception { + RefHelper.marshal(out, value); + } + + /** + Unmarshal method for the RefHolder class, decodes a Ref object from the output stream + and assigns it to the Holder value field. + **/ + public void _unmarshal(com.ericsson.otp.erlang.OtpInputStream in) throws java.lang.Exception { + value = RefHelper.unmarshal(in); + } +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/ShortHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/ShortHolder.java new file mode 100644 index 0000000000..81fd7656b8 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/ShortHolder.java @@ -0,0 +1,61 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for long + * + */ +package com.ericsson.otp.ic; + +/** + +Holder class for Short, according to OMG-IDL java mapping. + +**/ + +final public class ShortHolder implements Holder { + public short value; + + public ShortHolder() {} + + public ShortHolder(short initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Shorts. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof Short ) + return ( value == ((Short)obj).shortValue()); + else + return false; + } + + /** + Comparisson method for Shorts. + @return true if the input short value equals the value of the current object, false otherwize + **/ + public boolean equals( short s ) { + return ( value == s); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/StringHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/StringHolder.java new file mode 100644 index 0000000000..09b42dc270 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/StringHolder.java @@ -0,0 +1,62 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * A Holder class for IDL's out/inout argument passing modes for string + * + */ +package com.ericsson.otp.ic; + + +/** + +Holder class for String, according to OMG-IDL java mapping. + +**/ + +final public class StringHolder implements Holder { + public String value; + + public StringHolder() {} + + public StringHolder(String initial) { + value = initial; + } + + /* Extra methods not in standard. */ + /** + Comparisson method for Strings. + @return true if the input object equals the current object, false otherwize + **/ + public boolean equals( Object obj ) { + if( obj instanceof String ) + return ( value == obj); + else + return false; + } + + /** + Comparisson method for Strings. + @return true if the input String value equals the value of the current object, false otherwize + **/ + public boolean equals( String s ) { + return ( value == s); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/TCKind.java b/lib/ic/java_src/com/ericsson/otp/ic/TCKind.java new file mode 100644 index 0000000000..210f7f6216 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/TCKind.java @@ -0,0 +1,199 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * The TCKind class for Java IDL + * + */ +package com.ericsson.otp.ic; + +/** + The TCKind class is the implementation of the OMG-IDL enumerant type TCKind. + **/ + +final public class TCKind { + + // instance variables + public static final int _tk_null = 0, + _tk_void = 1, + _tk_short = 2, + _tk_long = 3, + _tk_ushort = 4, + _tk_ulong = 5, + _tk_float = 6, + _tk_double = 7, + _tk_boolean = 8, + _tk_char = 9, + _tk_octet = 10, + _tk_any = 11, + _tk_TypeCode = 12, + _tk_Principal = 13, + _tk_objref = 14, + _tk_struct = 15, + _tk_union = 16, + _tk_enum = 17, + _tk_string = 18, + _tk_sequence = 19, + _tk_array = 20, + _tk_alias = 21, + _tk_except = 22, + _tk_longlong = 23, + _tk_ulonglong = 24, + _tk_longdouble = 25, + _tk_wchar = 26, + _tk_wstring = 27, + _tk_fixed = 28, + _tk_atom = 20000, /* Used for union label default value only */ + _tk_pid = 20001, /* Used for special pid struct */ + _tk_port = 20002, /* Used for special port struct */ + _tk_ref = 20003, /* Used for special ref struct */ + _tk_term = 20004; /* Used for special term struct */ + + public static final TCKind tk_null = new TCKind(_tk_null); + public static final TCKind tk_void = new TCKind(_tk_void); + public static final TCKind tk_short = new TCKind(_tk_short); + public static final TCKind tk_long = new TCKind(_tk_long); + public static final TCKind tk_ushort = new TCKind(_tk_ushort); + public static final TCKind tk_ulong = new TCKind(_tk_ulong); + public static final TCKind tk_float = new TCKind(_tk_float); + public static final TCKind tk_double = new TCKind(_tk_double); + public static final TCKind tk_boolean = new TCKind(_tk_boolean); + public static final TCKind tk_char = new TCKind(_tk_char); + public static final TCKind tk_octet = new TCKind(_tk_octet); + public static final TCKind tk_any = new TCKind(_tk_any); + public static final TCKind tk_TypeCode = new TCKind(_tk_TypeCode); + public static final TCKind tk_Principal = new TCKind(_tk_Principal); + public static final TCKind tk_objref = new TCKind(_tk_objref); + public static final TCKind tk_struct = new TCKind(_tk_struct); + public static final TCKind tk_union = new TCKind(_tk_union); + public static final TCKind tk_enum = new TCKind(_tk_enum); + public static final TCKind tk_string = new TCKind(_tk_string); + public static final TCKind tk_sequence = new TCKind(_tk_sequence); + public static final TCKind tk_array = new TCKind(_tk_array); + public static final TCKind tk_alias = new TCKind(_tk_alias); + public static final TCKind tk_except = new TCKind(_tk_except); + public static final TCKind tk_longlong = new TCKind(_tk_longlong); + public static final TCKind tk_ulonglong = new TCKind(_tk_ulonglong); + public static final TCKind tk_longdouble = new TCKind(_tk_longdouble); + public static final TCKind tk_wchar = new TCKind(_tk_wchar); + public static final TCKind tk_wstring = new TCKind(_tk_wstring); + public static final TCKind tk_fixed = new TCKind(_tk_fixed); + protected static final TCKind tk_atom = new TCKind(_tk_atom); + protected static final TCKind tk_pid = new TCKind(_tk_pid); + protected static final TCKind tk_port = new TCKind(_tk_port); + protected static final TCKind tk_ref = new TCKind(_tk_ref); + protected static final TCKind tk_term = new TCKind(_tk_term); + private int _value; + + // constructors + private TCKind(int __value) { + _value = __value; + } + + // methods + + /** + Accessor method for the value of TCKind. + @return int, the value of TCKind object + **/ + public int value() { + return _value; + } + + /** + Translator method for TCKind. + Traslates the input integer value to a TCKind enumerant object. + @return TCKind, a TCKind object + **/ + public static final TCKind from_int(int __value) throws java.lang.Exception { + switch (__value) { + case _tk_null: + return tk_null; + case _tk_void: + return tk_void; + case _tk_short: + return tk_short; + case _tk_long: + return tk_long; + case _tk_ushort: + return tk_ushort; + case _tk_ulong: + return tk_ulong; + case _tk_float: + return tk_float; + case _tk_double: + return tk_double; + case _tk_boolean: + return tk_boolean; + case _tk_char: + return tk_char; + case _tk_octet: + return tk_octet; + case _tk_any: + return tk_any; + case _tk_TypeCode: + return tk_TypeCode; + case _tk_Principal: + return tk_Principal; + case _tk_objref: + return tk_objref; + case _tk_struct: + return tk_struct; + case _tk_union: + return tk_union; + case _tk_enum: + return tk_enum; + case _tk_string: + return tk_string; + case _tk_sequence: + return tk_sequence; + case _tk_array: + return tk_array; + case _tk_alias: + return tk_alias; + case _tk_except: + return tk_except; + case _tk_longlong: + return tk_longlong; + case _tk_ulonglong: + return tk_ulonglong; + case _tk_longdouble: + return tk_longdouble; + case _tk_wchar: + return tk_wchar; + case _tk_wstring: + return tk_wstring; + case _tk_fixed: + return tk_fixed; + case _tk_atom: + return tk_atom; + case _tk_pid: + return tk_pid; + case _tk_port: + return tk_port; + case _tk_ref: + return tk_ref; + case _tk_term: + return tk_term; + default: + throw new java.lang.Exception(""); + } + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/Term.java b/lib/ic/java_src/com/ericsson/otp/ic/Term.java new file mode 100644 index 0000000000..9219cb7038 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/Term.java @@ -0,0 +1,1109 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + +The Term class is intended to represent the erlang term generic type. +It extends the Any class and is basically used the same way as the Any class. +<p>The main difference between Term and Any is the use of guard methods +instead for TypeCode to determine the data included in the Term. +This actual when cannot determine a Term's value class returned at compile time. + +**/ + +final public class Term extends Any { + + // Primitive value holder + protected java.lang.String atomV; + protected long longV; + protected Pid PidV; + protected Ref RefV; + protected Port PortV; + protected com.ericsson.otp.erlang.OtpErlangObject ObjV; + protected int tag; + + /** + Tag accessor method + @return int, the tag of the Object that denotes the erlang external format tag + **/ + public int tag() { + return tag; + } + + /* Guards */ + + /** + Guard method + @return true if the Term is an OtpErlangAtom, false otherwize + **/ + public boolean isAtom() { + + if (ObjV == null) { + if (tag == com.ericsson.otp.erlang.OtpExternal.atomTag) + return true; + + return false; + } + + return (ObjV instanceof com.ericsson.otp.erlang.OtpErlangAtom) ; + } + + /** + Guard method + @return true if the Term is not an OtpErlangList nor an OtpErlangTuple, false otherwize + **/ + public boolean isConstant() { + if (isList()) + return false; + + if (isTuple()) + return false; + + return true; + } + + /** + Guard method + @return true if the Term is an OtpErlangFloat, false otherwize + **/ + public boolean isFloat() { + if (tag == com.ericsson.otp.erlang.OtpExternal.floatTag) + return true; + + return false; + } + + /** + Guard method + @return true if the Term is an OtpErlangInt, false otherwize + **/ + public boolean isInteger() { + switch(tag) { + case com.ericsson.otp.erlang.OtpExternal.smallIntTag: + case com.ericsson.otp.erlang.OtpExternal.intTag: + case com.ericsson.otp.erlang.OtpExternal.smallBigTag: + return true; + default: + return false; + } + } + + /** + Guard method + @return true if the Term is an OtpErlangList, false otherwize + **/ + public boolean isList() { + + if (ObjV == null) { + switch(tag) { + case com.ericsson.otp.erlang.OtpExternal.listTag: + case com.ericsson.otp.erlang.OtpExternal.stringTag: + case com.ericsson.otp.erlang.OtpExternal.nilTag: + return true; + default: + return false; + } + } + + if (ObjV instanceof com.ericsson.otp.erlang.OtpErlangList) + return true; + + if (ObjV instanceof com.ericsson.otp.erlang.OtpErlangString) + return true; + + return false; + } + + + /** + Guard method + @return true if the Term is an OtpErlangString, false otherwize + **/ + public boolean isString() { + + if (ObjV == null) { + switch(tag) { + case com.ericsson.otp.erlang.OtpExternal.stringTag: + case com.ericsson.otp.erlang.OtpExternal.nilTag: + return true; + default: + try { + stringV = extract_string(); + return true; + } catch (Exception e) { + return false; + } + } + } + + if (ObjV instanceof com.ericsson.otp.erlang.OtpErlangString) + return true; + + try { + stringV = extract_string(); + return true; + } catch (Exception e) { + return false; + } + } + + /** + Guard method + @return true if the Term is an OtpErlangInteger or an OtpErlangFloat, false otherwize + **/ + public boolean isNumber() { + switch(tag) { + case com.ericsson.otp.erlang.OtpExternal.smallIntTag: + case com.ericsson.otp.erlang.OtpExternal.intTag: + case com.ericsson.otp.erlang.OtpExternal.smallBigTag: + case com.ericsson.otp.erlang.OtpExternal.floatTag: + return true; + default : + return false; + } + } + + + /** + Guard method + @return true if the Term is an OtpErlangPid or Pid, false otherwize + **/ + public boolean isPid() { + + if (ObjV == null) { + if (tag == com.ericsson.otp.erlang.OtpExternal.pidTag) + return true; + + return false; + } + + return (ObjV instanceof com.ericsson.otp.erlang.OtpErlangPid) ; + } + + + /** + Guard method + @return true if the Term is an OtpErlangPort or Port, false otherwize + **/ + public boolean isPort() { + if (ObjV == null) { + if (tag == com.ericsson.otp.erlang.OtpExternal.portTag) + return true; + + return false; + } + + return (ObjV instanceof com.ericsson.otp.erlang.OtpErlangPort); + } + + + /** + Guard method + @return true if the Term is an OtpErlangRef, false otherwize + **/ + public boolean isReference() { + if (ObjV == null) { + switch(tag) { + case com.ericsson.otp.erlang.OtpExternal.refTag: + case com.ericsson.otp.erlang.OtpExternal.newRefTag: + return true; + default : + return false; + } + } + + return (ObjV instanceof com.ericsson.otp.erlang.OtpErlangRef) ; + } + + + /** + Guard method + @return true if the Term is an OtpErlangTuple, false otherwize + **/ + public boolean isTuple() { + if (ObjV == null) { + switch(tag) { + case com.ericsson.otp.erlang.OtpExternal.smallTupleTag: + case com.ericsson.otp.erlang.OtpExternal.largeTupleTag: + return true; + default : + return false; + } + } + + return (ObjV instanceof com.ericsson.otp.erlang.OtpErlangTuple); + } + + + /** + Guard method + @return true if the Term is an OtpErlangBinary, false otherwize + **/ + public boolean isBinary() { + if (ObjV == null) { + if (tag == com.ericsson.otp.erlang.OtpExternal.binTag) + return true; + + return false; + } + + return (ObjV instanceof com.ericsson.otp.erlang.OtpErlangBinary); + } + + + + + // Equal function + /** + Term comparison method + @return true if the input Term is equal to the object, false otherwize + **/ + public boolean equal(Term _any) { + + try { + + /* Pids */ + if ((PidV != null) && (_any.PidV != null)) + if (PidV.equal(_any.PidV)) + return true; + + /* Refs */ + if ((RefV != null) && (_any.RefV != null)) + if (RefV.equal(_any.RefV)) + return true; + + /* Ports */ + if ((PortV != null) && (_any.PortV != null)) + if (PortV.equals(_any.PortV)) + return true; + + /* strings */ + if ((stringV != null) && (_any.stringV != null)) + if (stringV.equals(_any.stringV)) + return true; + + /* atoms and booleans */ + if ((atomV != null) && (_any.atomV != null)) + if (atomV.equals(_any.atomV)) + return true; + + /* booleans */ + if (atomV != null) + if (_any.booleanV == Boolean.valueOf(atomV).booleanValue()) + return true; + + if (_any.atomV != null) + if (booleanV == Boolean.valueOf(_any.atomV).booleanValue()) + return true; + + /* integer types plus floating point types */ + double _ownNS = + longV+doubleV; + + double _othersNS = + _any.longV+_any.doubleV; + + if ((equal(_ownNS,_othersNS)) && + (!equal(_ownNS,0))) + return true; + + /* All together, 0 or false */ + if ((equal(_ownNS,_othersNS)) && + booleanV == _any.booleanV) + return true; + + + return false; + + } catch (Exception e) { + e.printStackTrace(); + return false; + } + } + + /** + Writes the value of Term to a stream + **/ + public void write_value(com.ericsson.otp.erlang.OtpOutputStream _os) + throws java.lang.Exception { + + if ((tcV == null) && (ObjV != null)) + _os.write_any(ObjV); // Type not generated by IC + + else { + + switch(tcV.kind().value()) { + + case TCKind._tk_octet : + case TCKind._tk_char : + case TCKind._tk_wchar : + case TCKind._tk_short : + case TCKind._tk_ushort : + case TCKind._tk_long : + case TCKind._tk_longlong : + case TCKind._tk_ulong : + case TCKind._tk_ulonglong : + _os.write_long(longV); + break; + + case TCKind._tk_float : + _os.write_double(doubleV); + break; + + case TCKind._tk_double : + _os.write_double(doubleV); + break; + + case TCKind._tk_boolean : + _os.write_boolean(booleanV); + break; + + case TCKind._tk_string : + case TCKind._tk_wstring : + _os.write_string(stringV); + break; + + case TCKind._tk_atom : + _os.write_atom(stringV); + break; + + case TCKind._tk_struct: + if (isPid()) + PidHelper.marshal(_os, PidV); + else { + if (isReference()) + RefHelper.marshal(_os, RefV); + else { + if (isPort()) + PortHelper.marshal(_os, PortV); + else + _os.write(os.toByteArray()); + } + } + break; + + case TCKind._tk_union: + case TCKind._tk_array: + case TCKind._tk_sequence: + case TCKind._tk_enum: + _os.write(os.toByteArray()); + break; + + case TCKind._tk_void : + _os.write_atom("ok"); + break; + + /* + * Not supported types + */ + default: + throw new java.lang.Exception("BAD KIND"); + } + } + } + + + + /* + * Insert and extract each primitive type + */ + + + /* short */ + + /** + Short value extractor method + @return short, the value of Term + **/ + public short extract_short() + throws java.lang.Exception { + + if (tcV == null) + return (short) longV; + + if (tcV.kind() == TCKind.tk_short) + return (short) longV; + + throw new java.lang.Exception(""); + } + + /** + Short value insertion method + **/ + public void insert_short(short s) { + longV = s; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_short); + }; + + /** + Short value insertion method + **/ + public void insert_short(long l) { + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_short); + }; + + + /* long */ + + /** + Long value extractor method + @return int, the value of Term + **/ + public int extract_long() + throws java.lang.Exception { + + if (tcV == null) + return (int) longV; + + if (tcV.kind() == TCKind.tk_long) + return (int) longV; + + throw new java.lang.Exception(""); + } + + /** + Long value insertion method + **/ + public void insert_long(int i){ + longV = i; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_long); + } + + /** + Long value insertion method + **/ + public void insert_long(long l){ + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_long); + } + + + /* longlong */ + + /** + Long Long value extractor method + @return long, the value of Term + **/ + public long extract_longlong() + throws java.lang.Exception { + + if (tcV == null) + return longV; + + if (tcV.kind() == TCKind.tk_longlong) + return longV; + + throw new java.lang.Exception(""); + } + + + /** + Long Long value insertion method + **/ + public void insert_longlong(long l){ + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_longlong); + } + + + /* ushort */ + + /** + Unsigned Short value extractor method + @return short, the value of Term + **/ + public short extract_ushort() + throws java.lang.Exception { + + if (tcV == null) + return (short) longV; + + if (tcV.kind() == TCKind.tk_ushort) + return (short) longV; + + throw new java.lang.Exception(""); + } + + /** + Unsigned Short value insertion method + **/ + public void insert_ushort(short s){ + longV = s; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_ushort); + } + + /** + Unsigned Short value insertion method + **/ + public void insert_ushort(long l){ + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_ushort); + } + + + /* ulong */ + + /** + Unsigned Long value extractor method + @return int, the value of Term + **/ + public int extract_ulong() + throws java.lang.Exception{ + + if (tcV == null) + return (int) longV; + + if (tcV.kind() == TCKind.tk_ulong) + return (int) longV; + + throw new java.lang.Exception(""); + } + + /** + Unsigned Long value insertion method + **/ + public void insert_ulong(int i){ + longV = i; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_ulong); + } + + + /** + Unsigned Long value insertion method + **/ + public void insert_ulong(long l){ + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_ulong); + } + + + + /* ulonglong */ + + /** + Unsigned Long Long value extractor method + @return long, the value of Term + **/ + public long extract_ulonglong() + throws java.lang.Exception { + + if (tcV == null) + return longV; + + if (tcV.kind() == TCKind.tk_ulonglong) + return longV; + + throw new java.lang.Exception(""); + } + + + /** + Unsigned Long Long value insertion method + **/ + public void insert_ulonglong(long l){ + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.intTag; + tcV = new TypeCode(TCKind.tk_ulonglong); + } + + + + /* float */ + /** + Float value extractor method + @return float, the value of Term + **/ + public float extract_float() + throws java.lang.Exception{ + + if (tcV == null) + return (float) doubleV; + + if (tcV.kind() == TCKind.tk_float) + return (float) doubleV; + + throw new java.lang.Exception(""); + } + + + /** + Float value insertion method + **/ + public void insert_float(float f){ + doubleV = f; + tag = com.ericsson.otp.erlang.OtpExternal.floatTag; + tcV = new TypeCode(TCKind.tk_float); + } + + /** + Float value insertion method + **/ + public void insert_float(double f){ + doubleV = f; + tag = com.ericsson.otp.erlang.OtpExternal.floatTag; + tcV = new TypeCode(TCKind.tk_float); + } + + + /* double */ + /** + Double value extractor method + @return double, the value of Term + **/ + public double extract_double() + throws java.lang.Exception{ + + if (tcV == null) + return doubleV; + + if (tcV.kind() == TCKind.tk_double) + return doubleV; + + throw new java.lang.Exception(""); + } + + /** + Double value insertion method + **/ + public void insert_double(double d){ + doubleV = d; + tag = com.ericsson.otp.erlang.OtpExternal.floatTag; + tcV = new TypeCode(TCKind.tk_double); + } + + + /* boolean */ + /** + Boolean value extractor method + @return boolean, the value of Term + **/ + public boolean extract_boolean() + throws java.lang.Exception{ + + if ((tcV == null) && (atomV != null)) + return Boolean.valueOf(atomV).booleanValue(); + + if (tcV.kind() == TCKind.tk_boolean) + return booleanV; + + throw new java.lang.Exception(""); + } + + /** + Boolean value insertion method + **/ + public void insert_boolean(boolean b){ + booleanV = b; + tag = com.ericsson.otp.erlang.OtpExternal.atomTag; + tcV = new TypeCode(TCKind.tk_boolean); + } + + + /* char */ + /** + Char value extractor method + @return char, the value of Term + **/ + public char extract_char() + throws java.lang.Exception{ + + if (tcV == null) + return (char) longV; + + if (tcV.kind() == TCKind.tk_char) + return (char) longV; + + throw new java.lang.Exception(""); + } + + /** + Char value insertion method + **/ + public void insert_char(char c) { + longV = c; + tag = com.ericsson.otp.erlang.OtpExternal.smallIntTag; + tcV = new TypeCode(TCKind.tk_char); + } + + /** + Char value insertion method + **/ + public void insert_char(long l) { + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.smallIntTag; + tcV = new TypeCode(TCKind.tk_char); + } + + + + /* wchar */ + /** + Wchar value extractor method + @return char, the value of Term + **/ + public char extract_wchar() + throws java.lang.Exception{ + + if (tcV == null) + return (char) longV; + + if (tcV.kind() == TCKind.tk_wchar) + return (char) longV; + + throw new java.lang.Exception(""); + } + + /** + Wchar value insertion method + **/ + public void insert_wchar(char c) { + longV = c; + tag = com.ericsson.otp.erlang.OtpExternal.smallIntTag; + tcV = new TypeCode(TCKind.tk_wchar); + } + + /** + Wchar value insertion method + **/ + public void insert_wchar(long l) { + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.smallIntTag; + tcV = new TypeCode(TCKind.tk_wchar); + } + + + /* octet */ + /** + Octet value extractor method + @return byte, the value of Term + **/ + public byte extract_octet() + throws java.lang.Exception{ + + if (tcV == null) + return (byte) longV; + + if (tcV.kind() == TCKind.tk_octet) + return (byte) longV; + + throw new java.lang.Exception(""); + } + + /** + Octet value insertion method + **/ + public void insert_octet(byte b){ + longV = b; + tag = com.ericsson.otp.erlang.OtpExternal.smallIntTag; + tcV = new TypeCode(TCKind.tk_octet); + } + + /** + Octet value insertion method + **/ + public void insert_octet(long l){ + longV = l; + tag = com.ericsson.otp.erlang.OtpExternal.smallIntTag; + tcV = new TypeCode(TCKind.tk_octet); + } + + + + /* string */ + + /** + String value extractor method + @return String, the value of Term + **/ + public java.lang.String extract_string() + throws java.lang.Exception{ + + if (tcV == null) { + if (stringV != null) + return stringV; + else { + is = this.extract_Streamable(); + stringV = is.read_string(); + return stringV; + } + } + else + if (tcV.kind() == TCKind.tk_string) + return stringV; + + throw new java.lang.Exception(""); + } + + /** + String value insertion method + **/ + public void insert_string(java.lang.String s) { + stringV = s; + tag = com.ericsson.otp.erlang.OtpExternal.stringTag; + tcV = new TypeCode(TCKind.tk_string); + } + + + + /* wstring */ + /** + Wstring value extractor method + @return String, the value of Term + **/ + public java.lang.String extract_wstring() + throws java.lang.Exception{ + + if (tcV == null) { + if (stringV != null) + return stringV; + else { + is = this.extract_Streamable(); + stringV = is.read_string(); + return stringV; + } + } + else + if (tcV.kind() == TCKind.tk_wstring) + return stringV; + + throw new java.lang.Exception(""); + } + + /** + Wstring value insertion method + **/ + public void insert_wstring(java.lang.String s) { + stringV = s; + tag = com.ericsson.otp.erlang.OtpExternal.stringTag; + tcV = new TypeCode(TCKind.tk_wstring); + } + + + + /* atom */ + /** + Atom value extractor method + @return atom, the value of Term + **/ + public java.lang.String extract_atom() + throws java.lang.Exception{ + + if ((tcV == null) && (atomV != null)) + return atomV; + + if (tcV.kind() == TCKind.tk_atom) + return stringV; + + throw new java.lang.Exception(""); + } + + + /** + Atom value insertion method + **/ + public void insert_atom(java.lang.String s) { + stringV = s; + tag = com.ericsson.otp.erlang.OtpExternal.atomTag; + tcV = new TypeCode(TCKind.tk_atom); + } + + + /* Pid */ + /** + Pid value extractor method + @return Pid, the value of Term + **/ + public Pid extract_Pid() + throws java.lang.Exception{ + + if ((tcV == null) && (PidV != null)) + return PidV; + + if (tcV.equal(PidHelper.type())) + return PidV; + + throw new java.lang.Exception(""); + } + + + /** + Pid value insertion method + **/ + public void insert_Pid(Pid p) { + PidV = p; + tag = com.ericsson.otp.erlang.OtpExternal.pidTag; + tcV = PidHelper.type(); + } + + + + /* Ref */ + /** + Ref value extractor method + @return Ref, the value of Term + **/ + public Ref extract_Ref() + throws java.lang.Exception{ + + if ((tcV == null) && (RefV != null)) + return RefV; + + if (tcV.equal(RefHelper.type())) + return RefV; + + throw new java.lang.Exception(""); + } + + /** + Ref value insertion method + **/ + public void insert_Ref(Ref r) { + RefV = r; + + if (r.isNewRef()) + tag = com.ericsson.otp.erlang.OtpExternal.newRefTag; + else + tag = com.ericsson.otp.erlang.OtpExternal.refTag; + + tcV = RefHelper.type(); + } + + + + /* Port */ + /** + Port value extractor method + @return Port, the value of Term + **/ + public Port extract_Port() + throws java.lang.Exception{ + + if ((tcV == null) && (PortV != null)) + return PortV; + + if (tcV.equal(PortHelper.type())) + return PortV; + + throw new java.lang.Exception(""); + } + + /** + Port value insertion method + **/ + public void insert_Port(Port p) { + PortV = p; + tag = com.ericsson.otp.erlang.OtpExternal.portTag; + tcV = PortHelper.type(); + } + + + /** + Object Stream extractor method + @return OtpInputStream, the stream value of Term + **/ + public com.ericsson.otp.erlang.OtpInputStream extract_Streamable() { + + if (is == null) { + if (os == null) { + if (stringV == null) + return null; + else { + // A sequence that become a string ! + os = new com.ericsson.otp.erlang.OtpOutputStream(); + os.write_string(stringV); + is = new com.ericsson.otp.erlang.OtpInputStream(os.toByteArray()); + } + } + else { + is = new com.ericsson.otp.erlang.OtpInputStream(os.toByteArray()); + } + } + + is.reset(); + return is; + } + + /** + Inserts Objects to Term + **/ + public void insert_Object(com.ericsson.otp.erlang.OtpErlangObject o) { + ObjV = o; + } + + /** + Extract Object value from Term + @return OtpErlangObject, the Object value of Term + **/ + public com.ericsson.otp.erlang.OtpErlangObject extract_Object() { + return ObjV; + } + + +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/TermHelper.java b/lib/ic/java_src/com/ericsson/otp/ic/TermHelper.java new file mode 100644 index 0000000000..437d38743b --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/TermHelper.java @@ -0,0 +1,139 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Helper class for Term. + **/ + +public class TermHelper { + + // Constructors + private TermHelper() {} + + // Methods + /** + Marshal method for the Term class, encodes the Term object to the output stream. + **/ + public static void marshal(com.ericsson.otp.erlang.OtpOutputStream _out, Term _any) + throws java.lang.Exception { + + _any.write_value(_out); + } + + /** + Unmarshal method for the Term class, decodes a Term object from the stream. + @return Term, read from the input stream + **/ + public static Term unmarshal(com.ericsson.otp.erlang.OtpInputStream _in) + throws java.lang.Exception { + + Term _value = new Term(); + + int tag = _in.peek(); + if (tag == com.ericsson.otp.erlang.OtpExternal.versionTag) { + _in.read1(); + tag = _in.peek(); + } + _value.tag = tag; + + + // Allways save the object in OtpErlangObject form + _in.mark(0); + com.ericsson.otp.erlang.OtpErlangObject _obj = _in.read_any(); + _value.insert_Object(_obj); + + switch (tag) { + case com.ericsson.otp.erlang.OtpExternal.smallIntTag: + case com.ericsson.otp.erlang.OtpExternal.intTag: + case com.ericsson.otp.erlang.OtpExternal.smallBigTag: + _in.reset(); + _value.longV = _in.read_long(); + break; + + case com.ericsson.otp.erlang.OtpExternal.atomTag: + _in.reset(); + _value.atomV = _in.read_atom(); + break; + + case com.ericsson.otp.erlang.OtpExternal.floatTag: + _in.reset(); + _value.doubleV = _in.read_double(); + break; + + case com.ericsson.otp.erlang.OtpExternal.refTag: + case com.ericsson.otp.erlang.OtpExternal.newRefTag: + _in.reset(); + com.ericsson.otp.erlang.OtpErlangRef _eref = + _in.read_ref(); + + if (_eref.isNewRef()) + _value.RefV = new Ref(_eref.node(),_eref.ids(),_eref.creation()); + else + _value.RefV = new Ref(_eref.node(),_eref.id(),_eref.creation()); + + break; + + case com.ericsson.otp.erlang.OtpExternal.portTag: + _in.reset(); + com.ericsson.otp.erlang.OtpErlangPort _eport = + _in.read_port(); + + _value.PortV = new Port(_eport.node(),_eport.id(),_eport.creation()); + break; + + case com.ericsson.otp.erlang.OtpExternal.pidTag: + _in.reset(); + com.ericsson.otp.erlang.OtpErlangPid _epid = + _in.read_pid(); + + _value.PidV = new Pid(_epid.node(),_epid.id(),_epid.serial(),_epid.creation()); + break; + + case com.ericsson.otp.erlang.OtpExternal.stringTag: + _in.reset(); + _value.stringV = _in.read_string(); + break; + + case com.ericsson.otp.erlang.OtpExternal.listTag: + case com.ericsson.otp.erlang.OtpExternal.nilTag: + case com.ericsson.otp.erlang.OtpExternal.smallTupleTag: + case com.ericsson.otp.erlang.OtpExternal.largeTupleTag: + case com.ericsson.otp.erlang.OtpExternal.binTag: + + com.ericsson.otp.erlang.OtpOutputStream _os = + new com.ericsson.otp.erlang.OtpOutputStream(); + + _obj.encode(_os); + _value.insert_Streamable(_os); + break; + + case com.ericsson.otp.erlang.OtpExternal.largeBigTag: + default: + throw new com.ericsson.otp.erlang.OtpErlangDecodeException("Uknown data type: " + tag); + } + + return _value; + } + +} + + + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/TermHolder.java b/lib/ic/java_src/com/ericsson/otp/ic/TermHolder.java new file mode 100644 index 0000000000..9c92de9523 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/TermHolder.java @@ -0,0 +1,58 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +package com.ericsson.otp.ic; + +/** + Holder class for Term. + **/ + +final public class TermHolder { + + /** + Term instance variable. + **/ + public Term value; + + // Constructors + public TermHolder() {} + + public TermHolder(Term initial) { + value = initial; + } + + // Methods + /** + Marshal method for the TermHolder class, encodes the Term object value to the output stream. + **/ + public void _marshal(com.ericsson.otp.erlang.OtpOutputStream out) + throws java.lang.Exception { + TermHelper.marshal(out, value); + } + + /** + Unmarshal method for the TermHolder class, decodes a Term object from the output stream + and assigns it to the Holder value field. + **/ + public void _unmarshal(com.ericsson.otp.erlang.OtpInputStream in) + throws java.lang.Exception { + value = TermHelper.unmarshal(in); + } + +} diff --git a/lib/ic/java_src/com/ericsson/otp/ic/TypeCode.java b/lib/ic/java_src/com/ericsson/otp/ic/TypeCode.java new file mode 100644 index 0000000000..6d049f75f7 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/TypeCode.java @@ -0,0 +1,875 @@ +/* + * %CopyrightBegin% + * + * Copyright Ericsson AB 1999-2009. All Rights Reserved. + * + * 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 online 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. + * + * %CopyrightEnd% + * + */ +/** + * The TypeCode class for Java IDL + * + */ +package com.ericsson.otp.ic; + +/** + The TypeCode class is the implementation of the OMG-IDL TypeCode type. + **/ + +public class TypeCode { + + private TCKind _kind; + private java.lang.String _id,_name; + private int _length,_member_count,_default_index; + private TypeCode _member_type,_discriminator_type,_content_type; + private Any _member_label; + private boolean extracted; + private TypeCode _members[]; + private java.lang.String _member_names[]; + private Any _member_labels[]; + + + + /* + * Constructors + */ + public TypeCode() { + extracted = false; + _members = null; + _member_names = null; + _member_labels = null; + _kind = null; + _id = null; + _name = null; + _length = -1; + _member_count = -1; + _default_index = -1; + _member_type = null; + _content_type = null; + _discriminator_type = null; + _member_label = null; + } + + public TypeCode(TCKind __kind) { + _kind = __kind; + } + + + /* + * Operation "TypeCode::equal" + */ + + /** + Comparisson method for TypeCode. + @return true if the input TypeCode value equals the value of the current object, false otherwize + **/ + public boolean equal(TypeCode tc) { + + try { + + TCKind tck = tc.kind(); + + switch (tck.value()) { + + case TCKind._tk_short: + case TCKind._tk_long: + case TCKind._tk_longlong: + case TCKind._tk_ushort: + case TCKind._tk_ulong: + case TCKind._tk_ulonglong: + case TCKind._tk_float: + case TCKind._tk_double: + case TCKind._tk_boolean: + case TCKind._tk_char: + case TCKind._tk_wchar: + case TCKind._tk_octet: + case TCKind._tk_string: + case TCKind._tk_wstring: + case TCKind._tk_any: + case TCKind._tk_void: + case TCKind._tk_atom: + + return (tck.value() == _kind.value()); + + case TCKind._tk_struct: + + if((tc.id().compareTo(_id) == 0) && + (tc.name().compareTo(_name) == 0) && + (tc.member_count() == _member_count)){ + + for (int i = 0; i < _member_count; i++) + if (!tc.member_type(i).equal(_members[i])) + return false; + + return true; + } + else + return false; + + case TCKind._tk_union: + + if((tc.id().compareTo(_id) == 0) && + (tc.name().compareTo(_name) == 0) && + (tc.member_count() == _member_count) && + (tc.discriminator_type().equal(_discriminator_type))){ + + for (int i = 0; i < _member_count; i++) + if ((!tc.member_type(i).equal(_members[i])) && + (tc.member_name(i).compareTo(_member_names[i]) != 0)) + return false; + + return true; + } + else + return false; + + case TCKind._tk_sequence: + case TCKind._tk_array: + + if((tck.value() == _kind.value()) && + (tc.content_type().equal(_content_type))) + return true; + else + return false; + + case TCKind._tk_enum: + if((tck.value() == _kind.value()) && + (tc.member_count() == _member_count)) { + + for (int i = 0; i < _member_count; i++) + if (tc.member_name(i).compareTo(_member_names[i]) != 0) + return false; + + return true; + } + else + return false; + + // Not used in real + 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 (tck.value() == _kind.value()); + + default : + return false; + + } + } catch (Exception e) { + return false; + } + + } + + + /* + * Operation "TypeCode::kind" + */ + + /** + Accessor method for the TCKind value of TypeCode. + @return TCKind, the TCKind value of the TypeCode object. + **/ + public TCKind kind() { + return _kind; + } + + /** + Insertion method for the TCKind value of TypeCode. + Sets the TCKind value of the object. + **/ + public void kind(TCKind __kind) { + _kind = __kind; + } + + /** + Insertion method for the TCKind value of TypeCode. + Sets the TCKind value of the object. + **/ + public static TCKind kind(java.lang.String atom) + throws java.lang.Exception { + + if (atom.equals("tk_null")) + return TCKind.tk_null; + else + if (atom.equals("tk_void")) + return TCKind.tk_void; + else + if (atom.equals("tk_short")) + return TCKind.tk_short; + else + if (atom.equals("tk_long")) + return TCKind.tk_long; + else + if (atom.equals("tk_ushort")) + return TCKind.tk_ushort; + else + if (atom.equals("tk_ulong")) + return TCKind.tk_ulong; + else + if (atom.equals("tk_float")) + return TCKind.tk_float; + else + if (atom.equals("tk_double")) + return TCKind.tk_double; + else + if (atom.equals("tk_boolean")) + return TCKind.tk_boolean; + else + if (atom.equals("tk_char")) + return TCKind.tk_char; + else + if (atom.equals("tk_octet")) + return TCKind.tk_octet; + else + if (atom.equals("tk_any")) + return TCKind.tk_any; + else + if (atom.equals("tk_TypeCode")) + return TCKind.tk_TypeCode; + else + if (atom.equals("tk_Principal")) + return TCKind.tk_Principal; + else + if (atom.equals("tk_objref")) + return TCKind.tk_objref; + else + if (atom.equals("tk_struct")) + return TCKind.tk_struct; + else + if (atom.equals("tk_union")) + return TCKind.tk_union; + else + if (atom.equals("tk_enum")) + return TCKind.tk_enum; + else + if (atom.equals("tk_string")) + return TCKind.tk_string; + else + if (atom.equals("tk_sequence")) + return TCKind.tk_sequence; + else + if (atom.equals("tk_array")) + return TCKind.tk_array; + else + if (atom.equals("tk_alias")) + return TCKind.tk_alias; + else + if (atom.equals("tk_except")) + return TCKind.tk_except; + else + if (atom.equals("tk_longlong")) + return TCKind.tk_longlong; + else + if (atom.equals("tk_ulonglong")) + return TCKind.tk_ulonglong; + else + if (atom.equals("tk_longdouble")) + return TCKind.tk_longdouble; + else + if (atom.equals("tk_wchar")) + return TCKind.tk_wchar; + else + if (atom.equals("tk_wstring")) + return TCKind.tk_wstring; + else + if (atom.equals("tk_fixed")) + return TCKind.tk_fixed; + else + if (atom.equals("tk_atom")) + return TCKind.tk_atom; + else + throw new java.lang.Exception("BAD KIND"); + + } + + + + /* + * Operation "TypeCode::id" + */ + + /** + Accessor method for the id value of TypeCode. + @return String, the id value of TypeCode object + **/ + public java.lang.String id() + throws java.lang.Exception{ + + if (_id == null) + throw new java.lang.Exception("BAD KIND"); + + return _id; + } + + + /** + Insertion method for the id value of TypeCode. + Sets the id value of the object. + **/ + public void id(java.lang.String __id) { + + _id = __id; + } + + + + /* + * Operation "TypeCode::name" + */ + + /** + Accessor method for the name value of TypeCode. + @return String, the name value of TypeCode object + **/ + public java.lang.String name() + throws java.lang.Exception{ + + if (_name == null) + throw new java.lang.Exception("BAD KIND"); + + return _name; + } + + /** + Insertion method for the name value of TypeCode. + Sets the name value of the object. + **/ + public void name(java.lang.String __name) { + _name = __name; + } + + + + /* + * Operation "TypeCode::member_count" + */ + + /** + Accessor method for the member number value of TypeCode. + @return int, the number of members of TypeCode object + **/ + public int member_count() + throws java.lang.Exception{ + + if (_member_count == -1) + throw new java.lang.Exception("BAD KIND"); + + return _member_count; + } + + /** + Insertion method for the member number value of TypeCode. + Sets the number of members value of the object. + **/ + public void member_count(int __member_count) { + + switch(_kind.value()) { + case TCKind._tk_struct: + _members = new TypeCode[__member_count]; + _member_names = new java.lang.String[__member_count]; + _member_count = __member_count; + break; + case TCKind._tk_union: + _members = new TypeCode[__member_count]; + _member_names = new java.lang.String[__member_count]; + _member_labels = new Any[__member_count]; + _member_count = __member_count; + break; + case TCKind._tk_enum: + _member_names = new java.lang.String[__member_count]; + _member_count = __member_count; + break; + default : + // Do nothing + } + } + + + /* + * Operation "TypeCode::member_name" + */ + + /** + Member name accessor method for TypeCode. + @return String, the name value of the member of the TypeCode object + on the selected index + **/ + public java.lang.String member_name(int __index) + throws java.lang.Exception{ + + return _member_names[__index]; + } + + /** + Insertion method for the indexed member name of TypeCode. + Sets the name of a member value of the object at the selected index.. + **/ + public void member_name(int __index, java.lang.String __member_name) { + _member_names[__index] = __member_name; + } + + + /* + * Operation "TypeCode::member_type" + */ + + /** + Member type accessor method for TypeCode. + @return TypeCOde, the type of the member of the TypeCode object + on the selected index + **/ + public TypeCode member_type(int __index) + throws java.lang.Exception{ + + return _members[__index]; + } + + /** + Insertion method for the indexed member type of TypeCode. + Sets the type of a member value of the object at the selected index.. + **/ + public void member_type(int __index, TypeCode __member_type) { + _members[__index] = __member_type; + } + + + /* + * Operation "TypeCode::member_label" + */ + + /** + Member label accessor method for TypeCode. + @return Any, the label of the member of the TypeCode object + on the selected index + **/ + public Any member_label(int __index) + throws java.lang.Exception{ + + return _member_labels[__index]; + } + + /** + Insertion method for the indexed member label of TypeCode. + Sets the label of a member value of the object at the selected index. + **/ + public void member_label(int __index, Any __member_label) { + _member_labels[__index] = __member_label; + } + + + /* + * Operation "TypeCode::discriminator_type" + */ + + /** + Discriminator type accessor method for TypeCode. + @return TypeCode, the type of the discriminator of the TypeCode object + **/ + public TypeCode discriminator_type() + throws java.lang.Exception{ + + if (_discriminator_type == null) + throw new java.lang.Exception("BAD KIND"); + + return _discriminator_type; + } + + /** + Insertion method for the type of the discriminator value of TypeCode. + Sets the discriminator type value of the object. + **/ + public void discriminator_type(TypeCode __discriminator_type) { + _discriminator_type = __discriminator_type; + } + + + /* + * Operation "TypeCode::default_index" + */ + + /** + Index accessor method for TypeCode. + @return int, the default index value of the member of the TypeCode object + **/ + public int default_index() + throws java.lang.Exception{ + + if (_default_index == -1) + throw new java.lang.Exception("BAD KIND"); + + return _default_index; + } + + /** + Insertion method for the default index value of TypeCode. + Sets the default index value of the object. + **/ + public void default_index(int __default_index) { + _default_index = __default_index; + } + + + /* + * Operation "TypeCode::length" + */ + + /** + Length accessor method for TypeCode. + @return int, the length of the TypeCode object + **/ + public int length() + throws java.lang.Exception{ + + if (_length == -1) + throw new java.lang.Exception("BAD KIND"); + + return _length; + } + + /** + Insertion method for the length value of TypeCode. + Sets the length value of the object. + **/ + public void length(int __length) { + _length = __length; + } + + + /* + * Operation "TypeCode::content_type" + */ + + /** + Content type accessor method for TypeCode. + @return TypeCode, the content type of the TypeCode object + **/ + public TypeCode content_type() + throws java.lang.Exception { + + if (_content_type == null) + throw new java.lang.Exception("BAD KIND"); + + return _content_type; + } + + /** + Insertion method for the content type value of TypeCode. + Sets the content type value of the object. + **/ + public void content_type(TypeCode __content_type) { + _content_type = __content_type; + } + + + /** + Marshal operation for TypeCode. + **/ + public static void marshal(com.ericsson.otp.erlang.OtpOutputStream _os, TypeCode _tc) + throws java.lang.Exception { + + TypeCode memberTC = null; + int len = -1; + + switch(_tc.kind().value()) { + + case TCKind._tk_short : + _os.write_atom("tk_short"); + break; + case TCKind._tk_ushort : + _os.write_atom("tk_ushort"); + break; + case TCKind._tk_long : + _os.write_atom("tk_long"); + break; + case TCKind._tk_longlong : + _os.write_atom("tk_longlong"); + break; + case TCKind._tk_ulong : + _os.write_atom("tk_ulong"); + break; + case TCKind._tk_ulonglong : + _os.write_atom("tk_ulonglong"); + break; + case TCKind._tk_float : + _os.write_atom("tk_float"); + break; + case TCKind._tk_double : + _os.write_atom("tk_double"); + break; + case TCKind._tk_boolean : + _os.write_atom("tk_boolean"); + break; + case TCKind._tk_char : + _os.write_atom("tk_char"); + break; + case TCKind._tk_wchar : + _os.write_atom("tk_wchar"); + break; + case TCKind._tk_octet : + _os.write_atom("tk_octet"); + break; + case TCKind._tk_string : + _os.write_tuple_head(2); + _os.write_atom("tk_string"); + _os.write_ulong(_tc.length()); + break; + case TCKind._tk_wstring : + _os.write_tuple_head(2); + _os.write_atom("tk_wstring"); + _os.write_ulong(_tc.length()); + break; + case TCKind._tk_struct: + len = _tc.member_count(); + _os.write_tuple_head(4); + _os.write_atom("tk_struct"); + _os.write_string(_tc.id()); + _os.write_string(_tc.name()); + // Member list + _os.write_list_head(len); + for(int i=0; i<len; i++) { + _os.write_tuple_head(2); + _os.write_string(_tc.member_name(i)); + marshal(_os,_tc.member_type(i)); + } + _os.write_nil(); + break; + case TCKind._tk_union: + len = _tc.member_count(); + _os.write_tuple_head(6); + _os.write_atom("tk_union"); + _os.write_string(_tc.id()); + _os.write_string(_tc.name()); + marshal(_os,_tc.discriminator_type()); + _os.write_int(_tc.default_index()); + // Member list + _os.write_list_head(len); + for(int i=0; i<len; i++) { + _os.write_tuple_head(3); + _tc.member_label(i).write_value(_os); + _os.write_string(_tc.member_name(i)); + marshal(_os,_tc.member_type(i)); + } + _os.write_nil(); + break; + case TCKind._tk_sequence: + _os.write_tuple_head(3); + _os.write_atom("tk_sequence"); + marshal(_os,_tc.content_type()); + _os.write_int(_tc.length()); + break; + case TCKind._tk_array: + _os.write_tuple_head(3); + _os.write_atom("tk_array"); + marshal(_os,_tc.content_type()); + _os.write_int(_tc.length()); + break; + case TCKind._tk_enum: + len = _tc.member_count(); + _os.write_tuple_head(4); + _os.write_atom("tk_enum"); + _os.write_string(_tc.id()); + _os.write_string(_tc.name()); + _os.write_list_head(len); + for(int i=0; i<len; i++) + _os.write_string(_tc.member_name(i)); + _os.write_nil(); + break; + case TCKind._tk_any: + _os.write_atom("tk_any"); + break; + case TCKind._tk_void : + _os.write_atom("tk_void"); + break; + /* + * Not supported types + */ + default : + throw new java.lang.Exception("Unsupported type"); + + } + + } + + + /** + Unmarshal operation for TypeCode. + @return TypeCode, the TypeCode read from the input stream. + **/ + public static TypeCode unmarshal(com.ericsson.otp.erlang.OtpInputStream _is) + throws java.lang.Exception { + + TypeCode _tc, __member; + TCKind __kind; + int __len; + int __tag = _is.peek(); + + switch(__tag) { + case (com.ericsson.otp.erlang.OtpExternal.atomTag): + __kind = TypeCode.kind(_is.read_atom()); + + switch(__kind.value()) { + case TCKind._tk_short : + case TCKind._tk_ushort : + case TCKind._tk_long : + case TCKind._tk_longlong : + case TCKind._tk_ulong : + case TCKind._tk_ulonglong : + case TCKind._tk_float : + case TCKind._tk_double : + case TCKind._tk_boolean : + case TCKind._tk_char : + case TCKind._tk_wchar : + case TCKind._tk_octet : + case TCKind._tk_void : + case TCKind._tk_any : + _tc = new TypeCode(); + _tc.kind(__kind); + + return _tc; + default : + throw new java.lang.Exception("Unsupported type"); + } + + case (com.ericsson.otp.erlang.OtpExternal.smallTupleTag): + case (com.ericsson.otp.erlang.OtpExternal.largeTupleTag): + + __len = _is.read_tuple_head(); + __tag = _is.peek(); + + switch(__tag) { + + case (com.ericsson.otp.erlang.OtpExternal.atomTag): + + __kind = TypeCode.kind(_is.read_atom()); + _tc = new TypeCode(); + _tc.kind(__kind); + + switch(__kind.value()) { + + case TCKind._tk_string : + _tc.length((int)_is.read_ulong()); + return _tc; + + case TCKind._tk_wstring : + _tc.length((int)_is.read_ulong()); + return _tc; + + case TCKind._tk_struct: + + _tc.id(_is.read_string()); + _tc.name(_is.read_string()); + __len = _is.read_list_head(); + _tc.member_count(__len); + + for(int i=0; i<__len; i++) { + _is.read_tuple_head(); + _tc.member_name(i,_is.read_string()); + _tc.member_type(i,unmarshal(_is)); + } + _is.read_nil(); + + return _tc; + + + case TCKind._tk_union: + + _tc.id(_is.read_string()); + _tc.name(_is.read_string()); + _tc.discriminator_type(unmarshal(_is)); + _tc.default_index(_is.read_int()); + __len = _is.read_list_head(); + _tc.member_count(__len); + + for(int i=0; i<__len; i++) { + _is.read_tuple_head(); + + __tag = _is.peek(); + Any __label = new Any(); + TypeCode __label_type = new TypeCode(); + + __label_type.kind(com.ericsson.otp.ic.TCKind.tk_long); + __label.type(__label_type); + + switch(__tag) { + case (com.ericsson.otp.erlang.OtpExternal.stringTag): + java.lang.String __enum = _is.read_string(); + __label.insert_string(__enum); + break; + case (com.ericsson.otp.erlang.OtpExternal.atomTag): + java.lang.String __default = _is.read_atom(); + __label.insert_atom(__default); + break; + default: + __label.insert_long(_is.read_int()); + } + + _tc.member_label(i,__label); + _tc.member_name(i,_is.read_string()); + _tc.member_type(i,unmarshal(_is)); + } + _is.read_nil(); + + return _tc; + + + case TCKind._tk_sequence: + _tc.content_type(unmarshal(_is)); + _tc.length(_is.read_int()); + return _tc; + + + case TCKind._tk_array: + _tc.content_type(unmarshal(_is)); + _tc.length(_is.read_int()); + return _tc; + + + case TCKind._tk_enum: + + _tc.id(_is.read_string()); + _tc.name(_is.read_string()); + __len = _is.read_list_head(); + _tc.member_count(__len); + + for(int i=0; i<__len; i++) + _tc.member_name(i,_is.read_string()); + + _is.read_nil(); + + return _tc; + + default: + throw new java.lang.Exception("Unsupported type"); + + } + + default: + throw new java.lang.Exception("Unsupported type"); + } + + } + + return null; + } + +} + + diff --git a/lib/ic/java_src/com/ericsson/otp/ic/ignore_config_record.inf b/lib/ic/java_src/com/ericsson/otp/ic/ignore_config_record.inf new file mode 100644 index 0000000000..34e5586175 --- /dev/null +++ b/lib/ic/java_src/com/ericsson/otp/ic/ignore_config_record.inf @@ -0,0 +1 @@ +Dummy to speed up compilatio |