← Back to branch summary

~mterry/unity-scopes-api/snap-root

« back to all changes in this revision

Viewing changes to src/scopes/internal/RangeInputFilterImpl.cpp

  • Committer: CI Train Bot
  • Author(s): Pawel Stolowski
  • Date: 2016-03-17 22:35:14 UTC
  • mfrom: (261.1.54 staging)
  • Revision ID: ci-train-bot@canonical.com-20160317223514-dxndlxrg5jbi2oqk
Merged devel: use abigail for abi-compoliance checker (disabled for now due o abigail bugs); filters API changes.
Approved by: Michi Henning, PS Jenkins bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/scopes/internal/RangeInputFilterImpl.cpp
1
1
/*
2
 
 * Copyright (C) 2014 Canonical Ltd
 
2
 * Copyright (C) 2015 Canonical Ltd
3
3
 *
4
4
 * This program is free software: you can redistribute it and/or modify
5
5
 * it under the terms of the GNU Lesser General Public License version 3 as
31
31
namespace internal
32
32
{
33
33
 
34
 
RangeInputFilterImpl::RangeInputFilterImpl(std::string const& id, std::string const& start_label, std::string const& end_label, std::string const& unit_label)
 
34
RangeInputFilterImpl::RangeInputFilterImpl(std::string const& id,
 
35
        Variant const& default_start_value, Variant const& default_end_value,
 
36
        std::string const& start_prefix_label, std::string const& start_postfix_label,
 
37
        std::string const& central_label,
 
38
        std::string const& end_prefix_label, std::string const& end_postfix_label)
35
39
    : FilterBaseImpl(id),
36
 
      start_label_(start_label),
37
 
      end_label_(end_label),
38
 
      unit_label_(unit_label)
 
40
      default_start_value_(default_start_value),
 
41
      default_end_value_(default_end_value),
 
42
      start_prefix_label_(start_prefix_label),
 
43
      start_postfix_label_(start_postfix_label),
 
44
      end_prefix_label_(end_prefix_label),
 
45
      end_postfix_label_(end_postfix_label),
 
46
      central_label_(central_label)
39
47
{
40
48
}
41
49
 
52
60
    return filter;
53
61
}
54
62
 
55
 
std::string RangeInputFilterImpl::start_label() const
56
 
{
57
 
    return start_label_;
58
 
}
59
 
 
60
 
std::string RangeInputFilterImpl::end_label() const
61
 
{
62
 
    return end_label_;
63
 
}
64
 
 
65
 
std::string RangeInputFilterImpl::unit_label() const
66
 
{
67
 
    return unit_label_;
 
63
std::string RangeInputFilterImpl::start_prefix_label() const
 
64
{
 
65
    return start_prefix_label_;
 
66
}
 
67
 
 
68
std::string RangeInputFilterImpl::start_postfix_label() const
 
69
{
 
70
    return start_postfix_label_;
 
71
}
 
72
 
 
73
std::string RangeInputFilterImpl::end_prefix_label() const
 
74
{
 
75
    return end_prefix_label_;
 
76
}
 
77
 
 
78
std::string RangeInputFilterImpl::end_postfix_label() const
 
79
{
 
80
    return end_postfix_label_;
 
81
}
 
82
 
 
83
std::string RangeInputFilterImpl::central_label() const
 
84
{
 
85
    return central_label_;
 
86
}
 
87
 
 
88
Variant RangeInputFilterImpl::default_start_value() const
 
89
{
 
90
    return default_start_value_;
 
91
}
 
92
 
 
93
Variant RangeInputFilterImpl::default_end_value() const
 
94
{
 
95
    return default_end_value_;
68
96
}
69
97
 
70
98
bool RangeInputFilterImpl::has_value(FilterState const& filter_state, unsigned int index) const
114
142
        {
115
143
        }
116
144
    }
117
 
    throw unity::scopes::NotFoundException("RangeInputFilterImpl::get_value(): invalid index for filter '" + id() + "'",
 
145
    throw NotFoundException("RangeInputFilterImpl::get_value(): invalid index for filter '" + id() + "'",
118
146
                                           std::to_string(index));
119
147
}
120
148
 
121
149
double RangeInputFilterImpl::start_value(FilterState const& filter_state) const
122
150
{
123
 
    return get_value(filter_state, 0);
 
151
    try
 
152
    {
 
153
        return get_value(filter_state, 0);
 
154
    }
 
155
    catch (unity::scopes::NotFoundException const&)
 
156
    {
 
157
        if (default_start_value_.which() == Variant::Type::Double)
 
158
        {
 
159
            return default_start_value_.get_double();
 
160
        }
 
161
        if (default_end_value_.which() == Variant::Type::Int)
 
162
        {
 
163
            return default_start_value_.get_int();
 
164
        }
 
165
    }
 
166
    throw NotFoundException("RangeInputFilterImpl::start_value(): start value is not set for filter", id());
124
167
}
125
168
 
126
169
double RangeInputFilterImpl::end_value(FilterState const& filter_state) const
127
170
{
128
 
    return get_value(filter_state, 1);
 
171
    try
 
172
    {
 
173
        return get_value(filter_state, 1);
 
174
    }
 
175
    catch (unity::scopes::NotFoundException const&)
 
176
    {
 
177
        if (default_end_value_.which() == Variant::Type::Double)
 
178
        {
 
179
            return default_end_value_.get_double();
 
180
        }
 
181
        if (default_end_value_.which() == Variant::Type::Int)
 
182
        {
 
183
            return default_end_value_.get_int();
 
184
        }
 
185
    }
 
186
    throw NotFoundException("RangeInputFilterImpl::end_value(): end value is not set for filter", id());
129
187
}
130
188
 
131
189
void RangeInputFilterImpl::check_type(Variant const& val, std::string const& filter_id, std::string const& varname)
132
190
{
133
191
    if (val.which() == Variant::Type::Int || val.which() == Variant::Type::Double || val.is_null())
 
192
    {
134
193
        return;
 
194
    }
135
195
    std::stringstream err;
136
196
    err << "RangeInputFilterImpl::check_type(): Invalid variant type for " << varname << ", filter '" << filter_id << "'";
137
197
    throw unity::InvalidArgumentException(err.str());
178
238
 
179
239
void RangeInputFilterImpl::serialize(VariantMap& var) const
180
240
{
181
 
    var["start_label"] = start_label_;
182
 
    var["end_label"] = end_label_;
183
 
    var["unit_label"] = unit_label_;
 
241
    var["default_start_value"] = default_start_value_;
 
242
    var["default_end_value"] = default_end_value_;
 
243
    var["start_prefix_label"] = start_prefix_label_;
 
244
    var["start_postfix_label"] = start_postfix_label_;
 
245
    var["end_prefix_label"] = end_prefix_label_;
 
246
    var["end_postfix_label"] = end_postfix_label_;
 
247
    var["central_label"] = central_label_;
184
248
}
185
249
 
186
250
void RangeInputFilterImpl::deserialize(VariantMap const& var)
187
251
{
188
 
    auto it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "start_label");
189
 
    start_label_ = it->second.get_string();
190
 
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "end_label");
191
 
    end_label_ = it->second.get_string();
192
 
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "unit_label");
193
 
    unit_label_ = it->second.get_string();
 
252
    auto it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "start_prefix_label");
 
253
    start_prefix_label_ = it->second.get_string();
 
254
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "start_postfix_label");
 
255
    start_postfix_label_ = it->second.get_string();
 
256
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "end_prefix_label");
 
257
    end_prefix_label_ = it->second.get_string();
 
258
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "end_postfix_label");
 
259
    end_postfix_label_ = it->second.get_string();
 
260
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "central_label");
 
261
    central_label_ = it->second.get_string();
 
262
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "default_start_value");
 
263
    default_start_value_ = it->second;
 
264
    it = find_or_throw("RangeInputFilterImpl::deserialize()", var, "default_end_value");
 
265
    default_end_value_ = it->second;
194
266
}
195
267
 
196
268
void RangeInputFilterImpl::validate_display_hints() const