GCC Code Coverage Report

Directory: ./
File: src/hpp/core_idl/configuration_shooters.hh
Date: 2024-12-13 15:50:05
Exec Total Coverage
Lines: 0 50 0.0%
Branches: 0 94 0.0%
Line Branch Exec Source
1 #ifndef hpp_core_idl__configuration__shooters_hxx__
2 #define hpp_core_idl__configuration__shooters_hxx__
3
4 //
5 // Implemention of IDL interfaces in file /root/robotpkg/path/py-hpp-corbaserver/work/hpp-corbaserver-6.0.0/idl/hpp/core_idl/configuration_shooters.idl
6 //
7
8 #include <hpp/core_idl/configuration_shooters-fwd.hh>
9
10 #include <sstream>
11
12 #include <hpp/corbaserver/fwd.hh>
13 #include <hpp/corbaserver/conversions.hh>
14 #include "hpp/corbaserver/servant-base.hh"
15
16
17
18 //
19 // Implementational code for IDL interface hpp::core_idl::ConfigurationShooter
20 //
21 namespace hpp {
22
23 namespace core_impl {
24 template <typename _Base, typename _Storage>
25 ✗ ConfigurationShooterServant<_Base, _Storage>::ConfigurationShooterServant(::hpp::corbaServer::Server* server,
26 const _Storage& s)
27 ✗ : hpp::corbaServer::ServantBase<hpp::core::ConfigurationShooter, _Storage> (server, s)
28 {
29 // add extra constructor code here
30 }
31 template <typename _Base, typename _Storage>
32 ✗ ConfigurationShooterServant<_Base, _Storage>::~ConfigurationShooterServant()
33 {
34 // add extra destructor code here
35 }
36
37 // Methods corresponding to IDL attributes and operations
38
39 template <typename _Base, typename _Storage>
40 ✗ void ConfigurationShooterServant<_Base, _Storage>::deleteThis ()
41 {
42 try {
43 // automatically generated code.
44 ✗ _ServantBase::deleteThis();
45 ✗ } catch (const std::exception& e) {
46 ✗ throw ::hpp::Error (e.what());
47 }
48 }
49
50 template <typename _Base, typename _Storage>
51 ✗ ::CORBA::Boolean ConfigurationShooterServant<_Base, _Storage>::deleteIfExpired ()
52 {
53 try {
54 // automatically generated code.
55 ✗ return _ServantBase::deleteIfExpired();
56 ✗ } catch (const std::exception& e) {
57 ✗ throw ::hpp::Error (e.what());
58 }
59 }
60
61 template <typename _Base, typename _Storage>
62 ✗ void ConfigurationShooterServant<_Base, _Storage>::persistantStorage (::CORBA::Boolean persistant)
63 {
64 try {
65 // automatically generated code.
66 ✗ _ServantBase::persistantStorage(persistant);
67 ✗ } catch (const std::exception& e) {
68 ✗ throw ::hpp::Error (e.what());
69 }
70 }
71
72 template <typename _Base, typename _Storage>
73 ✗ hpp::floatSeq* ConfigurationShooterServant<_Base, _Storage>::shoot ()
74 {
75 try {
76 // automatically generated code.
77
78 ✗ hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->shoot ());
79
80 ✗ return __return__;
81 ✗ } catch (const std::exception& e) {
82 ✗ throw ::hpp::Error (e.what());
83 }
84 }
85
86 // End of implementational code
87 } // namespace core_impl
88
89 } // namespace hpp
90
91 //
92 // Implementational code for IDL interface hpp::core_idl::configuration_shooter::Gaussian
93 //
94 namespace hpp {
95
96 namespace core_impl {
97
98 namespace configuration_shooter {
99 template <typename _Base, typename _Storage>
100 ✗ GaussianServant<_Base, _Storage>::GaussianServant(::hpp::corbaServer::Server* server,
101 const _Storage& s)
102 ✗ : hpp::core_impl::ConfigurationShooterServant<_Base, _Storage> (server, s)
103 {
104 // add extra constructor code here
105 }
106 template <typename _Base, typename _Storage>
107 ✗ GaussianServant<_Base, _Storage>::~GaussianServant()
108 {
109 // add extra destructor code here
110 }
111
112 // Methods corresponding to IDL attributes and operations
113
114 template <typename _Base, typename _Storage>
115 ✗ void GaussianServant<_Base, _Storage>::setCenter (const hpp::floatSeq& c)
116 {
117 try {
118 // automatically generated code.
119 ✗ hpp::core::vector_t _c = hpp::corbaServer::floatSeqToVector (c);
120 ✗ (getT()->center (_c));
121
122
123 ✗ } catch (const std::exception& e) {
124 ✗ throw ::hpp::Error (e.what());
125 }
126 }
127
128 template <typename _Base, typename _Storage>
129 ✗ hpp::floatSeq* GaussianServant<_Base, _Storage>::getCenter ()
130 {
131 try {
132 // automatically generated code.
133
134 ✗ hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->center ());
135
136 ✗ return __return__;
137 ✗ } catch (const std::exception& e) {
138 ✗ throw ::hpp::Error (e.what());
139 }
140 }
141
142 template <typename _Base, typename _Storage>
143 ✗ hpp::floatSeq* GaussianServant<_Base, _Storage>::getSigmas ()
144 {
145 try {
146 // automatically generated code.
147
148 ✗ hpp::floatSeq* __return__ = hpp::corbaServer::vectorToFloatSeq (getT()->sigmas ());
149
150 ✗ return __return__;
151 ✗ } catch (const std::exception& e) {
152 ✗ throw ::hpp::Error (e.what());
153 }
154 }
155
156 template <typename _Base, typename _Storage>
157 ✗ void GaussianServant<_Base, _Storage>::setSigmas (const hpp::floatSeq& s)
158 {
159 try {
160 // automatically generated code.
161 ✗ hpp::core::vector_t _s = hpp::corbaServer::floatSeqToVector (s);
162 ✗ (getT()->sigmas (_s));
163
164
165 ✗ } catch (const std::exception& e) {
166 ✗ throw ::hpp::Error (e.what());
167 }
168 }
169
170 // End of implementational code
171 } // namespace configuration_shooter
172
173 } // namespace core_impl
174
175 } // namespace hpp
176
177 //
178 // Implementational code for IDL interface hpp::core_idl::configuration_shooter::UniformSeedable
179 //
180 namespace hpp {
181
182 namespace core_impl {
183
184 namespace configuration_shooter {
185 template <typename _Base, typename _Storage>
186 ✗ UniformSeedableServant<_Base, _Storage>::UniformSeedableServant(::hpp::corbaServer::Server* server,
187 const _Storage& s)
188 ✗ : hpp::core_impl::ConfigurationShooterServant<_Base, _Storage> (server, s)
189 {
190 // add extra constructor code here
191 }
192 template <typename _Base, typename _Storage>
193 ✗ UniformSeedableServant<_Base, _Storage>::~UniformSeedableServant()
194 {
195 // add extra destructor code here
196 }
197
198 // Methods corresponding to IDL attributes and operations
199
200 template <typename _Base, typename _Storage>
201 ✗ void UniformSeedableServant<_Base, _Storage>::seed (::CORBA::Long seed_)
202 {
203 try {
204 // automatically generated code.
205
206 ✗ (getT()->seed (seed_));
207
208
209 ✗ } catch (const std::exception& e) {
210 ✗ throw ::hpp::Error (e.what());
211 }
212 }
213
214 // End of implementational code
215 } // namespace configuration_shooter
216
217 } // namespace core_impl
218
219 } // namespace hpp
220
221
222
223
224
225 #endif // hpp_core_idl__configuration__shooters_hxx__
226
227