← Back to branch summary

~thomas-voss/location-service/unify-source-code-formatting

« back to all changes in this revision

Viewing changes to src/location_service/com/ubuntu/location/engine.cpp

  • Committer: thomas-voss
  • Date: 2015-02-03 09:07:56 UTC
  • Revision ID: thomas.voss@canonical.com-20150203090756-czqdnnoqoi3uxd1v
Unify source code formatting.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/location_service/com/ubuntu/location/engine.cpp
32
32
 
33
33
cul::Engine::Engine(const cul::ProviderSelectionPolicy::Ptr& provider_selection_policy,
34
34
                    const cul::Settings::Ptr& settings)
35
 
          : provider_selection_policy(provider_selection_policy),
36
 
            settings(settings)
 
35
    : provider_selection_policy(provider_selection_policy),
 
36
      settings(settings)
37
37
{
38
 
    if (!provider_selection_policy) throw std::runtime_error
39
 
    {
40
 
        "Cannot construct an engine given a null ProviderSelectionPolicy"
41
 
    };
 
38
    if (!provider_selection_policy)
 
39
        throw std::runtime_error{
 
40
            "Cannot construct an engine given a null ProviderSelectionPolicy"};
42
41
 
43
 
    if (!settings) throw std::runtime_error
44
 
    {
45
 
        "Cannot construct an engine given a null Settings instance"
46
 
    };
 
42
    if (!settings)
 
43
        throw std::runtime_error{
 
44
            "Cannot construct an engine given a null Settings instance"};
47
45
 
48
46
    // Setup behavior in case of configuration changes.
49
47
    configuration.satellite_based_positioning_state.changed().connect([this](const SatelliteBasedPositioningState& state)
50
 
    {
 
48
                                                                      {
51
49
        for_each_provider([this, state](const Provider::Ptr& provider)
52
50
        {
53
51
            if (provider->requires(cul::Provider::Requirements::satellites))
65
63
                }
66
64
            }
67
65
        });
68
 
    });
 
66
                                                                      });
69
67
 
70
68
    configuration.engine_state.changed().connect([this](const Engine::Status& status)
71
 
    {
 
69
                                                 {
72
70
        for_each_provider([this, status](const Provider::Ptr& provider)
73
71
        {
74
72
            switch (status)
87
85
                break;
88
86
            }
89
87
        });
90
 
    });
 
88
                                                 });
91
89
 
92
90
    configuration.engine_state =
93
 
            settings->get_enum_for_key<Engine::Status>(
94
 
                Configuration::Keys::engine_state,
95
 
                Configuration::Defaults::engine_state);
 
91
        settings->get_enum_for_key<Engine::Status>(
 
92
            Configuration::Keys::engine_state,
 
93
            Configuration::Defaults::engine_state);
96
94
 
97
95
    configuration.satellite_based_positioning_state =
98
 
            settings->get_enum_for_key<SatelliteBasedPositioningState>(
99
 
                Configuration::Keys::satellite_based_positioning_state,
100
 
                Configuration::Defaults::satellite_based_positioning_state);
 
96
        settings->get_enum_for_key<SatelliteBasedPositioningState>(
 
97
            Configuration::Keys::satellite_based_positioning_state,
 
98
            Configuration::Defaults::satellite_based_positioning_state);
101
99
 
102
100
    configuration.wifi_and_cell_id_reporting_state =
103
 
            settings->get_enum_for_key<WifiAndCellIdReportingState>(
104
 
                Configuration::Keys::wifi_and_cell_id_reporting_state,
105
 
                Configuration::Defaults::wifi_and_cell_id_reporting_state);
 
101
        settings->get_enum_for_key<WifiAndCellIdReportingState>(
 
102
            Configuration::Keys::wifi_and_cell_id_reporting_state,
 
103
            Configuration::Defaults::wifi_and_cell_id_reporting_state);
106
104
 
107
105
    configuration.engine_state.changed().connect([this](const Engine::Status& status)
108
 
    {
 
106
                                                 {
109
107
        Engine::settings->set_enum_for_key<Engine::Status>(Configuration::Keys::engine_state, status);
110
 
    });
 
108
                                                 });
111
109
 
112
110
    configuration.satellite_based_positioning_state.changed().connect([this](SatelliteBasedPositioningState state)
113
 
    {
 
111
                                                                      {
114
112
        Engine::settings->set_enum_for_key<SatelliteBasedPositioningState>(Configuration::Keys::satellite_based_positioning_state, state);
115
 
    });
 
113
                                                                      });
116
114
 
117
115
    configuration.wifi_and_cell_id_reporting_state.changed().connect([this](WifiAndCellIdReportingState state)
118
 
    {
 
116
                                                                     {
119
117
        Engine::settings->set_enum_for_key<WifiAndCellIdReportingState>(Configuration::Keys::wifi_and_cell_id_reporting_state, state);
120
 
    });
 
118
                                                                     });
121
119
}
122
120
 
123
121
cul::Engine::~Engine()
135
133
        configuration.wifi_and_cell_id_reporting_state);
136
134
 
137
135
    for_each_provider([](const Provider::Ptr& provider)
138
 
    {
 
136
                      {
139
137
        provider->state_controller()->stop_position_updates();
140
138
        provider->state_controller()->stop_heading_updates();
141
139
        provider->state_controller()->stop_velocity_updates();
142
 
    });
 
140
                      });
143
141
}
144
142
 
145
143
cul::ProviderSelection cul::Engine::determine_provider_selection_for_criteria(const cul::Criteria& criteria)
167
165
    // We wire up changes in the engine's configuration to the respective slots
168
166
    // of the provider.
169
167
    auto cp = updates.reference_location.changed().connect([provider](const cul::Update<cul::Position>& pos)
170
 
    {
 
168
                                                           {
171
169
        provider->on_reference_location_updated(pos);
172
 
    });
 
170
                                                           });
173
171
 
174
172
    auto cv = updates.reference_velocity.changed().connect([provider](const cul::Update<cul::Velocity>& velocity)
175
 
    {
 
173
                                                           {
176
174
        provider->on_reference_velocity_updated(velocity);
177
 
    });
 
175
                                                           });
178
176
 
179
177
    auto ch = updates.reference_heading.changed().connect([provider](const cul::Update<cul::Heading>& heading)
180
 
    {
 
178
                                                          {
181
179
        provider->on_reference_heading_updated(heading);
182
 
    });
 
180
                                                          });
183
181
 
184
182
    auto cr = configuration.wifi_and_cell_id_reporting_state.changed().connect([provider](cul::WifiAndCellIdReportingState state)
185
 
    {
 
183
                                                                               {
186
184
        provider->on_wifi_and_cell_reporting_state_changed(state);
187
 
    });
 
185
                                                                               });
188
186
 
189
187
    // And do the reverse: Satellite visibility updates are funneled via the engine's configuration.
190
188
    auto cs = provider->updates().svs.connect([this](const cul::Update<std::set<cul::SpaceVehicle>>& src)
191
 
    {
 
189
                                              {
192
190
        updates.visible_space_vehicles.update([src](std::map<cul::SpaceVehicle::Key, cul::SpaceVehicle>& dest)
193
191
        {
194
192
            for(auto& sv : src.value)
198
196
 
199
197
            return true;
200
198
        });
201
 
    });
 
199
                                              });
202
200
 
203
201
    // We are a bit dumb and just take any position update as new reference.
204
202
    // We should come up with a better heuristic here.
205
203
    auto cpr = provider->updates().position.connect([this](const cul::Update<cul::Position>& src)
206
 
    {
 
204
                                                    {
207
205
        updates.reference_location = src;
208
 
    });
 
206
                                                    });
209
207
 
210
208
    std::lock_guard<std::mutex> lg(guard);
211
209
    providers.emplace(provider, std::move(ProviderConnections{cp, ch, cv, cr, cs, cpr}));
231
229
        {
232
230
            enumerator(provider.first);
233
231
        }
234
 
        catch(const std::exception& e)
 
232
        catch (const std::exception& e)
235
233
        {
236
234
            VLOG(1) << e.what();
237
235
        }
240
238
 
241
239
namespace std
242
240
{
243
 
template<>
 
241
template <>
244
242
struct hash<cul::Engine::Status>
245
243
{
246
244
    std::size_t operator()(const cul::Engine::Status& s) const
253
251
 
254
252
std::ostream& cul::operator<<(std::ostream& out, cul::Engine::Status state)
255
253
{
256
 
    static constexpr const char* the_unknown_state
257
 
    {
258
 
        "Engine::Status::unknown"
259
 
    };
 
254
    static constexpr const char* the_unknown_state{
 
255
        "Engine::Status::unknown"};
260
256
 
261
 
    static const std::unordered_map<location::Engine::Status, std::string> lut
262
 
    {
 
257
    static const std::unordered_map<location::Engine::Status, std::string> lut{
263
258
        {cul::Engine::Status::off, "Engine::Status::off"},
264
259
        {cul::Engine::Status::on, "Engine::Status::on"},
265
 
        {cul::Engine::Status::active, "Engine::Status::active"}
266
 
    };
 
260
        {cul::Engine::Status::active, "Engine::Status::active"}};
267
261
 
268
262
    auto it = lut.find(state);
269
263
    if (it != lut.end())
277
271
/** @brief Parses the status from the given stream. */
278
272
std::istream& cul::operator>>(std::istream& in, cul::Engine::Status& state)
279
273
{
280
 
    static const std::unordered_map<std::string, cul::Engine::Status> lut
281
 
    {
 
274
    static const std::unordered_map<std::string, cul::Engine::Status> lut{
282
275
        {"Engine::Status::off", cul::Engine::Status::off},
283
276
        {"Engine::Status::on", cul::Engine::Status::on},
284
 
        {"Engine::Status::active", cul::Engine::Status::active}
285
 
    };
 
277
        {"Engine::Status::active", cul::Engine::Status::active}};
286
278
 
287
 
    std::string s; in >> s;
 
279
    std::string s;
 
280
    in >> s;
288
281
    auto it = lut.find(s);
289
282
    if (it != lut.end())
290
283
        state = it->second;
291
 
    else throw std::runtime_error
292
 
    {
293
 
        "cul::operator>>(std::istream&, Engine::Status&): "
294
 
        "Could not resolve state " + s
295
 
    };
 
284
    else
 
285
        throw std::runtime_error{
 
286
            "cul::operator>>(std::istream&, Engine::Status&): "
 
287
            "Could not resolve state " +
 
288
            s};
296
289
 
297
290
    return in;
298
291
}