| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| #ifndef __com_sun_star_test_bridge_XBridge_idl__ |
| #define __com_sun_star_test_bridge_XBridge_idl__ |
| |
| #ifndef __com_sun_star_uno_XInterface_idl__ |
| #include <com/sun/star/uno/XInterface.idl> |
| #endif |
| |
| #ifndef __com_sun_star_lang_IllegalArgumentException_idl__ |
| #include <com/sun/star/lang/IllegalArgumentException.idl> |
| #endif |
| |
| module com |
| { |
| module sun |
| { |
| module star |
| { |
| module test |
| { |
| module bridge |
| { |
| |
| published enum TestEnum |
| { |
| TEST, |
| ONE, |
| TWO, |
| CHECK, |
| LOLA, |
| PALOO, |
| ZA |
| }; |
| |
| /** |
| * simple types |
| */ |
| published struct TestSimple |
| { |
| boolean Bool; |
| char Char; |
| byte Byte; |
| short Short; |
| unsigned short UShort; |
| long Long; |
| unsigned long ULong; |
| hyper Hyper; |
| unsigned hyper UHyper; |
| float Float; |
| double Double; |
| TestEnum Enum; |
| }; |
| /** |
| * complex types adding string, inteface, any |
| */ |
| published struct TestElement : TestSimple |
| { |
| string String; |
| com::sun::star::uno::XInterface Interface; |
| any Any; |
| }; |
| /** |
| * adding even more complexity, sequence< TestElement > |
| */ |
| published struct TestDataElements : TestElement |
| { |
| sequence< TestElement > Sequence; |
| }; |
| |
| /** |
| * typedef used in interface |
| */ |
| published typedef TestDataElements TestData; |
| |
| published interface XRecursiveCall : com::sun::star::uno::XInterface |
| { |
| /*** |
| * @param nToCall If nToCall is 0, the method returns immeadiatly. |
| * Otherwise, call the given interface with nToCall -1 |
| * |
| ***/ |
| void callRecursivly( [in] XRecursiveCall xCall , [in] long nToCall ); |
| }; |
| |
| /** |
| * Monster test interface to test bridge calls. |
| * An implementation of this object has to store given values and return whenever there |
| * is an out param or return value. |
| */ |
| published interface XBridgeTestBase : com::sun::star::uno::XInterface |
| { |
| /** |
| * in parameter test, tests by calls reference also (complex types) |
| */ |
| [oneway] void setValues( [in] boolean bBool, [in] char cChar, [in] byte nByte, |
| [in] short nShort, [in] unsigned short nUShort, |
| [in] long nLong, [in] unsigned long nULong, |
| [in] hyper nHyper, [in] unsigned hyper nUHyper, |
| [in] float fFloat, [in] double fDouble, |
| [in] TestEnum eEnum, [in] string aString, |
| [in] com::sun::star::uno::XInterface xInterface, [in] any aAny, |
| [in] sequence< TestElement > aSequence, |
| [in] TestData aStruct ); |
| /** |
| * inout parameter test |
| * |
| * @return aStruct. The out parameter contain the values, that were previously set |
| * by setValues or (if not called before) default constructed values. |
| * |
| */ |
| TestData setValues2( [inout] boolean bBool, [inout] char cChar, [inout] byte nByte, |
| [inout] short nShort, [inout] unsigned short nUShort, |
| [inout] long nLong, [inout] unsigned long nULong, |
| [inout] hyper nHyper, [inout] unsigned hyper nUHyper, |
| [inout] float fFloat, [inout] double fDouble, |
| [inout] TestEnum eEnum, [inout] string aString, |
| [inout] com::sun::star::uno::XInterface xInterface, [inout] any aAny, |
| [inout] sequence< TestElement > aSequence, |
| [inout] TestData aStruct ); |
| |
| /** |
| * out parameter test |
| */ |
| TestData getValues( [out] boolean bBool, [out] char cChar, [out] byte nByte, |
| [out] short nShort, [out] unsigned short nUShort, |
| [out] long nLong, [out] unsigned long nULong, |
| [out] hyper nHyper, [out] unsigned hyper nUHyper, |
| [out] float fFloat, [out] double fDouble, |
| [out] TestEnum eEnum, [out] string aString, |
| [out] com::sun::star::uno::XInterface xInterface, [out] any aAny, |
| [out] sequence< TestElement > aSequence, |
| [out] TestData aStruct ); |
| |
| [attribute] boolean Bool; |
| [attribute] byte Byte; |
| [attribute] char Char; |
| [attribute] short Short; |
| [attribute] unsigned short UShort; |
| [attribute] long Long; |
| [attribute] unsigned long ULong; |
| [attribute] hyper Hyper; |
| [attribute] unsigned hyper UHyper; |
| [attribute] float Float; |
| [attribute] double Double; |
| [attribute] TestEnum Enum; |
| [attribute] string String; |
| [attribute] com::sun::star::uno::XInterface Interface; |
| [attribute] any Any; |
| [attribute] sequence< TestElement > Sequence; |
| [attribute] TestData Struct; |
| |
| |
| /*** |
| * This method returns the parameter value. |
| * Method to extensivly test anys. |
| ****/ |
| any transportAny( [in] any value ); |
| |
| /*** |
| * methods to check sequence of calls. Call call() and callOneway |
| * in an arbitrary sequence. Increase the callId for every call. |
| * The testobject sets an error flag. |
| |
| @see testSequencePassed |
| ***/ |
| void call( [in] long nCallId, [in] long nWaitMUSEC ); |
| [oneway] void callOneway( [in] long nCallId, [in] long nWaitMUSEC ); |
| boolean sequenceOfCallTestPassed(); |
| |
| /**** |
| * methods to check, if threads thread identity is holded. |
| * |
| ***/ |
| void startRecursiveCall( [in] XRecursiveCall xCall , [in] long nToCall ); |
| }; |
| |
| |
| /** |
| * Inherting from monster; adds raiseException(), attribute raising RuntimeException. |
| */ |
| published interface XBridgeTest : XBridgeTestBase |
| { |
| /** |
| * the exception struct returned has to be filled with given arguments. |
| * return value is for dummy. |
| */ |
| TestData raiseException( [in] short ArgumentPosition, |
| [in] string Message, |
| [in] com::sun::star::uno::XInterface Context ) |
| raises( com::sun::star::lang::IllegalArgumentException ); |
| |
| |
| /** |
| * Throws runtime exception. |
| * check remote bridges handle exceptions during oneway calls properly. |
| * Note that on client side the execption may fly or not. When it flies, it should |
| * have the proper message and context. |
| ***/ |
| [oneway] void raiseRuntimeExceptionOneway( [in] string Message, |
| [in] com::sun::star::uno::XInterface Context ); |
| |
| /** |
| * raises runtime exception; |
| * the exception struct returned has to be filled with formerly set test data. |
| */ |
| [attribute] long RuntimeException; |
| }; |
| |
| /** Extended tests with sequences. |
| */ |
| published interface XBridgeTest2 : XBridgeTest |
| { |
| sequence< boolean > setSequenceBool( [in] sequence< boolean > aSeq); |
| sequence< char > setSequenceChar( [in] sequence< char > aSeq); |
| sequence< byte> setSequenceByte( [in] sequence< byte > aSeq); |
| sequence< short> setSequenceShort( [in] sequence< short > aSeq); |
| sequence< unsigned short > setSequenceUShort( [in] sequence< unsigned short > aSeq); |
| sequence< long > setSequenceLong( [in] sequence< long > aSeq); |
| sequence< unsigned long > setSequenceULong( [in] sequence< unsigned long > aSeq); |
| sequence< hyper > setSequenceHyper( [in] sequence< hyper > aSeq); |
| sequence< unsigned hyper > setSequenceUHyper( [in] sequence< unsigned hyper > aSeq); |
| sequence< float > setSequenceFloat( [in] sequence< float > aSeq); |
| sequence< double > setSequenceDouble( [in] sequence< double > aSeq); |
| sequence< TestEnum > setSequenceEnum( [in] sequence< TestEnum > aSeq); |
| sequence< string > setSequenceString( [in] sequence< string > aString); |
| sequence< com::sun::star::uno::XInterface > setSequenceXInterface( |
| [in] sequence< com::sun::star::uno::XInterface > aSeq); |
| sequence< any > setSequenceAny( [in] sequence< any > aSeq); |
| sequence< TestElement > setSequenceStruct( [in] sequence< TestElement > aSeq); |
| |
| sequence< sequence< long > > setDim2( [in] sequence< sequence< long > > aSeq); |
| sequence< sequence < sequence < long > > > setDim3( |
| [in] sequence< sequence < sequence < long > > > aSeq); |
| |
| void setSequencesInOut( [inout] sequence< boolean > aSeqBoolean, |
| [inout] sequence< char > aSeqChar, |
| [inout] sequence< byte > aSeqByte, |
| [inout] sequence< short > aSeqShort, |
| [inout] sequence< unsigned short> aSeqUShort, |
| [inout] sequence< long > aSeqLong, |
| [inout] sequence< unsigned long > aSeqULong, |
| [inout] sequence< hyper > aSeqHyper, |
| [inout] sequence< unsigned hyper > aSeqUHyper, |
| [inout] sequence< float > aSeqFloat, |
| [inout] sequence< double > aSeqDouble, |
| [inout] sequence< TestEnum > aSeqEnum, |
| [inout] sequence< string > aSeqString, |
| [inout] sequence< com::sun::star::uno::XInterface > aSeqXInterface, |
| [inout] sequence< any > aSeqAny, |
| [inout] sequence< sequence< long > > aSeqDim2, |
| [inout] sequence< sequence < sequence < long > > > aSeqDim3); |
| |
| void setSequencesOut( [out] sequence< boolean > aSeqBoolean, |
| [out] sequence< char > aSeqChar, |
| [out] sequence< byte > aSeqByte, |
| [out] sequence< short > aSeqShort, |
| [out] sequence< unsigned short> aSeqUShort, |
| [out] sequence< long > aSeqLong, |
| [out] sequence< unsigned long > aSeqULong, |
| [out] sequence< hyper > aSeqHyper, |
| [out] sequence< unsigned hyper > aSeqUHyper, |
| [out] sequence< float > aSeqFloat, |
| [out] sequence< double > aSeqDouble, |
| [out] sequence< TestEnum > aSeqEnum, |
| [out] sequence< string > aSeqString, |
| [out] sequence< com::sun::star::uno::XInterface > aSeqXInterface, |
| [out] sequence< any > aSeqAny, |
| [out] sequence< sequence< long > > aSeqDim2, |
| [out] sequence< sequence < sequence < long > > > aSeqDim3); |
| |
| |
| }; |
| //============================================================================= |
| |
| }; |
| }; |
| }; |
| }; |
| }; |
| |
| #endif |
