// $Id$ // ============================================================================ // // = LIBRARY // TAO/performance-tests/Anyop // // = FILENAME // test.idl // // = DESCRIPTION // The basis for this file is the IDL file in TAO/tests/Param_Test // but modified slightly for testing the performance of Any // insertion and extraction operators. Not every IDL type in this // file is tested yet. // // = AUTHORS // Aniruddha Gokhale // Jeff Parsons // // ============================================================================ #include interface Coffee { struct Desc { string name; }; attribute Desc description; // provides us the coffee object type }; //typedef sequence ObjSeq; interface Param_Test { // Add exceptions to each // primitive types short test_short (in short s1, inout short s2, out short s3); // NOTE: use unsigned long long instead of long long, because // unsigned long long has much better support on platforms that // do not have a native 64 bit int type. unsigned long long test_ulonglong (in unsigned long long s1, inout unsigned long long s2, out unsigned long long s3); // strings unbounded string test_unbounded_string (in string s1, inout string s2, out string s3); // strings bounded typedef string<128> short_string; short_string test_bounded_string (in short_string s1, inout short_string s2, out short_string s3); // wstrings unbounded wstring test_unbounded_wstring (in wstring ws1, inout wstring ws2, out wstring ws3); // wstrings bounded typedef wstring<128> short_wstring; short_wstring test_bounded_wstring (in short_wstring ws1, inout short_wstring ws2, out short_wstring ws3); // structures (fixed size) struct Fixed_Struct { long l; char c; short s; octet o; float f; boolean b; double d; }; Fixed_Struct test_fixed_struct (in Fixed_Struct s1, inout Fixed_Struct s2, out Fixed_Struct s3); // = Sequences of long, strings, Var_Struct and Object // references... struct NameComponent { string id; string kind; }; struct Step { NameComponent name; boolean process; }; typedef sequence PathSpec; PathSpec test_unbounded_struct_sequence (in PathSpec s1, inout PathSpec s2, out PathSpec s3); typedef sequence Short_Seq; Short_Seq test_short_sequence (in Short_Seq s1, inout Short_Seq s2, out Short_Seq s3); typedef sequence Bounded_Short_Seq; Bounded_Short_Seq test_bounded_short_sequence (in Bounded_Short_Seq s1, inout Bounded_Short_Seq s2, out Bounded_Short_Seq s3); typedef sequence Long_Seq; Long_Seq test_long_sequence (in Long_Seq s1, inout Long_Seq s2, out Long_Seq s3); typedef sequence Bounded_Long_Seq; Bounded_Long_Seq test_bounded_long_sequence (in Bounded_Long_Seq s1, inout Bounded_Long_Seq s2, out Bounded_Long_Seq s3); typedef sequence StrSeq; StrSeq test_strseq (in StrSeq s1, inout StrSeq s2, out StrSeq s3); typedef sequence Bounded_StrSeq; Bounded_StrSeq test_bounded_strseq (in Bounded_StrSeq s1, inout Bounded_StrSeq s2, out Bounded_StrSeq s3); typedef sequence WStrSeq; WStrSeq test_wstrseq (in WStrSeq ws1, inout WStrSeq ws2, out WStrSeq ws3); typedef sequence Bounded_WStrSeq; Bounded_WStrSeq test_bounded_wstrseq (in Bounded_WStrSeq ws1, inout Bounded_WStrSeq ws2, out Bounded_WStrSeq ws3); typedef sequence StructSeq; StructSeq test_struct_sequence (in StructSeq s1, inout StructSeq s2, out StructSeq s3); typedef sequence Bounded_StructSeq; Bounded_StructSeq test_bounded_struct_sequence (in Bounded_StructSeq s1, inout Bounded_StructSeq s2, out Bounded_StructSeq s3); typedef sequence Coffee_Mix; Coffee_Mix test_coffe_mix (in Coffee_Mix s1, inout Coffee_Mix s2, out Coffee_Mix s3); typedef sequence Bounded_Coffee_Mix; Bounded_Coffee_Mix test_bounded_coffe_mix (in Bounded_Coffee_Mix s1, inout Bounded_Coffee_Mix s2, out Bounded_Coffee_Mix s3); typedef sequence AnySeq; AnySeq test_anyseq (in AnySeq s1, inout AnySeq s2, out AnySeq s3); /* typedef sequence Bounded_AnySeq; Bounded_AnySeq test_bounded_anyseq (in Bounded_AnySeq s1, inout Bounded_AnySeq s2, out Bounded_AnySeq s3); */ typedef string DUMMY; // variable structures struct Var_Struct { double dbl; DUMMY dummy1; boolean boole; DUMMY dummy2; short shrt; StrSeq seq; }; Var_Struct test_var_struct (in Var_Struct s1, inout Var_Struct s2, out Var_Struct s3); // nested structs (We reuse the var_struct defn above to make a very // complicated nested structure) struct Nested_Struct { Var_Struct vs; }; Nested_Struct test_nested_struct (in Nested_Struct s1, inout Nested_Struct s2, out Nested_Struct s3); // object references Coffee make_coffee (); // make a Coffee object // test the parameter passing conventions for ObjRefs Coffee test_objref (in Coffee o1, inout Coffee o2, out Coffee o3); // test typecodes CORBA::TypeCode test_typecode (in CORBA::TypeCode t1, inout CORBA::TypeCode t2, out CORBA::TypeCode t3); // Anys. We try to pump in all kinds of data types thru these Anys any test_any (in any a1, inout any a2, out any a3); struct Objref_Struct { long x; Coffee y; }; Objref_Struct test_objref_struct (in Objref_Struct t1, inout Objref_Struct t2, out Objref_Struct t3); // test structures that contain object references. // arrays (fixed) const unsigned long DIM1 = 10; typedef long Fixed_Array [DIM1]; Fixed_Array test_fixed_array (in Fixed_Array l1, inout Fixed_Array l2, out Fixed_Array l3); // arrays (variable) const unsigned long DIM2 = 5; typedef string Var_Array [DIM2]; Var_Array test_var_array (in Var_Array v1, inout Var_Array v2, out Var_Array v3); // Bounded and unbounced sequences of arrays. typedef sequence ArraySeq; ArraySeq test_array_sequence (in ArraySeq s1, inout ArraySeq s2, out ArraySeq s3); typedef sequence Bounded_ArraySeq; Bounded_ArraySeq test_bounded_array_sequence (in Bounded_ArraySeq s1, inout Bounded_ArraySeq s2, out Bounded_ArraySeq s3); // Just to test report a problem exception Ooops { string reason; unsigned long input; }; // To test what happens when an unexpected exception is thrown. exception BadBoy { }; unsigned long test_exception (in unsigned long s1, inout unsigned long s2, out unsigned long s3) raises (Ooops); union Big_Union switch (short) { case 0: Fixed_Array the_array; case 1: Coffee the_interface; case 2: long the_long; case 3: short another_array[32]; case 4: string the_string; case 5: Short_Seq the_sequence; case 6: any the_any; case 7: octet the_octet; case 8: char the_char; case 9: boolean the_boolean; case 10: Var_Struct the_var_struct; case 11: Fixed_Struct the_fixed_struct; // case 12: // Other_Union the_union; }; Big_Union test_big_union (in Big_Union u1, inout Big_Union u2, out Big_Union u3); enum Small_Union_Switch { A_LONG, A_SHORT }; union Small_Union switch (Small_Union_Switch) { case A_LONG: long the_long; case A_SHORT: short the_short; }; Small_Union test_small_union (in Small_Union u1, inout Small_Union u2, out Small_Union u3); // The following two structs are used to help compose // a complex Any for the test function below. struct level4 { string level5_string; any level5_any; }; struct level8 { string level9_string; boolean level9_boolean; short level9_short; }; any test_complex_any (in any ca1, inout any ca2, out any ca3); // Recursive structs. Contains a sequence of itself. struct Recursive_Struct { long x; sequence children; }; Recursive_Struct test_recursive_struct (in Recursive_Struct rs1, inout Recursive_Struct rs2, out Recursive_Struct rs3); // Recursive unions. We have one recursive union nested in a different // recursive union. union nested_rec_union switch (short) { case 0: long value; case 1: sequence nested_rec_member; }; union Recursive_Union switch (short) { case 0: sequence rec_member; case 1: nested_rec_union nested_member; }; Recursive_Union test_recursive_union (in Recursive_Union ru1, inout Recursive_Union ru2, out Recursive_Union ru3); // multidimensional arrays (fixed). The following will give rise to a 3 // dimensional array. The following will define a 3-dimensional array of size // DIM1 X DIM2 X DIM3 const unsigned long DIM3 = 3; typedef Fixed_Array Multdim_Array [DIM2][DIM3]; Multdim_Array test_multdim_array (in Multdim_Array m1, inout Multdim_Array m2, out Multdim_Array m3); // sequence of typecodes // typedef sequence TypeCodeSeq; // TypeCodeSeq test_tcseq (in TypeCodeSeq t1, inout TypeCodeSeq t2, out TypeCodeSeq t3); };