1 /*
2  *  Copyright (C) 2005-2018 Team Kodi
3  *  This file is part of Kodi - https://kodi.tv
4  *
5  *  SPDX-License-Identifier: GPL-2.0-or-later
6  *  See LICENSES/README.md for more information.
7  */
8 
9 #include "Temperature.h"
10 
11 #include "utils/Archive.h"
12 #include "utils/StringUtils.h"
13 
14 #include <assert.h>
15 
CTemperature()16 CTemperature::CTemperature()
17 {
18   m_value=0.0f;
19   m_valid=false;
20 }
21 
CTemperature(const CTemperature & temperature)22 CTemperature::CTemperature(const CTemperature& temperature)
23 {
24   m_value=temperature.m_value;
25   m_valid=temperature.m_valid;
26 }
27 
CTemperature(double value)28 CTemperature::CTemperature(double value)
29 {
30   m_value=value;
31   m_valid=true;
32 }
33 
operator >(const CTemperature & right) const34 bool CTemperature::operator >(const CTemperature& right) const
35 {
36   assert(IsValid());
37   assert(right.IsValid());
38 
39   if (!IsValid() || !right.IsValid())
40     return false;
41 
42   if (this==&right)
43     return false;
44 
45   return (m_value>right.m_value);
46 }
47 
operator >=(const CTemperature & right) const48 bool CTemperature::operator >=(const CTemperature& right) const
49 {
50   return operator >(right) || operator ==(right);
51 }
52 
operator <(const CTemperature & right) const53 bool CTemperature::operator <(const CTemperature& right) const
54 {
55   assert(IsValid());
56   assert(right.IsValid());
57 
58   if (!IsValid() || !right.IsValid())
59     return false;
60 
61   if (this==&right)
62     return false;
63 
64   return (m_value<right.m_value);
65 }
66 
operator <=(const CTemperature & right) const67 bool CTemperature::operator <=(const CTemperature& right) const
68 {
69   return operator <(right) || operator ==(right);
70 }
71 
operator ==(const CTemperature & right) const72 bool CTemperature::operator ==(const CTemperature& right) const
73 {
74   assert(IsValid());
75   assert(right.IsValid());
76 
77   if (!IsValid() || !right.IsValid())
78     return false;
79 
80   if (this==&right)
81     return true;
82 
83   return (m_value==right.m_value);
84 }
85 
operator !=(const CTemperature & right) const86 bool CTemperature::operator !=(const CTemperature& right) const
87 {
88   return !operator ==(right.m_value);
89 }
90 
operator =(const CTemperature & right)91 CTemperature& CTemperature::operator =(const CTemperature& right)
92 {
93   m_valid=right.m_valid;
94   m_value=right.m_value;
95   return *this;
96 }
97 
operator +=(const CTemperature & right)98 const CTemperature& CTemperature::operator +=(const CTemperature& right)
99 {
100   assert(IsValid());
101   assert(right.IsValid());
102 
103   m_value+=right.m_value;
104   return *this;
105 }
106 
operator -=(const CTemperature & right)107 const CTemperature& CTemperature::operator -=(const CTemperature& right)
108 {
109   assert(IsValid());
110   assert(right.IsValid());
111 
112   m_value-=right.m_value;
113   return *this;
114 }
115 
operator *=(const CTemperature & right)116 const CTemperature& CTemperature::operator *=(const CTemperature& right)
117 {
118   assert(IsValid());
119   assert(right.IsValid());
120 
121   m_value*=right.m_value;
122   return *this;
123 }
124 
operator /=(const CTemperature & right)125 const CTemperature& CTemperature::operator /=(const CTemperature& right)
126 {
127   assert(IsValid());
128   assert(right.IsValid());
129 
130   m_value/=right.m_value;
131   return *this;
132 }
133 
operator +(const CTemperature & right) const134 CTemperature CTemperature::operator +(const CTemperature& right) const
135 {
136   assert(IsValid());
137   assert(right.IsValid());
138 
139   CTemperature temp(*this);
140 
141   if (!IsValid() || !right.IsValid())
142     temp.SetValid(false);
143   else
144     temp.m_value+=right.m_value;
145 
146   return temp;
147 }
148 
operator -(const CTemperature & right) const149 CTemperature CTemperature::operator -(const CTemperature& right) const
150 {
151   assert(IsValid());
152   assert(right.IsValid());
153 
154   CTemperature temp(*this);
155   if (!IsValid() || !right.IsValid())
156     temp.SetValid(false);
157   else
158     temp.m_value-=right.m_value;
159 
160   return temp;
161 }
162 
operator *(const CTemperature & right) const163 CTemperature CTemperature::operator *(const CTemperature& right) const
164 {
165   assert(IsValid());
166   assert(right.IsValid());
167 
168   CTemperature temp(*this);
169   if (!IsValid() || !right.IsValid())
170     temp.SetValid(false);
171   else
172     temp.m_value*=right.m_value;
173   return temp;
174 }
175 
operator /(const CTemperature & right) const176 CTemperature CTemperature::operator /(const CTemperature& right) const
177 {
178   assert(IsValid());
179   assert(right.IsValid());
180 
181   CTemperature temp(*this);
182   if (!IsValid() || !right.IsValid())
183     temp.SetValid(false);
184   else
185     temp.m_value/=right.m_value;
186   return temp;
187 }
188 
operator ++()189 CTemperature& CTemperature::operator ++()
190 {
191   assert(IsValid());
192 
193   m_value++;
194   return *this;
195 }
196 
operator --()197 CTemperature& CTemperature::operator --()
198 {
199   assert(IsValid());
200 
201   m_value--;
202   return *this;
203 }
204 
operator ++(int)205 CTemperature CTemperature::operator ++(int)
206 {
207   assert(IsValid());
208 
209   CTemperature temp(*this);
210   m_value++;
211   return temp;
212 }
213 
operator --(int)214 CTemperature CTemperature::operator --(int)
215 {
216   assert(IsValid());
217 
218   CTemperature temp(*this);
219   m_value--;
220   return temp;
221 }
222 
operator >(double right) const223 bool CTemperature::operator >(double right) const
224 {
225   assert(IsValid());
226 
227   if (!IsValid())
228     return false;
229 
230   return (m_value>right);
231 }
232 
operator >=(double right) const233 bool CTemperature::operator >=(double right) const
234 {
235   return operator >(right) || operator ==(right);
236 }
237 
operator <(double right) const238 bool CTemperature::operator <(double right) const
239 {
240   assert(IsValid());
241 
242   if (!IsValid())
243     return false;
244 
245   return (m_value<right);
246 }
247 
operator <=(double right) const248 bool CTemperature::operator <=(double right) const
249 {
250   return operator <(right) || operator ==(right);
251 }
252 
operator ==(double right) const253 bool CTemperature::operator ==(double right) const
254 {
255   if (!IsValid())
256     return false;
257 
258   return (m_value==right);
259 }
260 
operator !=(double right) const261 bool CTemperature::operator !=(double right) const
262 {
263   return !operator ==(right);
264 }
265 
operator +=(double right)266 const CTemperature& CTemperature::operator +=(double right)
267 {
268   assert(IsValid());
269 
270   m_value+=right;
271   return *this;
272 }
273 
operator -=(double right)274 const CTemperature& CTemperature::operator -=(double right)
275 {
276   assert(IsValid());
277 
278   m_value-=right;
279   return *this;
280 }
281 
operator *=(double right)282 const CTemperature& CTemperature::operator *=(double right)
283 {
284   assert(IsValid());
285 
286   m_value*=right;
287   return *this;
288 }
289 
operator /=(double right)290 const CTemperature& CTemperature::operator /=(double right)
291 {
292   assert(IsValid());
293 
294   m_value/=right;
295   return *this;
296 }
297 
operator +(double right) const298 CTemperature CTemperature::operator +(double right) const
299 {
300   assert(IsValid());
301 
302   CTemperature temp(*this);
303   temp.m_value+=right;
304   return temp;
305 }
306 
operator -(double right) const307 CTemperature CTemperature::operator -(double right) const
308 {
309   assert(IsValid());
310 
311   CTemperature temp(*this);
312   temp.m_value-=right;
313   return temp;
314 }
315 
operator *(double right) const316 CTemperature CTemperature::operator *(double right) const
317 {
318   assert(IsValid());
319 
320   CTemperature temp(*this);
321   temp.m_value*=right;
322   return temp;
323 }
324 
operator /(double right) const325 CTemperature CTemperature::operator /(double right) const
326 {
327   assert(IsValid());
328 
329   CTemperature temp(*this);
330   temp.m_value/=right;
331   return temp;
332 }
333 
CreateFromFahrenheit(double value)334 CTemperature CTemperature::CreateFromFahrenheit(double value)
335 {
336   return CTemperature(value);
337 }
338 
CreateFromReaumur(double value)339 CTemperature CTemperature::CreateFromReaumur(double value)
340 {
341   return CTemperature(value*2.25f+32.0f);
342 }
343 
CreateFromRankine(double value)344 CTemperature CTemperature::CreateFromRankine(double value)
345 {
346   return CTemperature(value-459.67f);
347 }
348 
CreateFromRomer(double value)349 CTemperature CTemperature::CreateFromRomer(double value)
350 {
351   return CTemperature((value-7.5f)*24.0f/7.0f+32.0f);
352 }
353 
CreateFromDelisle(double value)354 CTemperature CTemperature::CreateFromDelisle(double value)
355 {
356   CTemperature temp(212.0f - value * 1.2f);
357   return temp;
358 }
359 
CreateFromNewton(double value)360 CTemperature CTemperature::CreateFromNewton(double value)
361 {
362   return CTemperature(value*60.0f/11.0f+32.0f);
363 }
364 
CreateFromCelsius(double value)365 CTemperature CTemperature::CreateFromCelsius(double value)
366 {
367   return CTemperature(value*1.8f+32.0f);
368 }
369 
CreateFromKelvin(double value)370 CTemperature CTemperature::CreateFromKelvin(double value)
371 {
372   return CTemperature((value - 273.15) * 1.8 + 32.0);
373 }
374 
Archive(CArchive & ar)375 void CTemperature::Archive(CArchive& ar)
376 {
377   if (ar.IsStoring())
378   {
379     ar<<m_value;
380     ar<<m_valid;
381   }
382   else
383   {
384     ar>>m_value;
385     ar>>m_valid;
386   }
387 }
388 
IsValid() const389 bool CTemperature::IsValid() const
390 {
391   return m_valid;
392 }
393 
ToFahrenheit() const394 double CTemperature::ToFahrenheit() const
395 {
396   return m_value;
397 }
398 
ToKelvin() const399 double CTemperature::ToKelvin() const
400 {
401   return (m_value+459.67F)/1.8f;
402 }
403 
ToCelsius() const404 double CTemperature::ToCelsius() const
405 {
406   return (m_value-32.0f)/1.8f;
407 }
408 
ToReaumur() const409 double CTemperature::ToReaumur() const
410 {
411   return (m_value-32.0f)/2.25f;
412 }
413 
ToRankine() const414 double CTemperature::ToRankine() const
415 {
416   return m_value+459.67f;
417 }
418 
ToRomer() const419 double CTemperature::ToRomer() const
420 {
421   return (m_value-32.0f)*7.0f/24.0f+7.5f;
422 }
423 
ToDelisle() const424 double CTemperature::ToDelisle() const
425 {
426   return (212.f-m_value)*5.0f/6.0f;
427 }
428 
ToNewton() const429 double CTemperature::ToNewton() const
430 {
431   return (m_value-32.0f)*11.0f/60.0f;
432 }
433 
To(Unit temperatureUnit) const434 double CTemperature::To(Unit temperatureUnit) const
435 {
436   if (!IsValid())
437     return 0;
438 
439   double value = 0.0;
440 
441   switch (temperatureUnit)
442   {
443   case UnitFahrenheit:
444     value=ToFahrenheit();
445     break;
446   case UnitKelvin:
447     value=ToKelvin();
448     break;
449   case UnitCelsius:
450     value=ToCelsius();
451     break;
452   case UnitReaumur:
453     value=ToReaumur();
454     break;
455   case UnitRankine:
456     value=ToRankine();
457     break;
458   case UnitRomer:
459     value=ToRomer();
460     break;
461   case UnitDelisle:
462     value=ToDelisle();
463     break;
464   case UnitNewton:
465     value=ToNewton();
466     break;
467   default:
468     assert(false);
469     break;
470   }
471   return value;
472 }
473 
474 // Returns temperature as localized string
ToString(Unit temperatureUnit) const475 std::string CTemperature::ToString(Unit temperatureUnit) const
476 {
477   if (!IsValid())
478     return "";
479 
480   return StringUtils::Format("%2.0f", To(temperatureUnit));
481 }
482