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()16CTemperature::CTemperature() 17 { 18 m_value=0.0f; 19 m_valid=false; 20 } 21 CTemperature(const CTemperature & temperature)22CTemperature::CTemperature(const CTemperature& temperature) 23 { 24 m_value=temperature.m_value; 25 m_valid=temperature.m_valid; 26 } 27 CTemperature(double value)28CTemperature::CTemperature(double value) 29 { 30 m_value=value; 31 m_valid=true; 32 } 33 operator >(const CTemperature & right) const34bool 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) const48bool CTemperature::operator >=(const CTemperature& right) const 49 { 50 return operator >(right) || operator ==(right); 51 } 52 operator <(const CTemperature & right) const53bool 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) const67bool CTemperature::operator <=(const CTemperature& right) const 68 { 69 return operator <(right) || operator ==(right); 70 } 71 operator ==(const CTemperature & right) const72bool 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) const86bool CTemperature::operator !=(const CTemperature& right) const 87 { 88 return !operator ==(right.m_value); 89 } 90 operator =(const CTemperature & right)91CTemperature& 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)98const 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)107const 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)116const 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)125const 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) const134CTemperature 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) const149CTemperature 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) const163CTemperature 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) const176CTemperature 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 ++()189CTemperature& CTemperature::operator ++() 190 { 191 assert(IsValid()); 192 193 m_value++; 194 return *this; 195 } 196 operator --()197CTemperature& CTemperature::operator --() 198 { 199 assert(IsValid()); 200 201 m_value--; 202 return *this; 203 } 204 operator ++(int)205CTemperature CTemperature::operator ++(int) 206 { 207 assert(IsValid()); 208 209 CTemperature temp(*this); 210 m_value++; 211 return temp; 212 } 213 operator --(int)214CTemperature CTemperature::operator --(int) 215 { 216 assert(IsValid()); 217 218 CTemperature temp(*this); 219 m_value--; 220 return temp; 221 } 222 operator >(double right) const223bool 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) const233bool CTemperature::operator >=(double right) const 234 { 235 return operator >(right) || operator ==(right); 236 } 237 operator <(double right) const238bool 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) const248bool CTemperature::operator <=(double right) const 249 { 250 return operator <(right) || operator ==(right); 251 } 252 operator ==(double right) const253bool CTemperature::operator ==(double right) const 254 { 255 if (!IsValid()) 256 return false; 257 258 return (m_value==right); 259 } 260 operator !=(double right) const261bool CTemperature::operator !=(double right) const 262 { 263 return !operator ==(right); 264 } 265 operator +=(double right)266const CTemperature& CTemperature::operator +=(double right) 267 { 268 assert(IsValid()); 269 270 m_value+=right; 271 return *this; 272 } 273 operator -=(double right)274const CTemperature& CTemperature::operator -=(double right) 275 { 276 assert(IsValid()); 277 278 m_value-=right; 279 return *this; 280 } 281 operator *=(double right)282const CTemperature& CTemperature::operator *=(double right) 283 { 284 assert(IsValid()); 285 286 m_value*=right; 287 return *this; 288 } 289 operator /=(double right)290const CTemperature& CTemperature::operator /=(double right) 291 { 292 assert(IsValid()); 293 294 m_value/=right; 295 return *this; 296 } 297 operator +(double right) const298CTemperature 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) const307CTemperature 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) const316CTemperature 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) const325CTemperature 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)334CTemperature CTemperature::CreateFromFahrenheit(double value) 335 { 336 return CTemperature(value); 337 } 338 CreateFromReaumur(double value)339CTemperature CTemperature::CreateFromReaumur(double value) 340 { 341 return CTemperature(value*2.25f+32.0f); 342 } 343 CreateFromRankine(double value)344CTemperature CTemperature::CreateFromRankine(double value) 345 { 346 return CTemperature(value-459.67f); 347 } 348 CreateFromRomer(double value)349CTemperature CTemperature::CreateFromRomer(double value) 350 { 351 return CTemperature((value-7.5f)*24.0f/7.0f+32.0f); 352 } 353 CreateFromDelisle(double value)354CTemperature CTemperature::CreateFromDelisle(double value) 355 { 356 CTemperature temp(212.0f - value * 1.2f); 357 return temp; 358 } 359 CreateFromNewton(double value)360CTemperature CTemperature::CreateFromNewton(double value) 361 { 362 return CTemperature(value*60.0f/11.0f+32.0f); 363 } 364 CreateFromCelsius(double value)365CTemperature CTemperature::CreateFromCelsius(double value) 366 { 367 return CTemperature(value*1.8f+32.0f); 368 } 369 CreateFromKelvin(double value)370CTemperature CTemperature::CreateFromKelvin(double value) 371 { 372 return CTemperature((value - 273.15) * 1.8 + 32.0); 373 } 374 Archive(CArchive & ar)375void 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() const389bool CTemperature::IsValid() const 390 { 391 return m_valid; 392 } 393 ToFahrenheit() const394double CTemperature::ToFahrenheit() const 395 { 396 return m_value; 397 } 398 ToKelvin() const399double CTemperature::ToKelvin() const 400 { 401 return (m_value+459.67F)/1.8f; 402 } 403 ToCelsius() const404double CTemperature::ToCelsius() const 405 { 406 return (m_value-32.0f)/1.8f; 407 } 408 ToReaumur() const409double CTemperature::ToReaumur() const 410 { 411 return (m_value-32.0f)/2.25f; 412 } 413 ToRankine() const414double CTemperature::ToRankine() const 415 { 416 return m_value+459.67f; 417 } 418 ToRomer() const419double CTemperature::ToRomer() const 420 { 421 return (m_value-32.0f)*7.0f/24.0f+7.5f; 422 } 423 ToDelisle() const424double CTemperature::ToDelisle() const 425 { 426 return (212.f-m_value)*5.0f/6.0f; 427 } 428 ToNewton() const429double CTemperature::ToNewton() const 430 { 431 return (m_value-32.0f)*11.0f/60.0f; 432 } 433 To(Unit temperatureUnit) const434double 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) const475std::string CTemperature::ToString(Unit temperatureUnit) const 476 { 477 if (!IsValid()) 478 return ""; 479 480 return StringUtils::Format("%2.0f", To(temperatureUnit)); 481 } 482