xbmc/Temperature.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "LangInfo.h"
  22 #include "guilib/LocalizeStrings.h"
  23 #include "Temperature.h"
  24 #include "utils/StringUtils.h"
  25
  26 CTemperature::CTemperature()
  27 {
  28   m_value=0.0f;
  29   m_state=invalid;
  30 }
  31
  32 CTemperature::CTemperature(const CTemperature& temperature)
  33 {
  34   m_value=temperature.m_value;
  35   m_state=temperature.m_state;
  36 }
  37
  38 CTemperature::CTemperature(double value)
  39 {
  40   m_value=value;
  41   m_state=valid;
  42 }
  43
  44 bool CTemperature::operator >(const CTemperature& right) const
  45 {
  46   ASSERT(IsValid());
  47   ASSERT(right.IsValid());
  48
  49   if (!IsValid() || !right.IsValid())
  50     return false;
  51
  52   if (this==&right)
  53     return false;
  54
  55   return (m_value>right.m_value);
  56 }
  57
  58 bool CTemperature::operator >=(const CTemperature& right) const
  59 {
  60   return operator >(right) || operator ==(right);
  61 }
  62
  63 bool CTemperature::operator <(const CTemperature& right) const
  64 {
  65   ASSERT(IsValid());
  66   ASSERT(right.IsValid());
  67
  68   if (!IsValid() || !right.IsValid())
  69     return false;
  70
  71   if (this==&right)
  72     return false;
  73
  74   return (m_value<right.m_value);
  75 }
  76
  77 bool CTemperature::operator <=(const CTemperature& right) const
  78 {
  79   return operator <(right) || operator ==(right);
  80 }
  81
  82 bool CTemperature::operator ==(const CTemperature& right) const
  83 {
  84   ASSERT(IsValid());
  85   ASSERT(right.IsValid());
  86
  87   if (!IsValid() || !right.IsValid())
  88     return false;
  89
  90   if (this==&right)
  91     return true;
  92
  93   return (m_value==right.m_value);
  94 }
  95
  96 bool CTemperature::operator !=(const CTemperature& right) const
  97 {
  98   return !operator ==(right.m_value);
  99 }
 100
 101 const CTemperature& CTemperature::operator =(const CTemperature& right)
 102 {
 103   m_state=right.m_state;
 104   m_value=right.m_value;
 105   return *this;
 106 }
 107
 108 const CTemperature& CTemperature::operator +=(const CTemperature& right)
 109 {
 110   ASSERT(IsValid());
 111   ASSERT(right.IsValid());
 112
 113   m_value+=right.m_value;
 114   return *this;
 115 }
 116
 117 const CTemperature& CTemperature::operator -=(const CTemperature& right)
 118 {
 119   ASSERT(IsValid());
 120   ASSERT(right.IsValid());
 121
 122   m_value-=right.m_value;
 123   return *this;
 124 }
 125
 126 const CTemperature& CTemperature::operator *=(const CTemperature& right)
 127 {
 128   ASSERT(IsValid());
 129   ASSERT(right.IsValid());
 130
 131   m_value*=right.m_value;
 132   return *this;
 133 }
 134
 135 const CTemperature& CTemperature::operator /=(const CTemperature& right)
 136 {
 137   ASSERT(IsValid());
 138   ASSERT(right.IsValid());
 139
 140   m_value/=right.m_value;
 141   return *this;
 142 }
 143
 144 CTemperature CTemperature::operator +(const CTemperature& right) const
 145 {
 146   ASSERT(IsValid());
 147   ASSERT(right.IsValid());
 148
 149   CTemperature temp(*this);
 150
 151   if (!IsValid() || !right.IsValid())
 152     temp.SetState(invalid);
 153   else
 154     temp.m_value+=right.m_value;
 155
 156   return temp;
 157 }
 158
 159 CTemperature CTemperature::operator -(const CTemperature& right) const
 160 {
 161   ASSERT(IsValid());
 162   ASSERT(right.IsValid());
 163
 164   CTemperature temp(*this);
 165   if (!IsValid() || !right.IsValid())
 166     temp.SetState(invalid);
 167   else
 168     temp.m_value-=right.m_value;
 169
 170   return temp;
 171 }
 172
 173 CTemperature CTemperature::operator *(const CTemperature& right) const
 174 {
 175   ASSERT(IsValid());
 176   ASSERT(right.IsValid());
 177
 178   CTemperature temp(*this);
 179   if (!IsValid() || !right.IsValid())
 180     temp.SetState(invalid);
 181   else
 182     temp.m_value*=right.m_value;
 183   return temp;
 184 }
 185
 186 CTemperature CTemperature::operator /(const CTemperature& right) const
 187 {
 188   ASSERT(IsValid());
 189   ASSERT(right.IsValid());
 190
 191   CTemperature temp(*this);
 192   if (!IsValid() || !right.IsValid())
 193     temp.SetState(invalid);
 194   else
 195     temp.m_value/=right.m_value;
 196   return temp;
 197 }
 198
 199 CTemperature& CTemperature::operator ++()
 200 {
 201   ASSERT(IsValid());
 202
 203   m_value++;
 204   return *this;
 205 }
 206
 207 CTemperature& CTemperature::operator --()
 208 {
 209   ASSERT(IsValid());
 210
 211   m_value--;
 212   return *this;
 213 }
 214
 215 CTemperature CTemperature::operator ++(int)
 216 {
 217   ASSERT(IsValid());
 218
 219   CTemperature temp(*this);
 220   m_value++;
 221   return temp;
 222 }
 223
 224 CTemperature CTemperature::operator --(int)
 225 {
 226   ASSERT(IsValid());
 227
 228   CTemperature temp(*this);
 229   m_value--;
 230   return temp;
 231 }
 232
 233 bool CTemperature::operator >(double right) const
 234 {
 235   ASSERT(IsValid());
 236
 237   if (!IsValid())
 238     return false;
 239
 240   return (m_value>right);
 241 }
 242
 243 bool CTemperature::operator >=(double right) const
 244 {
 245   return operator >(right) || operator ==(right);
 246 }
 247
 248 bool CTemperature::operator <(double right) const
 249 {
 250   ASSERT(IsValid());
 251
 252   if (!IsValid())
 253     return false;
 254
 255   return (m_value<right);
 256 }
 257
 258 bool CTemperature::operator <=(double right) const
 259 {
 260   return operator <(right) || operator ==(right);
 261 }
 262
 263 bool CTemperature::operator ==(double right) const
 264 {
 265   if (!IsValid())
 266     return false;
 267
 268   return (m_value==right);
 269 }
 270
 271 bool CTemperature::operator !=(double right) const
 272 {
 273   return !operator ==(right);
 274 }
 275
 276 const CTemperature& CTemperature::operator +=(double right)
 277 {
 278   ASSERT(IsValid());
 279
 280   m_value+=right;
 281   return *this;
 282 }
 283
 284 const CTemperature& CTemperature::operator -=(double right)
 285 {
 286   ASSERT(IsValid());
 287
 288   m_value-=right;
 289   return *this;
 290 }
 291
 292 const CTemperature& CTemperature::operator *=(double right)
 293 {
 294   ASSERT(IsValid());
 295
 296   m_value*=right;
 297   return *this;
 298 }
 299
 300 const CTemperature& CTemperature::operator /=(double right)
 301 {
 302   ASSERT(IsValid());
 303
 304   m_value/=right;
 305   return *this;
 306 }
 307
 308 CTemperature CTemperature::operator +(double right) const
 309 {
 310   ASSERT(IsValid());
 311
 312   CTemperature temp(*this);
 313   temp.m_value+=right;
 314   return temp;
 315 }
 316
 317 CTemperature CTemperature::operator -(double right) const
 318 {
 319   ASSERT(IsValid());
 320
 321   CTemperature temp(*this);
 322   temp.m_value-=right;
 323   return temp;
 324 }
 325
 326 CTemperature CTemperature::operator *(double right) const
 327 {
 328   ASSERT(IsValid());
 329
 330   CTemperature temp(*this);
 331   temp.m_value*=right;
 332   return temp;
 333 }
 334
 335 CTemperature CTemperature::operator /(double right) const
 336 {
 337   ASSERT(IsValid());
 338
 339   CTemperature temp(*this);
 340   temp.m_value/=right;
 341   return temp;
 342 }
 343
 344 CTemperature CTemperature::CreateFromFahrenheit(double value)
 345 {
 346   return CTemperature(value);
 347 }
 348
 349 CTemperature CTemperature::CreateFromReaumur(double value)
 350 {
 351   return CTemperature(value*2.25f+32.0f);
 352 }
 353
 354 CTemperature CTemperature::CreateFromRankine(double value)
 355 {
 356   return CTemperature(value-459.67f);
 357 }
 358
 359 CTemperature CTemperature::CreateFromRomer(double value)
 360 {
 361   return CTemperature((value-7.5f)*24.0f/7.0f+32.0f);
 362 }
 363
 364 CTemperature CTemperature::CreateFromDelisle(double value)
 365 {
 366   CTemperature temp(212.0f - value * 1.2f);
 367   return temp;
 368 }
 369
 370 CTemperature CTemperature::CreateFromNewton(double value)
 371 {
 372   return CTemperature(value*60.0f/11.0f+32.0f);
 373 }
 374
 375 CTemperature CTemperature::CreateFromCelsius(double value)
 376 {
 377   return CTemperature(value*1.8f+32.0f);
 378 }
 379
 380 void CTemperature::Archive(CArchive& ar)
 381 {
 382   if (ar.IsStoring())
 383   {
 384     ar<<m_value;
 385     ar<<(int)m_state;
 386   }
 387   else
 388   {
 389     ar>>m_value;
 390     int state;
 391     ar>>(int&)state;
 392     m_state = CTemperature::STATE(state);
 393   }
 394 }
 395
 396 void CTemperature::SetState(CTemperature::STATE state)
 397 {
 398   m_state=state;
 399 }
 400
 401 bool CTemperature::IsValid() const
 402 {
 403   return (m_state==valid);
 404 }
 405
 406 double CTemperature::ToFahrenheit() const
 407 {
 408   return m_value;
 409 }
 410
 411 double CTemperature::ToKelvin() const
 412 {
 413   return (m_value+459.67F)/1.8f;
 414 }
 415
 416 double CTemperature::ToCelsius() const
 417 {
 418   return (m_value-32.0f)/1.8f;
 419 }
 420
 421 double CTemperature::ToReaumur() const
 422 {
 423   return (m_value-32.0f)/2.25f;
 424 }
 425
 426 double CTemperature::ToRankine() const
 427 {
 428   return m_value+459.67f;
 429 }
 430
 431 double CTemperature::ToRomer() const
 432 {
 433   return (m_value-32.0f)*7.0f/24.0f+7.5f;
 434 }
 435
 436 double CTemperature::ToDelisle() const
 437 {
 438   return (212.f-m_value)*5.0f/6.0f;
 439 }
 440
 441 double CTemperature::ToNewton() const
 442 {
 443   return (m_value-32.0f)*11.0f/60.0f;
 444 }
 445
 446 double CTemperature::ToLocale() const
 447 {
 448   if (!IsValid())
 449     return 0;
 450   double value = 0.0;
 451
 452   switch(g_langInfo.GetTempUnit())
 453   {
 454   case CLangInfo::TEMP_UNIT_FAHRENHEIT:
 455     value=ToFahrenheit();
 456     break;
 457   case CLangInfo::TEMP_UNIT_KELVIN:
 458     value=ToKelvin();
 459     break;
 460   case CLangInfo::TEMP_UNIT_CELSIUS:
 461     value=ToCelsius();
 462     break;
 463   case CLangInfo::TEMP_UNIT_REAUMUR:
 464     value=ToReaumur();
 465     break;
 466   case CLangInfo::TEMP_UNIT_RANKINE:
 467     value=ToRankine();
 468     break;
 469   case CLangInfo::TEMP_UNIT_ROMER:
 470     value=ToRomer();
 471     break;
 472   case CLangInfo::TEMP_UNIT_DELISLE:
 473     value=ToDelisle();
 474     break;
 475   case CLangInfo::TEMP_UNIT_NEWTON:
 476     value=ToNewton();
 477     break;
 478   default:
 479     ASSERT(false);
 480     break;
 481   }
 482   return value;
 483 }
 484
 485 // Returns temperature as localized string
 486 std::string CTemperature::ToString() const
 487 {
 488   if (!IsValid())
 489     return g_localizeStrings.Get(13205); // "Unknown"
 490
 491   return StringUtils::Format("%2.0f%s", ToLocale(), g_langInfo.GetTempUnitString().c_str());
 492 }