LibreOffice Module codemaker (master) 1
dependencies.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include <sal/config.h>
21
22#include <cassert>
23#include <utility>
24#include <vector>
25
26#include <codemaker/global.hxx>
27#include <codemaker/typemanager.hxx>
28#include <codemaker/unotype.hxx>
29
30#include <rtl/ref.hxx>
31#include <rtl/string.hxx>
32#include <rtl/ustring.hxx>
33#include <sal/types.h>
34#include <unoidl/unoidl.hxx>
35
36#include "dependencies.hxx"
37
38namespace codemaker::cppumaker {
39
40Dependencies::Dependencies(
41 rtl::Reference< TypeManager > const & manager, OUString const & name):
42 m_manager(manager), m_voidDependency(false), m_booleanDependency(false),
43 m_byteDependency(false), m_shortDependency(false),
44 m_unsignedShortDependency(false), m_longDependency(false),
45 m_unsignedLongDependency(false), m_hyperDependency(false),
46 m_unsignedHyperDependency(false), m_charDependency(false),
47 m_stringDependency(false), m_typeDependency(false), m_anyDependency(false),
48 m_sequenceDependency(false)
49{
50 assert(manager.is());
51 rtl::Reference< unoidl::Entity > ent;
52 switch (m_manager->getSort(name, &ent)) {
53 case UnoType::Sort::Enum:
54 break;
55 case UnoType::Sort::PlainStruct:
56 {
57 rtl::Reference< unoidl::PlainStructTypeEntity > ent2(
58 static_cast< unoidl::PlainStructTypeEntity * >(ent.get()));
59 if (!ent2->getDirectBase().isEmpty()) {
60 insert(ent2->getDirectBase(), KIND_NORMAL);
61 }
62 for (const unoidl::PlainStructTypeEntity::Member& member : ent2->getDirectMembers())
63 {
64 insert(member.type, KIND_NORMAL);
65 }
66 break;
67 }
68 case UnoType::Sort::PolymorphicStructTemplate:
69 {
70 rtl::Reference< unoidl::PolymorphicStructTypeTemplateEntity > ent2(
71 static_cast< unoidl::PolymorphicStructTypeTemplateEntity * >(
72 ent.get()));
73 for (const unoidl::PolymorphicStructTypeTemplateEntity::Member& member : ent2->getMembers())
74 {
75 if (!member.parameterized) {
76 insert(member.type, KIND_NORMAL);
77 }
78 }
79 break;
80 }
81 case UnoType::Sort::Exception:
82 {
83 rtl::Reference< unoidl::ExceptionTypeEntity > ent2(
84 static_cast< unoidl::ExceptionTypeEntity * >(ent.get()));
85 if (!ent2->getDirectBase().isEmpty()) {
86 insert(ent2->getDirectBase(), KIND_NORMAL);
87 }
88 for (const unoidl::ExceptionTypeEntity::Member& member : ent2->getDirectMembers())
89 {
90 insert(member.type, KIND_NORMAL);
91 }
92 break;
93 }
94 case UnoType::Sort::Interface:
95 {
96 rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
97 static_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
98 for (const unoidl::AnnotatedReference& ar : ent2->getDirectMandatoryBases())
99 {
100 insert(ar.name, KIND_BASE);
101 }
102 if (!(ent2->getDirectAttributes().empty()
103 && ent2->getDirectMethods().empty()))
104 {
105 insert(u"com.sun.star.uno.RuntimeException", KIND_EXCEPTION);
106 }
107 for (const unoidl::InterfaceTypeEntity::Attribute& attr : ent2->getDirectAttributes())
108 {
109 insert(attr.type, KIND_NORMAL);
110 for (const OUString& ex : attr.getExceptions)
111 {
112 insert(ex, KIND_EXCEPTION);
113 }
114 for (const OUString& ex : attr.setExceptions)
115 {
116 insert(ex, KIND_EXCEPTION);
117 }
118 }
119 for (const unoidl::InterfaceTypeEntity::Method& method : ent2->getDirectMethods())
120 {
121 insert(method.returnType, KIND_NORMAL);
122 for (const unoidl::InterfaceTypeEntity::Method::Parameter& param : method.parameters)
123 {
124 insert(param.type, KIND_NORMAL);
125 }
126 for (const OUString& ex : method.exceptions)
127 {
128 insert(ex, KIND_EXCEPTION);
129 }
130 }
131 break;
132 }
133 case UnoType::Sort::Typedef:
134 insert(
135 static_cast< unoidl::TypedefEntity * >(ent.get())->getType(),
136 KIND_NORMAL);
137 break;
138 case UnoType::Sort::ConstantGroup:
139 {
140 rtl::Reference< unoidl::ConstantGroupEntity > ent2(
141 static_cast< unoidl::ConstantGroupEntity * >(ent.get()));
142 for (const unoidl::ConstantGroupEntity::Member& member : ent2->getMembers())
143 {
144 switch (member.value.type) {
145 case unoidl::ConstantValue::TYPE_BOOLEAN:
146 m_booleanDependency = true;
147 break;
148 case unoidl::ConstantValue::TYPE_BYTE:
149 m_byteDependency = true;
150 break;
151 case unoidl::ConstantValue::TYPE_SHORT:
152 m_shortDependency = true;
153 break;
154 case unoidl::ConstantValue::TYPE_UNSIGNED_SHORT:
155 m_unsignedShortDependency = true;
156 break;
157 case unoidl::ConstantValue::TYPE_LONG:
158 m_longDependency = true;
159 break;
160 case unoidl::ConstantValue::TYPE_UNSIGNED_LONG:
161 m_unsignedLongDependency = true;
162 break;
163 case unoidl::ConstantValue::TYPE_HYPER:
164 m_hyperDependency = true;
165 break;
166 case unoidl::ConstantValue::TYPE_UNSIGNED_HYPER:
167 m_unsignedHyperDependency = true;
168 break;
169 case unoidl::ConstantValue::TYPE_FLOAT:
170 break;
171 case unoidl::ConstantValue::TYPE_DOUBLE:
172 break;
173 }
174 }
175 break;
176 }
177 case UnoType::Sort::SingleInterfaceBasedService:
178 {
179 rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > ent2(
180 static_cast< unoidl::SingleInterfaceBasedServiceEntity * >(
181 ent.get()));
182 if (!ent2->getConstructors().empty()) {
183 insert(ent2->getBase(), KIND_NORMAL);
184 }
185 for (const unoidl::SingleInterfaceBasedServiceEntity::Constructor& cons : ent2->getConstructors())
186 {
187 for (const unoidl::SingleInterfaceBasedServiceEntity::Constructor::Parameter& param
188 : cons.parameters)
189 {
190 insert(param.type, KIND_NORMAL);
191 if (param.rest) {
192 m_sequenceDependency = true;
193 }
194 }
195 for (const OUString& ex : cons.exceptions)
196 {
197 insert(ex, KIND_EXCEPTION);
198 }
199 }
200 break;
201 }
202 case UnoType::Sort::InterfaceBasedSingleton:
203 insert(
204 static_cast< unoidl::InterfaceBasedSingletonEntity * >(ent.get())->
205 getBase(),
206 KIND_NORMAL);
207 break;
208 default:
209 assert(false); // this cannot happen
210 }
211}
212
213Dependencies::~Dependencies() {}
214
215void Dependencies::insert(std::u16string_view name, Kind kind) {
216 sal_Int32 k;
217 std::vector< OString > args;
218 OUString n(b2u(UnoType::decompose(u2b(name), &k, &args)));
219 if (k != 0) {
220 m_sequenceDependency = true;
221 }
222 switch (m_manager->getSort(n)) {
223 case UnoType::Sort::Void:
224 m_voidDependency = true;
225 break;
226 case UnoType::Sort::Boolean:
227 m_booleanDependency = true;
228 break;
229 case UnoType::Sort::Byte:
230 m_byteDependency = true;
231 break;
232 case UnoType::Sort::Short:
233 m_shortDependency = true;
234 break;
235 case UnoType::Sort::UnsignedShort:
236 m_unsignedShortDependency = true;
237 break;
238 case UnoType::Sort::Long:
239 m_longDependency = true;
240 break;
241 case UnoType::Sort::UnsignedLong:
242 m_unsignedLongDependency = true;
243 break;
244 case UnoType::Sort::Hyper:
245 m_hyperDependency = true;
246 break;
247 case UnoType::Sort::UnsignedHyper:
248 m_unsignedHyperDependency = true;
249 break;
250 case UnoType::Sort::Float:
251 break;
252 case UnoType::Sort::Double:
253 break;
254 case UnoType::Sort::Char:
255 m_charDependency = true;
256 break;
257 case UnoType::Sort::String:
258 m_stringDependency = true;
259 break;
260 case UnoType::Sort::Type:
261 m_typeDependency = true;
262 break;
263 case UnoType::Sort::Any:
264 m_anyDependency = true;
265 break;
266 case UnoType::Sort::PolymorphicStructTemplate:
267 for (const OString& arg : args)
268 {
269 insert(b2u(arg), KIND_NORMAL);
270 }
271 [[fallthrough]];
272 case UnoType::Sort::Sequence:
273 case UnoType::Sort::Enum:
274 case UnoType::Sort::PlainStruct:
275 case UnoType::Sort::Exception:
276 case UnoType::Sort::Interface:
277 case UnoType::Sort::Typedef:
278 {
279 std::pair< Map::iterator, bool > i(
280 m_map.emplace(n, kind));
281 if (!i.second && kind == KIND_BASE) {
282 assert(i.first->second != KIND_EXCEPTION);
283 i.first->second = KIND_BASE;
284 }
285 break;
286 }
287 default:
288 throw CannotDumpException(
289 OUString::Concat("unexpected type \"") + name
290 + "\" in call to codemaker::cppumaker::Dependencies::Dependencies");
291 }
292}
293
294}
295
296/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
codemaker::cppumaker::Dependencies::m_manager
rtl::Reference< TypeManager > m_manager
Definition: dependencies.hxx:106
codemaker::cppumaker::Dependencies::Dependencies
Dependencies(rtl::Reference< TypeManager > const &manager, OUString const &name)
Constructs the dependencies for a given entity.
Definition: dependencies.cxx:40
codemaker::cppumaker::Dependencies::Kind
Kind
Flags to distinguish whether one entity depends on another entity because the second is a direct base...
Definition: dependencies.hxx:48
codemaker::cppumaker::Dependencies::insert
void insert(std::u16string_view name, Kind kind)
Definition: dependencies.cxx:215
unoidl::TypedefEntity::getType
const OUString & getType() const
manager
rtl::Reference< ParseManager > manager
u
float u
name
const char * name
n
sal_Int64 n
codemaker::UnoType::decompose
rtl::OString decompose(rtl::OString const &type, sal_Int32 *rank=nullptr, std::vector< rtl::OString > *arguments=nullptr)
Decomposes a UNO type name or UNO type registry name.
i
int i
args
args
b2u
OUString b2u(std::string_view s)
Definition: typemanager.hxx:71
u2b
OString u2b(std::u16string_view s)
Definition: typemanager.hxx:67
Generated on Sun Jul 30 2023 04:33:53 for LibreOffice Module codemaker (master) by doxygen 1.9.3