cppu/test/language_binding.idl

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: language_binding.idl,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _TEST_LANGUAGE_BINDING_IDL_
  31 #define _TEST_LANGUAGE_BINDING_IDL_
  32
  33 #include <com/sun/star/uno/XInterface.idl>
  34 #include <com/sun/star/lang/IllegalArgumentException.idl>
  35
  36 module test
  37 {
  38
  39 enum TestEnum
  40 {
  41     TEST,
  42     ONE,
  43     TWO,
  44     CHECK,
  45     LOLA,
  46     PALOO,
  47     ZA
  48 };
  49
  50 /**
  51  * simple c++ types
  52  */
  53 struct TestSimple
  54 {
  55     boolean                                        Bool;
  56     char                                           Char;
  57     byte                                           Byte;
  58     short                                          Short;
  59     unsigned short                         UShort;
  60     long                                           Long;
  61     unsigned long                          ULong;
  62     hyper                                          Hyper;
  63     unsigned hyper                         UHyper;
  64     float                                          Float;
  65     double                                         Double;
  66     test::TestEnum                         Enum;
  67 };
  68 /**
  69  * equal to max size returned in registers on x86_64
  70  */
  71 struct SmallStruct
  72 {
  73     hyper                                          a;
  74     hyper                                          b;
  75 };
  76 /**
  77  * equal to max size returned in registers on ia64
  78  */
  79 struct MediumStruct
  80 {
  81     hyper                                          a;
  82     hyper                                          b;
  83     hyper                                          c;
  84     hyper                                          d;
  85 };
  86 /**
  87  * bigger than max size returned in registers on ia64
  88  */
  89 struct BigStruct
  90 {
  91     hyper                                          a;
  92     hyper                                          b;
  93     hyper                                          c;
  94     hyper                                          d;
  95     hyper                                          e;
  96     hyper                                          f;
  97     hyper                                          g;
  98     hyper                                          h;
  99 };
 100 /**
 101  * all floats, ia64 claims to handle them specially
 102  */
 103 struct AllFloats
 104 {
 105     float                                          a;
 106     float                                          b;
 107     float                                          c;
 108     float                                          d;
 109 };
 110
 111 /**
 112  * complex c++ types
 113  */
 114 struct TestElement : test::TestSimple
 115 {
 116     string                                         String;
 117     com::sun::star::uno::XInterface   Interface;
 118     any                                            Any;
 119 };
 120 struct TestDataElements : test::TestElement
 121 {
 122     sequence<test::TestElement > Sequence;
 123 };
 124
 125 typedef TestDataElements TestData;
 126
 127 /**
 128  * Monster test interface to test language binding calls.
 129  *
 130  * @author Daniel Boelzle
 131  */
 132 interface XLBTestBase : com::sun::star::uno::XInterface
 133 {
 134     /**
 135      * in parameter test, tests by calls reference also (complex types)
 136      */
 137     [oneway] void setValues( [in] boolean bBool, [in] char cChar, [in] byte nByte,
 138                              [in] short nShort, [in] unsigned short nUShort,
 139                              [in] long nLong, [in] unsigned long nULong,
 140                              [in] hyper nHyper, [in] unsigned hyper nUHyper,
 141                              [in] float fFloat, [in] double fDouble,
 142                              [in] test::TestEnum eEnum, [in] string aString,
 143                              [in] com::sun::star::uno::XInterface xInterface, [in] any aAny,
 144                              [in] sequence<test::TestElement > aSequence,
 145                              [in] test::TestData aStruct );
 146     /**
 147      * inout parameter test
 148      */
 149     test::TestData setValues2( [inout] boolean bBool, [inout] char cChar, [inout] byte nByte,
 150                                [inout] short nShort, [inout] unsigned short nUShort,
 151                                [inout] long nLong, [inout] unsigned long nULong,
 152                                [inout] hyper nHyper, [inout] unsigned hyper nUHyper,
 153                                [inout] float fFloat, [inout] double fDouble,
 154                                [inout] test::TestEnum eEnum, [inout] string aString,
 155                                [inout] com::sun::star::uno::XInterface xInterface, [inout] any aAny,
 156                                [inout] sequence<test::TestElement > aSequence,
 157                                [inout] test::TestData aStruct );
 158
 159     /**
 160      * out parameter test
 161      */
 162     test::TestData getValues( [out] boolean bBool, [out] char cChar, [out] byte nByte,
 163                               [out] short nShort, [out] unsigned short nUShort,
 164                               [out] long nLong, [out] unsigned long nULong,
 165                               [out] hyper nHyper, [out] unsigned hyper nUHyper,
 166                               [out] float fFloat, [out] double fDouble,
 167                               [out] test::TestEnum eEnum, [out] string aString,
 168                               [out] com::sun::star::uno::XInterface xInterface, [out] any aAny,
 169                               [out] sequence<test::TestElement > aSequence,
 170                               [out] test::TestData aStruct );
 171
 172     /**
 173      * register return test 1
 174      */
 175     test::SmallStruct echoSmallStruct( [in] test::SmallStruct aStruct );
 176
 177     /**
 178      * register return test 2
 179      */
 180     test::MediumStruct echoMediumStruct( [in] test::MediumStruct aStruct );
 181
 182     /**
 183      * register return test 3
 184      */
 185     test::BigStruct echoBigStruct( [in] test::BigStruct aStruct );
 186
 187     /**
 188      * register return test 4
 189      */
 190     test::AllFloats echoAllFloats( [in] test::AllFloats aStruct );
 191
 192     [attribute] boolean                                  Bool;
 193     [attribute] byte                                     Byte;
 194     [attribute] char                                     Char;
 195     [attribute] short                                    Short;
 196     [attribute] unsigned short                   UShort;
 197     [attribute] long                                     Long;
 198     [attribute] unsigned long                    ULong;
 199     [attribute] hyper                                    Hyper;
 200     [attribute] unsigned hyper                   UHyper;
 201     [attribute] float                                    Float;
 202     [attribute] double                                   Double;
 203     [attribute] test::TestEnum                   Enum;
 204     [attribute] string                                   String;
 205     [attribute] com::sun::star::uno::XInterface Interface;
 206     [attribute] any                                              Any;
 207     [attribute] sequence<test::TestElement > Sequence;
 208     [attribute] test::TestData                   Struct;
 209 };
 210
 211
 212 /**
 213  * Inherting from monster; adds raiseException().
 214  *
 215  * @author Daniel Boelzle
 216  */
 217 interface XLanguageBindingTest : test::XLBTestBase
 218 {
 219     /**
 220      * params are there only for dummy, to test if all temp out params will be released.
 221      */
 222     test::TestData raiseException( [out] boolean bBool, [out] char cChar, [out] byte nByte,
 223                                    [out] short nShort, [out] unsigned short nUShort,
 224                                    [out] long nLong, [out] unsigned long nULong,
 225                                    [out] hyper nHyper, [out] unsigned hyper nUHyper,
 226                                    [out] float fFloat, [out] double fDouble,
 227                                    [out] test::TestEnum eEnum, [out] string aString,
 228                                    [out] com::sun::star::uno::XInterface xInterface, [out] any aAny,
 229                                    [out] sequence<test::TestElement > aSequence,
 230                                    [out] test::TestData aStruct )
 231         raises( com::sun::star::lang::IllegalArgumentException );
 232
 233     /**
 234      * raises runtime exception
 235      */
 236     [attribute] long                                     RuntimeException;
 237 };
 238
 239 }; // test
 240
 241
 242 #endif