src/standards/Tizen/Application/JSApplicationContextArray.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <dpl/log/log.h>
  18 #include <CommonsJavaScript/Converter.h>
  19 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  20 #include "JSApplicationContextArray.h"
  21 #include "ApplicationConverter.h"
  22
  23
  24 namespace {
  25 const char* FUNCTION_CONCAT = "concat";
  26 const char* FUNCTION_JOIN = "join";
  27 const char* FUNCTION_POP = "pop";
  28 const char* FUNCTION_PUSH = "push";
  29 const char* FUNCTION_REVERSE = "reverse";
  30 const char* FUNCTION_SHIFT = "shift";
  31 const char* FUNCTION_SLICE = "slice";
  32 const char* FUNCTION_SORT = "sort";
  33 const char* FUNCTION_SPLICE = "splice";
  34 const char* FUNCTION_TOSTRING = "toString";
  35 const char* FUNCTION_UNSHIFT = "unshift";
  36 const char* FUNCTION_VALUEOF = "valueOf";
  37 const char *ARRAY = "Array";
  38 const char *ATTRIBUTE_LENGTH = "length";
  39 }
  40
  41 namespace TizenApis {
  42 namespace Tizen1_0 {
  43 namespace Application {
  44
  45 using namespace Api::Application;
  46 using namespace WrtDeviceApis;
  47 using namespace WrtDeviceApis::CommonsJavaScript;
  48
  49 JSClassDefinition JSApplicationContextArray::m_classInfo = {
  50         0,
  51         kJSClassAttributeNone,
  52         ARRAY,
  53         0,
  54         m_property,
  55         m_function,
  56         initialize,
  57         finalize,
  58         hasProperty,
  59         getProperty,
  60         setProperty,
  61         NULL, //deleteProperty,
  62         NULL, //getPropertyNames,
  63         NULL, //callAsFunction,
  64         NULL, //callAsConstructor,
  65         NULL, //hasInstance,
  66         NULL, //convertToType,
  67 };
  68
  69 JSStaticValue JSApplicationContextArray::m_property[] = {
  70         { ATTRIBUTE_LENGTH, getLength, NULL, kJSPropertyAttributeReadOnly },
  71         { 0, 0, 0, 0 }
  72 };
  73
  74 JSStaticFunction JSApplicationContextArray::m_function[] = {
  75         { FUNCTION_CONCAT, concat, kJSPropertyAttributeNone },
  76         { FUNCTION_JOIN, join, kJSPropertyAttributeNone },
  77         { FUNCTION_POP, pop, kJSPropertyAttributeNone },
  78         { FUNCTION_PUSH, push, kJSPropertyAttributeNone },
  79         { FUNCTION_REVERSE, reverse, kJSPropertyAttributeNone },
  80         { FUNCTION_SHIFT, shift, kJSPropertyAttributeNone },
  81         { FUNCTION_SLICE, slice, kJSPropertyAttributeNone },
  82         { FUNCTION_SORT, sort, kJSPropertyAttributeNone },
  83         { FUNCTION_SPLICE, splice, kJSPropertyAttributeNone },
  84         { FUNCTION_TOSTRING, toString, kJSPropertyAttributeNone },
  85         { FUNCTION_UNSHIFT, unshift, kJSPropertyAttributeNone },
  86         { FUNCTION_VALUEOF, valueOf, kJSPropertyAttributeNone },
  87         { 0, 0, 0 }
  88 };
  89
  90 JSClassRef JSApplicationContextArray::m_jsClassRef = JSClassCreate(
  91                 JSApplicationContextArray::getClassInfo());
  92
  93 JSValueRef JSApplicationContextArray::getLength(JSContextRef context,
  94                 JSObjectRef object,
  95                 JSStringRef propertyName,
  96                 JSValueRef* exception)
  97 {
  98         Try
  99         {
 100                 JSApplicationContextArrayPriv* priv =
 101                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(object));
 102                 if (!priv) {
 103                         Throw(WrtDeviceApis::Commons::NullPointerException);
 104                 }
 105                 ApplicationContextArrayPtr privateDatas = priv->getObject();
 106                 if (privateDatas) {
 107                         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 108                         return converter->toJSValueRef(privateDatas->size());
 109                 }
 110         }
 111         Catch(WrtDeviceApis::Commons::Exception)
 112         {
 113                 LogError("invalid conversion");
 114         }
 115         return JSValueMakeUndefined(context);
 116 }
 117
 118 JSObjectRef JSApplicationContextArray::createArray(JSContextRef context,
 119                 const ApplicationContextArrayPtr &privateDatas)
 120 {
 121         JSApplicationContextArrayPriv *priv = new JSApplicationContextArrayPriv(context, privateDatas);
 122         return JSObjectMake(context, getClassRef(), priv);
 123 }
 124
 125 const JSClassDefinition* JSApplicationContextArray::getClassInfo()
 126 {
 127         return &(m_classInfo);
 128 }
 129
 130 JSClassRef JSApplicationContextArray::getClassRef()
 131 {
 132         if (!m_jsClassRef) {
 133                 m_jsClassRef = JSClassCreate(&m_classInfo);
 134         }
 135         return m_jsClassRef;
 136 }
 137
 138 bool JSApplicationContextArray::isObjectOfClass(JSContextRef context, JSValueRef value)
 139 {
 140         return JSValueIsObjectOfClass(context, value, getClassRef());
 141 }
 142
 143 ApplicationContextArrayPtr
 144         JSApplicationContextArray::getApplicationContextArray(JSContextRef context, JSValueRef value)
 145 {
 146         if (!isObjectOfClass(context, value)) {
 147                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 148         }
 149         JSObjectRef object = JSValueToObject(context, value, NULL);
 150         if (!object) {
 151                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 152         }
 153         JSApplicationContextArrayPriv *priv = static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(object));
 154         if (!priv) {
 155                 Throw(WrtDeviceApis::Commons::NullPointerException);
 156         }
 157         return priv->getObject();
 158 }
 159
 160 void JSApplicationContextArray::initialize(JSContextRef context,
 161                 JSObjectRef object)
 162 {
 163
 164 }
 165
 166 void JSApplicationContextArray::finalize(JSObjectRef object)
 167 {
 168         JSApplicationContextArrayPriv* priv =
 169                 static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(object));
 170         delete priv;
 171         JSObjectSetPrivate(object, NULL);
 172 }
 173
 174 bool JSApplicationContextArray::hasProperty(JSContextRef context,
 175                 JSObjectRef object,
 176                 JSStringRef propertyName)
 177 {
 178         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 179         Try
 180         {
 181                 size_t index = converter->toSizeT(propertyName);
 182                 JSApplicationContextArrayPriv* priv =
 183                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(object));
 184                 if (!priv) {
 185                         Throw(WrtDeviceApis::Commons::NullPointerException);
 186                 }
 187                 ApplicationContextArrayPtr privateDatas = priv->getObject();
 188                 if (index < privateDatas->size()) {
 189                         return true;
 190                 }
 191         }
 192         Catch(WrtDeviceApis::Commons::Exception)
 193         {
 194                 //not reporting error is intended
 195         }
 196         return false;
 197 }
 198
 199 JSValueRef JSApplicationContextArray::getProperty(JSContextRef context,
 200                 JSObjectRef object,
 201                 JSStringRef propertyName,
 202                 JSValueRef* exception)
 203 {
 204
 205         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 206         Try
 207         {
 208                 size_t index = converter->toSizeT(propertyName);
 209                 JSApplicationContextArrayPriv* priv =
 210                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(object));
 211                 if (!priv) {
 212                         Throw(WrtDeviceApis::Commons::NullPointerException);
 213                 }
 214                 ApplicationContextArrayPtr privateDatas = priv->getObject();
 215                 if (index < privateDatas->size()) {
 216                         ApplicationContextPtr result = privateDatas->at(index);
 217                         if (result) {
 218                                 return converter->toJSValueRef(result);
 219                         }
 220                 }
 221         }
 222         Catch(WrtDeviceApis::Commons::Exception)
 223         {
 224                 LogError("invalid property");
 225         }
 226         return JSValueMakeUndefined(context);
 227 }
 228
 229 bool JSApplicationContextArray::setProperty(JSContextRef context,
 230                 JSObjectRef object,
 231                 JSStringRef propertyName,
 232                 JSValueRef value,
 233                 JSValueRef* exception)
 234 {
 235         ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 236         Try
 237         {
 238                 size_t index = converter->toSizeT(propertyName);
 239                 ApplicationContextPtr privateData;
 240                 if (!JSValueIsUndefined(context, value)) {
 241                         privateData = converter->toApplicationContext(value);
 242                 }
 243                 JSApplicationContextArrayPriv* priv =
 244                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(object));
 245                 if (!priv) {
 246                         Throw(WrtDeviceApis::Commons::NullPointerException);
 247                 }
 248                 ApplicationContextArrayPtr privateDatas = priv->getObject();
 249                 if (!privateDatas) {
 250                         Throw(WrtDeviceApis::Commons::NullPointerException);
 251                 }
 252                 if (privateDatas->size() <= index) {
 253                         privateDatas->resize(index + 1);
 254                 }
 255                 (*privateDatas)[index] = privateData;
 256                 return true;
 257         }
 258         Catch(WrtDeviceApis::Commons::Exception)
 259         {
 260                 LogError("error occured");
 261                 JSDOMExceptionFactory::TypeMismatchException.make(context, exception);
 262         }
 263         return false;
 264 }
 265
 266 JSValueRef JSApplicationContextArray::concat(JSContextRef context,
 267                 JSObjectRef function,
 268                 JSObjectRef thisObject,
 269                 size_t argumentCount,
 270                 const JSValueRef arguments[],
 271                 JSValueRef* exception)
 272 {
 273         Try
 274         {
 275                 ApplicationContextArrayPtr privateDatas = ApplicationContextArrayPtr(new ApplicationContextArray());
 276                 JSApplicationContextArrayPriv *newPrivateObject = new JSApplicationContextArrayPriv(context, privateDatas);
 277                 JSValueRef result = JSObjectMake(context, getClassRef(), newPrivateObject);
 278
 279                 //copy current privateDatas
 280                 JSApplicationContextArrayPriv* priv =
 281                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 282                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 283                 for (size_t i = 0; i < currentApplicationContexts->size(); ++i) {
 284                         privateDatas->push_back(currentApplicationContexts->at(i));
 285                 }
 286
 287                 //copy submitted arrays
 288                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 289                 for (size_t i = 0; i < argumentCount; ++i) {
 290                         if (!JSIsArrayValue(context, arguments[i])) {
 291                                 Throw(WrtDeviceApis::Commons::ConversionException);
 292                         }
 293                         // process array of strings
 294                         JSObjectRef arrayObj = converter->toJSObjectRef(arguments[i]);
 295                         unsigned int len = JSGetArrayLength(context, arrayObj);
 296                         for (unsigned int e = 0; e < len; ++e) {
 297                                 JSValueRef att = JSGetArrayElement(context, arrayObj, e);
 298                                 privateDatas->push_back(converter->toApplicationContext(att));
 299                         }
 300                 }
 301                 return result;
 302         }
 303         Catch(WrtDeviceApis::Commons::Exception)
 304         {
 305                 LogError("error occured");
 306         }
 307         return JSDOMExceptionFactory::TypeMismatchException.make(context, exception);
 308 }
 309
 310 JSValueRef JSApplicationContextArray::join(JSContextRef context,
 311                 JSObjectRef function,
 312                 JSObjectRef thisObject,
 313                 size_t argumentCount,
 314                 const JSValueRef arguments[],
 315                 JSValueRef* exception)
 316 {
 317         Try
 318         {
 319                 std::string result;
 320                 std::string separator(",");
 321                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 322                 JSApplicationContextArrayPriv* priv =
 323                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 324                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 325                 if (argumentCount > 0 && JSValueIsString(context, arguments[0])) {
 326                         separator = converter->toString(arguments[0]);
 327                 }
 328                 for (size_t i = 0; i < currentApplicationContexts->size(); ++i) {
 329                         if (i != 0) {
 330                                 result += separator;
 331                         }
 332                         //FIXME : to be changed to support join
 333                         //result += currentApplicationContexts->at(i);
 334                 }
 335                 return converter->toJSValueRef(result);
 336         }
 337         Catch(WrtDeviceApis::Commons::Exception)
 338         {
 339                 LogError("error occured");
 340         }
 341         return JSDOMExceptionFactory::TypeMismatchException.make(context, exception);
 342 }
 343
 344 JSValueRef JSApplicationContextArray::pop(JSContextRef context,
 345                 JSObjectRef function,
 346                 JSObjectRef thisObject,
 347                 size_t argumentCount,
 348                 const JSValueRef arguments[],
 349                 JSValueRef* exception)
 350 {
 351         Try
 352         {
 353                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 354                 JSApplicationContextArrayPriv* priv =
 355                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 356                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 357                 if (currentApplicationContexts->size() > 0) {
 358                         ApplicationContextPtr result = currentApplicationContexts->at(
 359                                         currentApplicationContexts->size() - 1);
 360                         currentApplicationContexts->pop_back();
 361                         return converter->toJSValueRef(result);
 362                 }
 363         }
 364         Catch(WrtDeviceApis::Commons::Exception)
 365         {
 366                 LogError("error occured");
 367         }
 368         return JSValueMakeUndefined(context);
 369 }
 370
 371 JSValueRef JSApplicationContextArray::push(JSContextRef context,
 372                 JSObjectRef function,
 373                 JSObjectRef thisObject,
 374                 size_t argumentCount,
 375                 const JSValueRef arguments[],
 376                 JSValueRef* exception)
 377 {
 378         Try
 379         {
 380                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 381                 JSApplicationContextArrayPriv* priv =
 382                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 383                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 384                 for (size_t i = 0; i < argumentCount; ++i) {
 385                         currentApplicationContexts->push_back(converter->toApplicationContext(arguments[i]));
 386                 }
 387                 return converter->toJSValueRef(currentApplicationContexts->size());
 388         }
 389         Catch(WrtDeviceApis::Commons::Exception)
 390         {
 391                 LogError("error occured");
 392         }
 393         return JSDOMExceptionFactory::TypeMismatchException.make(context, exception);
 394 }
 395
 396 JSValueRef JSApplicationContextArray::reverse(JSContextRef context,
 397                 JSObjectRef function,
 398                 JSObjectRef thisObject,
 399                 size_t argumentCount,
 400                 const JSValueRef arguments[],
 401                 JSValueRef* exception)
 402 {
 403
 404         Try
 405         {
 406                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 407                 JSApplicationContextArrayPriv* priv =
 408                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 409                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 410                 std::reverse(currentApplicationContexts->begin(), currentApplicationContexts->end());
 411                 return thisObject;
 412         }
 413         Catch(WrtDeviceApis::Commons::Exception)
 414         {
 415                 LogError("error occured");
 416         }
 417         return JSValueMakeUndefined(context);
 418 }
 419
 420 JSValueRef JSApplicationContextArray::shift(JSContextRef context,
 421                 JSObjectRef function,
 422                 JSObjectRef thisObject,
 423                 size_t argumentCount,
 424                 const JSValueRef arguments[],
 425                 JSValueRef* exception)
 426 {
 427
 428         Try
 429         {
 430                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 431                 JSApplicationContextArrayPriv* priv =
 432                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 433                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 434                 if (currentApplicationContexts->size() > 0) {
 435                         ApplicationContextPtr result = currentApplicationContexts->at(0);
 436                         currentApplicationContexts->erase(currentApplicationContexts->begin());
 437                         return converter->toJSValueRef(result);
 438                 }
 439         }
 440         Catch(WrtDeviceApis::Commons::Exception)
 441         {
 442                 LogError("error occured");
 443         }
 444         return JSValueMakeUndefined(context);
 445 }
 446
 447 JSValueRef JSApplicationContextArray::slice(JSContextRef context,
 448                 JSObjectRef function,
 449                 JSObjectRef thisObject,
 450                 size_t argumentCount,
 451                 const JSValueRef arguments[],
 452                 JSValueRef* exception)
 453 {
 454
 455         Try
 456         {
 457                 if (argumentCount < 1) {
 458                         return JSValueMakeUndefined(context);
 459                 }
 460                 ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 461                 ApplicationContextArrayPtr privateDatas = ApplicationContextArrayPtr(new ApplicationContextArray());
 462                 JSApplicationContextArrayPriv *newPrivateObject = new JSApplicationContextArrayPriv(
 463                                 context,
 464                                 privateDatas);
 465                 JSValueRef result = JSObjectMake(context,
 466                                                                                  getClassRef(), newPrivateObject);
 467
 468                 //copy current privateDatas
 469                 JSApplicationContextArrayPriv* priv =
 470                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 471                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 472                 std::size_t first = converter->toSizeT(arguments[0]);
 473                 std::size_t last = currentApplicationContexts->size() - 1;
 474                 if (argumentCount > 1) {
 475                         last = converter->toSizeT(arguments[1]);
 476                         if (last >= currentApplicationContexts->size()) {
 477                                 last = currentApplicationContexts->size() - 1;
 478                         }
 479                 }
 480                 if (first < 0) {
 481                         first = 0;
 482                 }
 483                 for (size_t i = first; i <= last; ++i) {
 484                         privateDatas->push_back(currentApplicationContexts->at(i));
 485                 }
 486
 487                 return result;
 488         }
 489         Catch(WrtDeviceApis::Commons::Exception)
 490         {
 491                 LogError("error occured");
 492         }
 493         return JSDOMExceptionFactory::TypeMismatchException.make(context, exception);
 494 }
 495
 496 JSValueRef JSApplicationContextArray::sort(JSContextRef context,
 497                 JSObjectRef function,
 498                 JSObjectRef thisObject,
 499                 size_t argumentCount,
 500                 const JSValueRef arguments[],
 501                 JSValueRef* exception)
 502 {
 503
 504         Try
 505         {
 506                 //ApplicationConverterFactory::ConverterType converter = ApplicationConverterFactory::getConverter(context);
 507                 JSApplicationContextArrayPriv* priv =
 508                         static_cast<JSApplicationContextArrayPriv*>(JSObjectGetPrivate(thisObject));
 509                 ApplicationContextArrayPtr currentApplicationContexts = priv->getObject();
 510                 std::sort(currentApplicationContexts->begin(), currentApplicationContexts->end());
 511                 return thisObject;
 512         }
 513         Catch(WrtDeviceApis::Commons::Exception)
 514         {
 515                 LogError("error occured");
 516         }
 517         return JSValueMakeUndefined(context);
 518 }
 519
 520 JSValueRef JSApplicationContextArray::splice(JSContextRef context,
 521                 JSObjectRef function,
 522                 JSObjectRef thisObject,
 523                 size_t argumentCount,
 524                 const JSValueRef arguments[],
 525                 JSValueRef* exception)
 526 {
 527
 528         return JSValueMakeUndefined(context);
 529 }
 530
 531 JSValueRef JSApplicationContextArray::toString(JSContextRef context,
 532                 JSObjectRef function,
 533                 JSObjectRef thisObject,
 534                 size_t argumentCount,
 535                 const JSValueRef arguments[],
 536                 JSValueRef* exception)
 537 {
 538
 539         return join(context, function, thisObject, 0, arguments, exception);
 540 }
 541
 542 JSValueRef JSApplicationContextArray::unshift(JSContextRef context,
 543                 JSObjectRef function,
 544                 JSObjectRef thisObject,
 545                 size_t argumentCount,
 546                 const JSValueRef arguments[],
 547                 JSValueRef* exception)
 548 {
 549
 550         return JSValueMakeUndefined(context);
 551 }
 552
 553 JSValueRef JSApplicationContextArray::valueOf(JSContextRef context,
 554                 JSObjectRef function,
 555                 JSObjectRef thisObject,
 556                 size_t argumentCount,
 557                 const JSValueRef arguments[],
 558                 JSValueRef* exception)
 559 {
 560
 561         return JSValueMakeUndefined(context);
 562 }
 563 }
 564 }
 565 }