xbmc/utils/Temperature.cpp

   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
  16 CTemperature::CTemperature()
  17 {
  18   m_value = 0.0;
  19   m_valid=false;
  20 }
  21
  22 CTemperature::CTemperature(const CTemperature& temperature)
  23 {
  24   m_value=temperature.m_value;
  25   m_valid=temperature.m_valid;
  26 }
  27
  28 CTemperature::CTemperature(double value)
  29 {
  30   m_value=value;
  31   m_valid=true;
  32 }
  33
  34 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
  48 bool CTemperature::operator >=(const CTemperature& right) const
  49 {
  50   return operator >(right) || operator ==(right);
  51 }
  52
  53 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
  67 bool CTemperature::operator <=(const CTemperature& right) const
  68 {
  69   return operator <(right) || operator ==(right);
  70 }
  71
  72 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
  86 bool CTemperature::operator !=(const CTemperature& right) const
  87 {
  88   return !operator ==(right.m_value);
  89 }
  90
  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
  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
 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
 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
 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
 134 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
 149 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
 163 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
 176 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
 189 CTemperature& CTemperature::operator ++()
 190 {
 191   assert(IsValid());
 192
 193   m_value++;
 194   return *this;
 195 }
 196
 197 CTemperature& CTemperature::operator --()
 198 {
 199   assert(IsValid());
 200
 201   m_value--;
 202   return *this;
 203 }
 204
 205 CTemperature CTemperature::operator ++(int)
 206 {
 207   assert(IsValid());
 208
 209   CTemperature temp(*this);
 210   m_value++;
 211   return temp;
 212 }
 213
 214 CTemperature CTemperature::operator --(int)
 215 {
 216   assert(IsValid());
 217
 218   CTemperature temp(*this);
 219   m_value--;
 220   return temp;
 221 }
 222
 223 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
 233 bool CTemperature::operator >=(double right) const
 234 {
 235   return operator >(right) || operator ==(right);
 236 }
 237
 238 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
 248 bool CTemperature::operator <=(double right) const
 249 {
 250   return operator <(right) || operator ==(right);
 251 }
 252
 253 bool CTemperature::operator ==(double right) const
 254 {
 255   if (!IsValid())
 256     return false;
 257
 258   return (m_value==right);
 259 }
 260
 261 bool CTemperature::operator !=(double right) const
 262 {
 263   return !operator ==(right);
 264 }
 265
 266 const CTemperature& CTemperature::operator +=(double right)
 267 {
 268   assert(IsValid());
 269
 270   m_value+=right;
 271   return *this;
 272 }
 273
 274 const CTemperature& CTemperature::operator -=(double right)
 275 {
 276   assert(IsValid());
 277
 278   m_value-=right;
 279   return *this;
 280 }
 281
 282 const CTemperature& CTemperature::operator *=(double right)
 283 {
 284   assert(IsValid());
 285
 286   m_value*=right;
 287   return *this;
 288 }
 289
 290 const CTemperature& CTemperature::operator /=(double right)
 291 {
 292   assert(IsValid());
 293
 294   m_value/=right;
 295   return *this;
 296 }
 297
 298 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
 307 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
 316 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
 325 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
 334 CTemperature CTemperature::CreateFromFahrenheit(double value)
 335 {
 336   return CTemperature(value);
 337 }
 338
 339 CTemperature CTemperature::CreateFromReaumur(double value)
 340 {
 341   return CTemperature(value * 2.25 + 32.0);
 342 }
 343
 344 CTemperature CTemperature::CreateFromRankine(double value)
 345 {
 346   return CTemperature(value - 459.67);
 347 }
 348
 349 CTemperature CTemperature::CreateFromRomer(double value)
 350 {
 351   return CTemperature((value - 7.5) * 24.0 / 7.0 + 32.0);
 352 }
 353
 354 CTemperature CTemperature::CreateFromDelisle(double value)
 355 {
 356   CTemperature temp(212.0 - value * 1.2);
 357   return temp;
 358 }
 359
 360 CTemperature CTemperature::CreateFromNewton(double value)
 361 {
 362   return CTemperature(value * 60.0 / 11.0 + 32.0);
 363 }
 364
 365 CTemperature CTemperature::CreateFromCelsius(double value)
 366 {
 367   return CTemperature(value * 1.8 + 32.0);
 368 }
 369
 370 CTemperature CTemperature::CreateFromKelvin(double value)
 371 {
 372   return CTemperature((value - 273.15) * 1.8 + 32.0);
 373 }
 374
 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
 389 bool CTemperature::IsValid() const
 390 {
 391   return m_valid;
 392 }
 393
 394 double CTemperature::ToFahrenheit() const
 395 {
 396   return m_value;
 397 }
 398
 399 double CTemperature::ToKelvin() const
 400 {
 401   return (m_value + 459.67) / 1.8;
 402 }
 403
 404 double CTemperature::ToCelsius() const
 405 {
 406   return (m_value - 32.0) / 1.8;
 407 }
 408
 409 double CTemperature::ToReaumur() const
 410 {
 411   return (m_value - 32.0) / 2.25;
 412 }
 413
 414 double CTemperature::ToRankine() const
 415 {
 416   return m_value + 459.67;
 417 }
 418
 419 double CTemperature::ToRomer() const
 420 {
 421   return (m_value - 32.0) * 7.0 / 24.0 + 7.5;
 422 }
 423
 424 double CTemperature::ToDelisle() const
 425 {
 426   return (212.0 - m_value) * 5.0 / 6.0;
 427 }
 428
 429 double CTemperature::ToNewton() const
 430 {
 431   return (m_value - 32.0) * 11.0 / 60.0;
 432 }
 433
 434 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
 475 std::string CTemperature::ToString(Unit temperatureUnit) const
 476 {
 477   if (!IsValid())
 478     return "";
 479
 480   return StringUtils::Format("{:2.0f}", To(temperatureUnit));
 481 }