1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 #include <iostream>
25
26 #include "osl/interlck.h"
27 #include "rtl/ustring.hxx"
28 #include "uno/environment.hxx"
29 #include "uno/mapping.hxx"
30 #include "uno/dispatcher.h"
31
32 //#include "cascade_mappping.hxx"
33 #include "cppu/EnvDcp.hxx"
34
35
36 //#define LOG_CALLING_named_purpose_getMapping
37
38 //#define LOG_LIFECYLE_MediatorMapping
39 #ifdef LOG_LIFECYLE_MediatorMapping
40 # define LOG_LIFECYLE_MediatorMapping_emit(x) x
41
42 #else
43 # define LOG_LIFECYLE_MediatorMapping_emit(x)
44
45 #endif
46
47
48 using namespace com::sun::star;
49
50 class MediatorMapping : public uno_Mapping
51 {
52 oslInterlockedCount m_refCount;
53
54 uno::Mapping m_from2uno;
55 uno::Mapping m_uno2to;
56
57 uno::Environment m_from;
58 uno::Environment m_interm;
59 uno::Environment m_to;
60
61 public:
62 void acquire(void);
63 void release(void);
64
65 void mapInterface(void ** ppOut,
66 void * pInterface,
67 typelib_InterfaceTypeDescription * pInterfaceTypeDescr);
68 MediatorMapping(uno_Environment * pFrom,
69 uno_Environment * pInterm,
70 uno_Environment * pTo);
71 ~MediatorMapping();
72 };
73
74 extern "C" {
s_acquire(uno_Mapping * mapping)75 static void SAL_CALL s_acquire(uno_Mapping * mapping)
76 {
77 MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
78 pMediatorMapping->acquire();
79 }
80
s_release(uno_Mapping * mapping)81 static void SAL_CALL s_release(uno_Mapping * mapping)
82 {
83 MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
84 pMediatorMapping->release();
85 }
86
s_mapInterface(uno_Mapping * mapping,void ** ppOut,void * pInterface,typelib_InterfaceTypeDescription * pInterfaceTypeDescr)87 static void SAL_CALL s_mapInterface(
88 uno_Mapping * mapping,
89 void ** ppOut,
90 void * pInterface,
91 typelib_InterfaceTypeDescription * pInterfaceTypeDescr)
92 {
93 MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
94 pMediatorMapping->mapInterface(ppOut, pInterface, pInterfaceTypeDescr);
95 }
96 }
97
MediatorMapping(uno_Environment * pFrom,uno_Environment * pInterm,uno_Environment * pTo)98 MediatorMapping::MediatorMapping(uno_Environment * pFrom,
99 uno_Environment * pInterm,
100 uno_Environment * pTo)
101 : m_refCount(0),
102 m_from2uno(pFrom, pInterm),
103 m_uno2to (pInterm, pTo),
104 m_from (pFrom),
105 m_interm (pInterm),
106 m_to (pTo)
107 {
108 LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
109
110 if (!m_from2uno.get() || !m_uno2to.get())
111 abort();
112
113 uno_Mapping::acquire = s_acquire;
114 uno_Mapping::release = s_release;
115 uno_Mapping::mapInterface = s_mapInterface;
116 }
117
~MediatorMapping()118 MediatorMapping::~MediatorMapping()
119 {
120 LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
121 }
122
acquire(void)123 void MediatorMapping::acquire(void)
124 {
125 LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
126
127 osl_incrementInterlockedCount(&m_refCount);
128 }
129
release(void)130 void MediatorMapping::release(void)
131 {
132 LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
133
134 if (osl_decrementInterlockedCount(&m_refCount) == 0)
135 {
136 ::uno_revokeMapping(this);
137 }
138 }
139
s_mapInterface_v(va_list * pParam)140 extern "C" { static void s_mapInterface_v(va_list * pParam)
141 {
142 void ** ppOut = va_arg(*pParam, void **);
143 void * pInterface = va_arg(*pParam, void *);
144 typelib_InterfaceTypeDescription * pInterfaceTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *);
145 uno_Mapping * pMapping = va_arg(*pParam, uno_Mapping *);
146
147 pMapping->mapInterface(pMapping, ppOut, pInterface, pInterfaceTypeDescr);
148 }}
149
mapInterface(void ** ppOut,void * pInterface,typelib_InterfaceTypeDescription * pInterfaceTypeDescr)150 void MediatorMapping::mapInterface(
151 void ** ppOut,
152 void * pInterface,
153 typelib_InterfaceTypeDescription * pInterfaceTypeDescr)
154 {
155 if (*ppOut != 0)
156 {
157 uno_ExtEnvironment * env = m_to.get()->pExtEnv;
158 OSL_ASSERT( env != 0 );
159 env->releaseInterface( env, *ppOut );
160 *ppOut = NULL;
161 }
162
163 void * ret = 0;
164 uno_Interface * pUnoI = 0;
165
166 m_from.invoke(s_mapInterface_v, &pUnoI, pInterface, pInterfaceTypeDescr, m_from2uno.get());
167
168 m_uno2to.mapInterface(&ret, pUnoI, pInterfaceTypeDescr);
169
170 if (pUnoI)
171 m_interm.get()->pExtEnv->releaseInterface(m_interm.get()->pExtEnv, pUnoI);
172
173 *ppOut = ret;
174 }
175
s_MediatorMapping_free(uno_Mapping * pMapping)176 extern "C" { static void SAL_CALL s_MediatorMapping_free(uno_Mapping * pMapping)
177 SAL_THROW_EXTERN_C()
178 {
179 delete static_cast<MediatorMapping *>(pMapping);
180 }}
181
182
183
getPrefix(rtl::OUString const & str1,rtl::OUString const & str2)184 static rtl::OUString getPrefix(rtl::OUString const & str1, rtl::OUString const & str2)
185 {
186 sal_Int32 nIndex1 = 0;
187 sal_Int32 nIndex2 = 0;
188 sal_Int32 sim = 0;
189
190 rtl::OUString token1;
191 rtl::OUString token2;
192
193 do
194 {
195 token1 = str1.getToken(0, ':', nIndex1);
196 token2 = str2.getToken(0, ':', nIndex2);
197
198 if (token1.equals(token2))
199 sim += token1.getLength() + 1;
200 }
201 while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1.equals(token2));
202
203 rtl::OUString result;
204
205 if (sim)
206 result = str1.copy(0, sim - 1);
207
208 return result;
209 }
210
211 // rtl::OUString str1(RTL_CONSTASCII_USTRINGPARAM("abc:def:ghi"));
212 // rtl::OUString str2(RTL_CONSTASCII_USTRINGPARAM("abc:def"));
213 // rtl::OUString str3(RTL_CONSTASCII_USTRINGPARAM("abc"));
214 // rtl::OUString str4(RTL_CONSTASCII_USTRINGPARAM(""));
215
216 // rtl::OUString pref;
217
218 // pref = getPrefix(str1, str1);
219 // pref = getPrefix(str1, str2);
220 // pref = getPrefix(str1, str3);
221 // pref = getPrefix(str1, str4);
222
223 // pref = getPrefix(str2, str1);
224 // pref = getPrefix(str3, str1);
225 // pref = getPrefix(str4, str1);
226
227
getCascadeMapping(uno_Mapping ** ppMapping,uno_Environment * pFrom,uno_Environment * pTo,rtl_uString * pAddPurpose)228 void getCascadeMapping(uno_Mapping ** ppMapping,
229 uno_Environment * pFrom,
230 uno_Environment * pTo,
231 rtl_uString * pAddPurpose)
232 {
233 if (pAddPurpose && pAddPurpose->length)
234 return;
235
236 rtl::OUString uno_envType(RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO));
237
238 rtl::OUString from_envType = cppu::EnvDcp::getTypeName(pFrom->pTypeName);
239 rtl::OUString to_envType = cppu::EnvDcp::getTypeName(pTo->pTypeName);
240 rtl::OUString from_envPurpose = cppu::EnvDcp::getPurpose(pFrom->pTypeName);
241 rtl::OUString to_envPurpose = cppu::EnvDcp::getPurpose(pTo->pTypeName);
242
243 #ifdef LOG_CALLING_named_purpose_getMapping
244 rtl::OString s_from_name = rtl::OUStringToOString(pFrom->pTypeName, RTL_TEXTENCODING_ASCII_US);
245 rtl::OString s_to_name = rtl::OUStringToOString(pTo->pTypeName, RTL_TEXTENCODING_ASCII_US);
246
247 std::cerr << __FUNCTION__ << " - creating mediation ";
248 std::cerr << "pFrom: " << s_from_name.getStr();
249 std::cerr <<" pTo: " << s_to_name.getStr() << std::endl;
250 #endif
251
252 if (from_envPurpose == to_envPurpose) // gcc:bla => uno:bla
253 return;
254
255 // reaching this point means, we need a mediated mapping!!!
256 // we generall mediate via uno[:free]
257 uno_Environment * pInterm = NULL;
258
259 // chained uno -> uno
260 if (from_envType == uno_envType && to_envType == uno_envType)
261 {
262 rtl::OUString purpose = getPrefix(from_envPurpose, to_envPurpose);
263
264 rtl::OUString uno_envDcp = uno_envType;
265 uno_envDcp += purpose;
266
267 // direct mapping possible?
268 // uno:bla-->uno:bla:blubb
269 if (from_envPurpose.equals(purpose))
270 {
271 rtl::OUString rest = to_envPurpose.copy(purpose.getLength());
272
273 sal_Int32 index = rest.indexOf(':', 1);
274 if (index == -1)
275 {
276 uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData);
277 return;
278 }
279
280 uno_envDcp += rest.copy(0, index);
281 }
282 else if (to_envPurpose.equals(purpose))
283 {
284 rtl::OUString rest = from_envPurpose.copy(purpose.getLength());
285
286 sal_Int32 index = rest.indexOf(':', 1);
287 if (index == -1)
288 {
289 uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData);
290 return;
291 }
292
293 uno_envDcp += rest.copy(0, index);
294 }
295
296 uno_getEnvironment(&pInterm, uno_envDcp.pData, NULL);
297 }
298 else if (from_envType != uno_envType && to_envType == uno_envType) // <ANY> -> UNO ?
299 // mediate via uno:purpose(fromEnv)
300 {
301 rtl::OUString envDcp = uno_envType;
302
303 envDcp += from_envPurpose;
304 uno_getEnvironment(&pInterm, envDcp.pData, NULL);
305 }
306 else if (from_envType == uno_envType && to_envType != uno_envType) // UNO -> <ANY>?
307 // mediate via uno(context)
308 {
309 rtl::OUString envDcp = uno_envType;
310
311 envDcp += to_envPurpose;
312 uno_getEnvironment(&pInterm, envDcp.pData, NULL);
313 }
314 else // everything else
315 // mediate via uno:purpose
316 {
317 rtl::OUString purpose = getPrefix(from_envPurpose, to_envPurpose);
318
319 rtl::OUString uno_envDcp = uno_envType;
320 uno_envDcp += purpose;
321
322 uno_getEnvironment(&pInterm, uno_envDcp.pData, NULL);
323 }
324
325 uno_Mapping * pMapping = new MediatorMapping(pFrom, pInterm, pTo);
326 pInterm->release(pInterm);
327
328
329 pMapping->acquire(pMapping);
330
331 ::uno_registerMapping(&pMapping, s_MediatorMapping_free, pFrom, pTo, pAddPurpose);
332
333 if (*ppMapping)
334 (*ppMapping)->release(*ppMapping);
335
336 *ppMapping = pMapping;
337 }
338