src/TimeUtil/TimeUtilConverter.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <Commons/Exception.h>
  19 #include <CommonsJavaScript/ScopedJSStringRef.h>
  20 #include <CommonsJavaScript/PrivateObject.h>
  21 #include <CommonsJavaScript/Validator.h>
  22 #include <CommonsJavaScript/JSUtils.h>
  23 #include <Commons/RegexUtils.h>
  24
  25 #include "TimeUtilConverter.h"
  26 #include "JSTZDate.h"
  27 #include "JSTimeDuration.h"
  28 #include <Logger.h>
  29
  30 using namespace WrtDeviceApis;
  31
  32 namespace DeviceAPI {
  33 namespace Time {
  34
  35 TimeUtilConverter::TimeUtilConverter(JSContextRef context)
  36 : WrtDeviceApis::CommonsJavaScript::Converter(context) {
  37 }
  38
  39 TimeUtilConverter::~TimeUtilConverter() {
  40 }
  41
  42 short TimeUtilConverter::toShort(const JSValueRef& arg)
  43 {
  44     double tmp = toNumber_(arg);
  45     return (isNan(tmp) ? 0 : static_cast<short>(tmp));
  46 }
  47
  48 TZDateProperties TimeUtilConverter::getPropertiesInTZDate(JSValueRef arg) {
  49         if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) || !JSValueIsObjectOfClass(m_context, arg, JSTZDate::getClassRef())) {
  50                 ThrowMsg(Commons::ConversionException,
  51                          "Message is JS null or JS undefined.");
  52         }
  53         JSObjectRef obj = toJSObjectRef(arg);
  54         return getPropertiesInTZDate(obj);
  55 }
  56
  57
  58 TZDateProperties TimeUtilConverter::getPropertiesInTZDate(JSObjectRef arg) {
  59         LoggerD("TZDate object=" << arg);
  60         if (!arg) {
  61                 LoggerE("Object is null");
  62                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
  63         }
  64         TZDatePrivObject* privateObject = static_cast<TZDatePrivObject*>(JSObjectGetPrivate(arg));
  65         if (!privateObject) {
  66                 LoggerE("Private object is not set.");
  67                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
  68         }
  69
  70         TZDatePtr tzDate = privateObject->getObject();
  71         TZDateProperties result;
  72
  73         result.timezone = tzDate->getTimezone();
  74         result.year = tzDate->get(TZDate::TZDATE_YEAR);
  75         result.month = tzDate->get(TZDate::TZDATE_MONTH);
  76         result.day= tzDate->get(TZDate::TZDATE_DATE);
  77         result.hours= tzDate->get(TZDate::TZDATE_HOUR_OF_DAY);
  78         result.minutes= tzDate->get(TZDate::TZDATE_MINUTE);
  79         result.seconds= tzDate->get(TZDate::TZDATE_SECOND);
  80         result.milliseconds = tzDate->get(TZDate::TZDATE_MILLISECOND);
  81         return result;
  82 }
  83
  84 JSObjectRef TimeUtilConverter::makeDurationObject(const DurationProperties &duration) {
  85         return JSTimeDuration::createJSObject(m_context, duration);
  86 }
  87
  88 JSObjectRef TimeUtilConverter::makeMillisecondDurationObject(const long long length) {
  89         DurationProperties duration;
  90         duration.length = length;
  91         duration.unit = MSECS_UNIT;
  92         const long long dayToMsecs = 1000 * 60 * 60 * 24;
  93         if ((length % dayToMsecs) == 0) {
  94                 duration.length = length / dayToMsecs;
  95                 duration.unit = DAYS_UNIT;
  96         }
  97
  98         return makeDurationObject(duration);
  99 }
 100
 101 DurationPropertiesPtr TimeUtilConverter::getDuration(JSValueRef value) {
 102         if (!JSValueIsObjectOfClass(m_context, value, JSTimeDuration::getClassRef())) {
 103                 ThrowMsg(Commons::ConversionException, "Wrong duration object.");
 104         }
 105
 106         TimeDurationPrivObject* privateObject = static_cast<TimeDurationPrivObject*>(JSObjectGetPrivate(toJSObjectRef(value)));
 107         DurationPropertiesPtr duration = privateObject->getObject();
 108         return duration;
 109 }
 110
 111 DurationProperties TimeUtilConverter::getDurationProperties(JSValueRef value) {
 112         DurationProperties duration;
 113         duration.length = getDurationLength(value);
 114         duration.unit = getDurationUnit(value);
 115         return duration;
 116 }
 117
 118 long long TimeUtilConverter::getDurationLength(JSValueRef value) {
 119         if (JSValueIsNull(m_context, value) || JSValueIsUndefined(m_context, value) || !JSValueIsObjectOfClass(m_context, value, JSTimeDuration::getClassRef())) {
 120                 ThrowMsg(Commons::ConversionException,
 121                          "Duration is JS null or JS undefined.");
 122         }
 123         JSObjectRef obj = toJSObjectRef(value);
 124         return getDurationLength(obj);
 125 }
 126
 127 long long TimeUtilConverter::getDurationLength(JSObjectRef object) {
 128         TimeDurationPrivObject* privateObject = static_cast<TimeDurationPrivObject*>(JSObjectGetPrivate(object));
 129         if (!privateObject) {
 130                 LoggerE("Private object is not set.");
 131                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
 132         }
 133
 134         DurationPropertiesPtr duration = privateObject->getObject();
 135
 136         return duration->length;
 137 }
 138
 139 short TimeUtilConverter::getDurationUnit(JSValueRef value) {
 140         if (JSValueIsNull(m_context, value) || JSValueIsUndefined(m_context, value) || !JSValueIsObjectOfClass(m_context, value, JSTimeDuration::getClassRef())) {
 141                 ThrowMsg(Commons::ConversionException,
 142                          "Duration is JS null or JS undefined.");
 143         }
 144         JSObjectRef obj = toJSObjectRef(value);
 145         return getDurationUnit(obj);
 146 }
 147
 148 short TimeUtilConverter::getDurationUnit(JSObjectRef object) {
 149         TimeDurationPrivObject* privateObject = static_cast<TimeDurationPrivObject*>(JSObjectGetPrivate(object));
 150         if (!privateObject) {
 151                 LoggerE("Private object is not set.");
 152                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
 153         }
 154
 155         DurationPropertiesPtr duration = privateObject->getObject();
 156
 157         return duration->unit;
 158
 159 }
 160
 161 short TimeUtilConverter::toDurationUnit(std::string strUnit) {
 162         if (!strUnit.compare("DAYS"))
 163                 return DAYS_UNIT;
 164         else if (!strUnit.compare("SECS"))
 165                 return SECONDS_UNIT;
 166         else if (!strUnit.compare("MINS"))
 167                 return MINUTES_UNIT;
 168         else if (!strUnit.compare("HOURS"))
 169                 return HOURS_UNIT;
 170         else if (!strUnit.compare("MSECS"))
 171                 return  MSECS_UNIT;
 172         else
 173                 return 0xff;
 174 }
 175
 176 std::string TimeUtilConverter::toDurationUnitString(short unit) {
 177         switch (unit) {
 178                 case DAYS_UNIT:
 179                         return "DAYS";
 180                 case SECONDS_UNIT:
 181                         return "SECS";
 182                 case MINUTES_UNIT:
 183                         return "MINS";
 184                 case HOURS_UNIT:
 185                         return "HOURS";
 186                 case MSECS_UNIT:
 187                         return "MSECS";
 188                 default:
 189                         return "";
 190         }
 191 }
 192
 193 long long TimeUtilConverter::convertDurationLength(DurationProperties duration, short unit) {
 194         if (duration.unit < unit)
 195                 ThrowMsg(Commons::ConversionException, "Unit is larger thatn duration's unit");
 196
 197         if (duration.unit == unit)
 198                 return duration.length;
 199
 200         long long result = duration.length;
 201
 202         switch(unit) {
 203                 case MSECS_UNIT:
 204                         result = result * 1000;
 205                         if (duration.unit == SECONDS_UNIT)
 206                                 return result;
 207                         // intentional fall-through
 208
 209                 case SECONDS_UNIT:
 210                         result = result * 60;
 211                         if (duration.unit == MINUTES_UNIT)
 212                                 return result;
 213                         // intentional fall-through
 214
 215                 case MINUTES_UNIT:
 216                         result = result * 60;
 217                         if (duration.unit == HOURS_UNIT)
 218                                 return result;
 219                         // intentional fall-through
 220
 221                 case HOURS_UNIT:
 222                         result = result * 24;
 223                         return result;
 224                         // intentional fall-through
 225         }
 226     return result;
 227 }
 228
 229 double TimeUtilConverter::getTimeInMilliseconds(JSValueRef arg) {
 230         if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) || !JSValueIsObjectOfClass(m_context, arg, JSTZDate::getClassRef())) {
 231                 ThrowMsg(Commons::ConversionException,
 232                          "JSValueRef is JS null or JS undefined.");
 233         }
 234         JSObjectRef obj = toJSObjectRef(arg);
 235
 236         return getTimeInMilliseconds(obj);
 237 }
 238
 239 double TimeUtilConverter::getTimeInMilliseconds(JSObjectRef arg) {
 240         if (!arg) {
 241                 LoggerE("Object is null");
 242                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
 243         }
 244
 245         TZDatePrivObject* privateObject = static_cast<TZDatePrivObject*>(JSObjectGetPrivate(arg));
 246         if (!privateObject) {
 247                 LoggerE("Private object is not set.");
 248                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
 249         }
 250
 251         TZDatePtr tzDate = privateObject->getObject();
 252
 253         return tzDate->getTime();
 254 }
 255
 256 tm TimeUtilConverter::toTZDateTime(JSValueRef arg) {
 257         if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) || !JSValueIsObjectOfClass(m_context, arg, JSTZDate::getClassRef())) {
 258                 ThrowMsg(Commons::ConversionException,
 259                          "JSValueRef is JS null or JS undefined.");
 260         }
 261         JSObjectRef obj = toJSObjectRef(arg);
 262
 263         return toTZDateTime(obj);
 264 }
 265
 266 tm TimeUtilConverter::toTZDateTime(JSObjectRef arg) {
 267         if (!arg) {
 268                 LoggerE("Object is null");
 269                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
 270         }
 271
 272         TZDatePrivObject* privateObject = static_cast<TZDatePrivObject*>(JSObjectGetPrivate(arg));
 273         if (!privateObject) {
 274                 LoggerE("Private object is not set.");
 275                 ThrowMsg(Commons::ConversionException, "Private object not initialized");
 276         }
 277
 278         TZDatePtr tzDate = privateObject->getObject();
 279         TZDatePtr utcTzDate(new TZDate(tzDate->getUTCTimezoneName()));
 280         if (!utcTzDate->setTime(tzDate->getTime()))
 281                 ThrowMsg(Commons::ConversionException, "Can not set UTC Time");
 282
 283         TZDateProperties utcProperties = utcTzDate->makeProperties();
 284         struct tm  utcTm;
 285         memset(&utcTm, 0, sizeof(utcTm));
 286
 287         utcTm.tm_year = utcProperties.year - 1900;
 288         utcTm.tm_mon = utcProperties.month;
 289         utcTm.tm_mday= utcProperties.day;
 290         utcTm.tm_hour= utcProperties.hours;
 291         utcTm.tm_min=utcProperties.minutes;
 292         utcTm.tm_sec= utcProperties.seconds;
 293         utcTm.tm_isdst = 0;
 294         return utcTm;
 295 }
 296
 297 JSObjectRef TimeUtilConverter::toJSValueRefTZDate(const double milliseconds, const std::string &timezone) {
 298         return JSTZDate::createJSObject(m_context, milliseconds, timezone);
 299 }
 300
 301 }
 302 }