android/android_api/base/jni/JniOcRepresentation.h

   1 /*
   2 * //******************************************************************
   3 * //
   4 * // Copyright 2015 Intel Corporation.
   5 * //
   6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7 * //
   8 * // Licensed under the Apache License, Version 2.0 (the "License");
   9 * // you may not use this file except in compliance with the License.
  10 * // You may obtain a copy of the License at
  11 * //
  12 * //      http://www.apache.org/licenses/LICENSE-2.0
  13 * //
  14 * // Unless required by applicable law or agreed to in writing, software
  15 * // distributed under the License is distributed on an "AS IS" BASIS,
  16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 * // See the License for the specific language governing permissions and
  18 * // limitations under the License.
  19 * //
  20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21 */
  22 #include "JniOcStack.h"
  23 #include <AttributeValue.h>
  24
  25 #ifndef _Included_org_iotivity_base_OcRepresentation
  26 #define _Included_org_iotivity_base_OcRepresentation
  27
  28 using namespace OC;
  29
  30 class JniOcRepresentation
  31 {
  32 public:
  33     static OCRepresentation* getOCRepresentationPtr(JNIEnv *env, jobject thiz);
  34 };
  35
  36 struct JObjectConverter : boost::static_visitor < jobject >
  37 {
  38     JObjectConverter(JNIEnv *env) : env(env)
  39     {
  40     }
  41
  42     jobject operator()(const NullType&) const
  43     {
  44         return nullptr;
  45     }
  46
  47     jobject operator()(const int& val) const
  48     {
  49         jobject jobj = env->NewObject(
  50             g_cls_Integer,
  51             g_mid_Integer_ctor,
  52             static_cast<jint>(val));
  53         return jobj;
  54     }
  55     jobject operator()(const double& val) const
  56     {
  57         jobject jobj = env->NewObject(
  58             g_cls_Double,
  59             g_mid_Double_ctor,
  60             static_cast<jdouble>(val));
  61         return jobj;
  62     }
  63     jobject operator()(const bool& val) const
  64     {
  65         jobject jobj = env->NewObject(
  66             g_cls_Boolean,
  67             g_mid_Boolean_ctor,
  68             static_cast<jboolean>(val));
  69         return jobj;
  70     }
  71     jobject operator()(const std::string& val) const
  72     {
  73         jstring jstr = env->NewStringUTF(val.c_str());
  74         return static_cast<jobject>(jstr);
  75     }
  76     jobject operator()(const OC::OCRepresentation& val) const
  77     {
  78         OCRepresentation * rep = new OCRepresentation(val);
  79         jlong handle = reinterpret_cast<jlong>(rep);
  80         jobject jRepresentation = env->NewObject(
  81             g_cls_OcRepresentation,
  82             g_mid_OcRepresentation_N_ctor_bool,
  83             handle, true);
  84         if (!jRepresentation)
  85         {
  86             delete rep;
  87         }
  88         return jRepresentation;
  89     }
  90
  91     // Sequences:
  92     jobject operator()(const std::vector<int>& val) const
  93     {
  94         size_t len = val.size();
  95         jintArray jIntArray = env->NewIntArray(len);
  96         if (!jIntArray)
  97         {
  98             return nullptr;
  99         }
 100         const int* ints = &val[0];
 101         env->SetIntArrayRegion(jIntArray, 0, len, reinterpret_cast<const jint*>(ints));
 102         return jIntArray;
 103     }
 104     jobject operator()(const std::vector<double>& val) const
 105     {
 106         size_t len = val.size();
 107         jdoubleArray jDoubleArray = env->NewDoubleArray(len);
 108         if (!jDoubleArray)
 109         {
 110             return nullptr;
 111         }
 112         const double* doubles = &val[0];
 113         env->SetDoubleArrayRegion(jDoubleArray, 0, len, reinterpret_cast<const jdouble*>(doubles));
 114         return jDoubleArray;
 115     }
 116     jobject operator()(const std::vector<bool>& val) const
 117     {
 118         size_t len = val.size();
 119         jbooleanArray jBooleanArray = env->NewBooleanArray(len);
 120         if (!jBooleanArray)
 121         {
 122             return nullptr;
 123         }
 124         jboolean* booleans = new jboolean[len];
 125         for (size_t i = 0; i < len; ++i)
 126         {
 127             booleans[i] = static_cast<jboolean>(val[i]);
 128         }
 129         env->SetBooleanArrayRegion(jBooleanArray, 0, len, booleans);
 130         if (env->ExceptionCheck())
 131         {
 132             return nullptr;
 133         }
 134         env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 135         return jBooleanArray;
 136     }
 137     jobject operator()(const std::vector<std::string>& val) const
 138     {
 139         size_t len = val.size();
 140         jobjectArray strArr = env->NewObjectArray(len, g_cls_String, nullptr);
 141         if (!strArr)
 142         {
 143             return nullptr;
 144         }
 145         for (size_t i = 0; i < len; ++i)
 146         {
 147             jstring jString = env->NewStringUTF(val[i].c_str());
 148             env->SetObjectArrayElement(strArr, static_cast<jsize>(i), jString);
 149             if (env->ExceptionCheck())
 150             {
 151                 return nullptr;
 152             }
 153             env->DeleteLocalRef(jString);
 154         }
 155         return strArr;
 156     }
 157     // OCByteString and arrays:
 158     jobject operator()(const OCByteString &val) const
 159     {
 160         jbyteArray jByteArray = env->NewByteArray(val.len);
 161         if (!jByteArray)
 162         {
 163             return nullptr;
 164         }
 165         env->SetByteArrayRegion(jByteArray, 0, val.len, reinterpret_cast<const jbyte *>(val.bytes));
 166         if (env->ExceptionCheck())
 167         {
 168             env->DeleteLocalRef(jByteArray);
 169             return nullptr;
 170         }
 171         return jByteArray;
 172     }
 173     jobject operator()(const std::vector<OCByteString> &val) const
 174     {
 175         jsize lenOuter = static_cast<jsize>(val.size());
 176         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_byte1DArray, nullptr);
 177         if (!jOuterArr)
 178         {
 179             return nullptr;
 180         }
 181         for (jsize i = 0; i < lenOuter; ++i)
 182         {
 183             jbyteArray jByteArray = (jbyteArray) operator()(val[i]);
 184             if (!jByteArray)
 185             {
 186                 env->DeleteLocalRef(jOuterArr);
 187                 return nullptr;
 188             }
 189             env->SetObjectArrayElement(jOuterArr, i, static_cast<jobject>(jByteArray));
 190             if (env->ExceptionCheck())
 191             {
 192                 env->DeleteLocalRef(jByteArray);
 193                 env->DeleteLocalRef(jOuterArr);
 194                 return nullptr;
 195             }
 196             env->DeleteLocalRef(jByteArray);
 197         }
 198         return jOuterArr;
 199     }
 200     jobject operator()(const std::vector<std::vector<OCByteString>> &val) const
 201     {
 202         jsize lenOuter = static_cast<jsize>(val.size());
 203         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_byte2DArray, nullptr);
 204         if (!jOuterArr)
 205         {
 206             return nullptr;
 207         }
 208         for (jsize i = 0; i < lenOuter; ++i)
 209         {
 210             jobjectArray jMiddleArr = (jobjectArray) operator()(val[i]);
 211             if (!jMiddleArr)
 212             {
 213                 env->DeleteLocalRef(jOuterArr);
 214                 return nullptr;
 215             }
 216             env->SetObjectArrayElement(jOuterArr, i, jMiddleArr);
 217             if (env->ExceptionCheck())
 218             {
 219                 env->DeleteLocalRef(jMiddleArr);
 220                 env->DeleteLocalRef(jOuterArr);
 221                 return nullptr;
 222             }
 223             env->DeleteLocalRef(jMiddleArr);
 224         }
 225         return jOuterArr;
 226      }
 227      jobject operator()(const std::vector<std::vector<std::vector<OCByteString>>> &val) const
 228      {
 229         jsize lenOuter = static_cast<jsize>(val.size());
 230         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_byte3DArray, nullptr);
 231         if (!jOuterArr)
 232         {
 233             return nullptr;
 234         }
 235         for (jsize i = 0; i < lenOuter; ++i)
 236         {
 237             jobjectArray jMiddleArr = (jobjectArray) operator()(val[i]);
 238             if (!jMiddleArr)
 239             {
 240                 env->DeleteLocalRef(jOuterArr);
 241                 return nullptr;
 242             }
 243             env->SetObjectArrayElement(jOuterArr, i, jMiddleArr);
 244             if (env->ExceptionCheck())
 245             {
 246                 env->DeleteLocalRef(jMiddleArr);
 247                 env->DeleteLocalRef(jOuterArr);
 248                 return nullptr;
 249             }
 250             env->DeleteLocalRef(jMiddleArr);
 251         }
 252         return jOuterArr;
 253     }
 254     jobject operator()(const std::vector<OC::OCRepresentation>& val) const
 255     {
 256         jsize len = static_cast<jsize>(val.size());
 257         jobjectArray repArr = env->NewObjectArray(len, g_cls_OcRepresentation, nullptr);
 258         if (!repArr)
 259         {
 260             return nullptr;
 261         }
 262         for (jsize i = 0; i < len; ++i)
 263         {
 264             OCRepresentation* rep = new OCRepresentation(val[i]);
 265             jlong handle = reinterpret_cast<jlong>(rep);
 266             jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 267                 handle, true);
 268             if (!jRepresentation)
 269             {
 270                 delete rep;
 271                 return nullptr;
 272             }
 273             env->SetObjectArrayElement(repArr, i, jRepresentation);
 274             if (env->ExceptionCheck())
 275             {
 276                 delete rep;
 277                 return nullptr;
 278             }
 279             env->DeleteLocalRef(jRepresentation);
 280         }
 281         return repArr;
 282     }
 283     jobject operator()(const std::vector<uint8_t>& val) const
 284     {
 285         size_t len = val.size();
 286         jbyteArray jByteArray = env->NewByteArray(len);
 287         if (!jByteArray)
 288         {
 289             return nullptr;
 290         }
 291         const uint8_t* bytes = &val[0];
 292         env->SetByteArrayRegion(jByteArray, 0, len, reinterpret_cast<const jbyte*>(bytes));
 293         return jByteArray;
 294     }
 295
 296     // Nested sequences:
 297     jobject operator()(const std::vector<std::vector<int>>& val) const
 298     {
 299         jsize lenOuter = static_cast<jsize>(val.size());
 300         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int1DArray, nullptr);
 301         if (!jOuterArr)
 302         {
 303             return nullptr;
 304         }
 305         for (jsize i = 0; i < lenOuter; ++i)
 306         {
 307             size_t lenInner = val[i].size();
 308             jintArray jIntArray = env->NewIntArray(lenInner);
 309             if (!jIntArray)
 310             {
 311                 return nullptr;
 312             }
 313             const int* ints = &val[i][0];
 314             env->SetIntArrayRegion(jIntArray, 0, lenInner, reinterpret_cast<const jint*>(ints));
 315             if (env->ExceptionCheck())
 316             {
 317                 return nullptr;
 318             }
 319             env->SetObjectArrayElement(jOuterArr, i, static_cast<jobject>(jIntArray));
 320             if (env->ExceptionCheck())
 321             {
 322                 return nullptr;
 323             }
 324             env->DeleteLocalRef(jIntArray);
 325         }
 326         return jOuterArr;
 327     }
 328     jobject operator()(const std::vector<std::vector<std::vector<int>>>& val) const
 329     {
 330         jsize lenOuter = static_cast<jsize>(val.size());
 331         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int2DArray, nullptr);
 332         if (!jOuterArr)
 333         {
 334             return nullptr;
 335         }
 336
 337         for (jsize k = 0; k < lenOuter; ++k)
 338         {
 339             jsize lenMiddle = static_cast<jsize>(val[k].size());
 340             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_int1DArray, nullptr);
 341             if (!jMiddleArr)
 342             {
 343                 return nullptr;
 344             }
 345
 346             for (jsize i = 0; i < lenMiddle; ++i)
 347             {
 348                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 349                 jintArray jIntArray = env->NewIntArray(lenInner);
 350                 if (!jIntArray)
 351                 {
 352                     return nullptr;
 353                 }
 354                 const int* ints = &val[k][i][0];
 355                 env->SetIntArrayRegion(jIntArray, 0, lenInner, reinterpret_cast<const jint*>(ints));
 356                 if (env->ExceptionCheck())
 357                 {
 358                     return nullptr;
 359                 }
 360                 env->SetObjectArrayElement(jMiddleArr, i, jIntArray);
 361                 if (env->ExceptionCheck())
 362                 {
 363                     return nullptr;
 364                 }
 365                 env->DeleteLocalRef(jIntArray);
 366             }
 367             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 368             if (env->ExceptionCheck())
 369             {
 370                 return nullptr;
 371             }
 372             env->DeleteLocalRef(jMiddleArr);
 373         }
 374         return jOuterArr;
 375     }
 376
 377     jobject operator()(const std::vector<std::vector<double>>& val) const
 378     {
 379         jsize lenOuter = static_cast<jsize>(val.size());
 380         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double1DArray, nullptr);
 381         if (!jOuterArr)
 382         {
 383             return nullptr;
 384         }
 385
 386         for (jsize i = 0; i < lenOuter; ++i)
 387         {
 388             size_t lenInner = val[i].size();
 389             jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);
 390             if (!jDoubleArray)
 391             {
 392                 return nullptr;
 393             }
 394
 395             const double* doubles = &val[i][0];
 396             env->SetDoubleArrayRegion(jDoubleArray, 0, lenInner, reinterpret_cast<const jdouble*>(doubles));
 397             if (env->ExceptionCheck())
 398             {
 399                 return nullptr;
 400             }
 401             env->SetObjectArrayElement(jOuterArr, i, jDoubleArray);
 402             if (env->ExceptionCheck())
 403             {
 404                 return nullptr;
 405             }
 406             env->DeleteLocalRef(jDoubleArray);
 407         }
 408
 409         return jOuterArr;
 410     }
 411     jobject operator()(const std::vector<std::vector<std::vector<double>>>& val) const
 412     {
 413         jsize lenOuter = static_cast<jsize>(val.size());
 414         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double2DArray, nullptr);
 415         if (!jOuterArr)
 416         {
 417             return nullptr;
 418         }
 419         for (jsize k = 0; k < lenOuter; ++k)
 420         {
 421             jsize lenMiddle = static_cast<jsize>(val[k].size());
 422             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_double1DArray, nullptr);
 423             if (!jMiddleArr)
 424             {
 425                 return nullptr;
 426             }
 427             for (jsize i = 0; i < lenMiddle; ++i)
 428             {
 429                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 430                 jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);
 431                 if (!jDoubleArray)
 432                 {
 433                     return nullptr;
 434                 }
 435                 const double* doubles = &val[k][i][0];
 436                 env->SetDoubleArrayRegion(jDoubleArray, 0, lenInner, reinterpret_cast<const jdouble*>(doubles));
 437                 if (env->ExceptionCheck())
 438                 {
 439                     return nullptr;
 440                 }
 441                 env->SetObjectArrayElement(jMiddleArr, i, jDoubleArray);
 442                 if (env->ExceptionCheck())
 443                 {
 444                     return nullptr;
 445                 }
 446                 env->DeleteLocalRef(jDoubleArray);
 447             }
 448             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 449             if (env->ExceptionCheck())
 450             {
 451                 return nullptr;
 452             }
 453             env->DeleteLocalRef(jMiddleArr);
 454         }
 455         return jOuterArr;
 456     }
 457
 458     jobject operator()(const std::vector<std::vector<bool>>& val) const
 459     {
 460         jsize lenOuter = static_cast<jsize>(val.size());
 461         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean1DArray, 0);
 462         if (!jOuterArr)
 463         {
 464             return nullptr;
 465         }
 466         for (jsize i = 0; i < lenOuter; ++i)
 467         {
 468             size_t lenInner = val[i].size();
 469             jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);
 470             if (!jBooleanArray)
 471             {
 472                 return nullptr;
 473             }
 474             jboolean* booleans = new jboolean[lenInner];
 475             for (size_t j = 0; j < lenInner; ++j)
 476             {
 477                 booleans[j] = static_cast<jboolean>(val[i][j]);
 478             }
 479             env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 480             if (env->ExceptionCheck())
 481             {
 482                 return nullptr;
 483             }
 484             env->SetObjectArrayElement(jOuterArr, i, jBooleanArray);
 485             if (env->ExceptionCheck())
 486             {
 487                 return nullptr;
 488             }
 489             env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 490             if (env->ExceptionCheck())
 491             {
 492                 return nullptr;
 493             }
 494             env->DeleteLocalRef(jBooleanArray);
 495         }
 496         return jOuterArr;
 497     }
 498     jobject operator()(const std::vector<std::vector<std::vector<bool>>>& val) const
 499     {
 500         jsize lenOuter = static_cast<jsize>(val.size());
 501         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean2DArray, nullptr);
 502         if (!jOuterArr)
 503         {
 504             return nullptr;
 505         }
 506         for (jsize k = 0; k < lenOuter; ++k)
 507         {
 508             jsize lenMiddle = static_cast<jsize>(val[k].size());
 509             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_boolean1DArray, nullptr);
 510             if (!jMiddleArr)
 511             {
 512                 return nullptr;
 513             }
 514             for (jsize i = 0; i < lenMiddle; ++i)
 515             {
 516                 size_t lenInner = val[k][i].size();
 517                 jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);
 518                 jboolean* booleans = new jboolean[lenInner];
 519                 for (size_t j = 0; j < lenInner; ++j)
 520                 {
 521                     booleans[j] = val[k][i][j];
 522                 }
 523                 env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 524                 if (env->ExceptionCheck())
 525                 {
 526                     return nullptr;
 527                 }
 528                 env->SetObjectArrayElement(jMiddleArr, i, jBooleanArray);
 529                 if (env->ExceptionCheck())
 530                 {
 531                     return nullptr;
 532                 }
 533                 env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 534                 if (env->ExceptionCheck())
 535                 {
 536                     return nullptr;
 537                 }
 538                 env->DeleteLocalRef(jBooleanArray);
 539             }
 540             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 541             if (env->ExceptionCheck())
 542             {
 543                 return nullptr;
 544             }            env->DeleteLocalRef(jMiddleArr);
 545         }
 546         return jOuterArr;
 547     }
 548
 549     jobject operator()(const std::vector<std::vector<std::string>>& val) const
 550     {
 551         jsize lenOuter = static_cast<jsize>(val.size());
 552         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String1DArray, nullptr);
 553         if (!jOuterArr)
 554         {
 555             return nullptr;
 556         }
 557         for (jsize i = 0; i < lenOuter; ++i)
 558         {
 559             jsize lenInner = static_cast<jsize>(val[i].size());
 560             jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, nullptr);
 561             if (!strArr)
 562             {
 563                 return nullptr;
 564             }
 565             for (jsize j = 0; j < lenInner; ++j)
 566             {
 567                 jstring jString = env->NewStringUTF(val[i][j].c_str());
 568                 env->SetObjectArrayElement(strArr, j, jString);
 569                 if (env->ExceptionCheck())
 570                 {
 571                     return nullptr;
 572                 }
 573                 env->DeleteLocalRef(jString);
 574             }
 575             env->SetObjectArrayElement(jOuterArr, i, strArr);
 576             if (env->ExceptionCheck())
 577             {
 578                 return nullptr;
 579             }
 580             env->DeleteLocalRef(strArr);
 581         }
 582
 583         return jOuterArr;
 584     }
 585     jobject operator()(const std::vector<std::vector<std::vector<std::string>>>& val) const
 586     {
 587         jsize lenOuter = static_cast<jsize>(val.size());
 588         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String2DArray, nullptr);
 589         if (!jOuterArr)
 590         {
 591             return nullptr;
 592         }
 593         for (jsize k = 0; k < lenOuter; ++k)
 594         {
 595             jsize lenMiddle = static_cast<jsize>(val[k].size());
 596             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_String1DArray, nullptr);
 597             if (!jMiddleArr)
 598             {
 599                 return nullptr;
 600             }
 601             for (jsize i = 0; i < lenMiddle; ++i)
 602             {
 603                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 604                 jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, nullptr);
 605                 if (!strArr)
 606                 {
 607                     return nullptr;
 608                 }
 609                 for (jsize j = 0; j < lenInner; ++j)
 610                 {
 611                     jstring jString = env->NewStringUTF(val[k][i][j].c_str());
 612                     env->SetObjectArrayElement(strArr, j, jString);
 613                     if (env->ExceptionCheck())
 614                     {
 615                         return nullptr;
 616                     }
 617                     env->DeleteLocalRef(jString);
 618                 }
 619                 env->SetObjectArrayElement(jMiddleArr, i, strArr);
 620                 if (env->ExceptionCheck())
 621                 {
 622                     return nullptr;
 623                 }
 624                 env->DeleteLocalRef(strArr);
 625             }
 626             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 627             if (env->ExceptionCheck())
 628             {
 629                 return nullptr;
 630             }
 631             env->DeleteLocalRef(jMiddleArr);
 632         }
 633         return jOuterArr;
 634     }
 635
 636     jobject operator()(const std::vector<std::vector<OC::OCRepresentation>>& val) const
 637     {
 638         jsize lenOuter = static_cast<jsize>(val.size());
 639         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation1DArray, nullptr);
 640         if (!jOuterArr)
 641         {
 642             return nullptr;
 643         }
 644         for (jsize i = 0; i < lenOuter; ++i)
 645         {
 646             jsize lenInner = static_cast<jsize>(val[i].size());
 647             jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, nullptr);
 648             if (!repArr)
 649             {
 650                 return nullptr;
 651             }
 652             for (jsize j = 0; j < lenInner; ++j)
 653             {
 654                 OCRepresentation* rep = new OCRepresentation(val[i][j]);
 655                 jlong handle = reinterpret_cast<jlong>(rep);
 656                 jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 657                     handle, true);
 658                 if (!jRepresentation)
 659                 {
 660                     delete rep;
 661                     return nullptr;
 662                 }
 663                 env->SetObjectArrayElement(repArr, j, jRepresentation);
 664                 if (env->ExceptionCheck())
 665                 {
 666                     return nullptr;
 667                 }
 668                 env->DeleteLocalRef(jRepresentation);
 669             }
 670             env->SetObjectArrayElement(jOuterArr, i, repArr);
 671             if (env->ExceptionCheck())
 672             {
 673                 return nullptr;
 674             }
 675             env->DeleteLocalRef(repArr);
 676         }
 677         return jOuterArr;
 678     }
 679     jobject operator()(const std::vector<std::vector<std::vector<OC::OCRepresentation>>>& val) const
 680     {
 681         jsize lenOuter = static_cast<jsize>(val.size());
 682         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation2DArray, nullptr);
 683         if (!jOuterArr)
 684         {
 685             return nullptr;
 686         }
 687         for (jsize k = 0; k < lenOuter; ++k)
 688         {
 689             jsize lenMiddle = static_cast<jsize>(val[k].size());
 690             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_OcRepresentation1DArray, nullptr);
 691             if (!jMiddleArr)
 692             {
 693                 return nullptr;
 694             }
 695             for (jsize i = 0; i < lenMiddle; ++i)
 696             {
 697                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 698                 jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, nullptr);
 699                 if (!repArr)
 700                 {
 701                     return nullptr;
 702                 }
 703                 for (jsize j = 0; j < lenInner; ++j)
 704                 {
 705                     OCRepresentation* rep = new OCRepresentation(val[k][i][j]);
 706                     jlong handle = reinterpret_cast<jlong>(rep);
 707                     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 708                         handle, true);
 709                     if (!jRepresentation)
 710                     {
 711                         delete rep;
 712                         return nullptr;
 713                     }
 714                     env->SetObjectArrayElement(repArr, j, jRepresentation);
 715                     if (env->ExceptionCheck())
 716                     {
 717                         return nullptr;
 718                     }
 719                     env->DeleteLocalRef(jRepresentation);
 720                 }
 721                 env->SetObjectArrayElement(jMiddleArr, i, repArr);
 722                 if (env->ExceptionCheck())
 723                 {
 724                     return nullptr;
 725                 }
 726                 env->DeleteLocalRef(repArr);
 727             }
 728             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 729             if (env->ExceptionCheck())
 730             {
 731                 return nullptr;
 732             }
 733             env->DeleteLocalRef(jMiddleArr);
 734         }
 735         return jOuterArr;
 736     }
 737
 738 private:
 739     JNIEnv *env;
 740 };
 741
 742 #ifdef __cplusplus
 743 extern "C" {
 744 #endif
 745
 746     /*
 747     * Class:     org_iotivity_base_OcRepresentation
 748     * Method:    getValues
 749     * Signature: ()Ljava/util/Map;
 750     */
 751     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getValues
 752         (JNIEnv *, jobject);
 753
 754     /*
 755     * Class:     org_iotivity_base_OcRepresentation
 756     * Method:    getValueN
 757     * Signature: (Ljava/lang/String;)Ljava/lang/Object;
 758     */
 759     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getValueN
 760         (JNIEnv *, jobject, jstring);
 761
 762     /*
 763     * Class:     org_iotivity_base_OcRepresentation
 764     * Method:    setValueInteger
 765     * Signature: (Ljava/lang/String;I)V
 766     */
 767     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger
 768         (JNIEnv *, jobject, jstring, jint);
 769
 770     /*
 771     * Class:     org_iotivity_base_OcRepresentation
 772     * Method:    setValueDouble
 773     * Signature: (Ljava/lang/String;D)V
 774     */
 775     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble
 776         (JNIEnv *, jobject, jstring, jdouble);
 777
 778     /*
 779     * Class:     org_iotivity_base_OcRepresentation
 780     * Method:    setValueBoolean
 781     * Signature: (Ljava/lang/String;Z)V
 782     */
 783     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean
 784         (JNIEnv *, jobject, jstring, jboolean);
 785
 786     /*
 787     * Class:     org_iotivity_base_OcRepresentation
 788     * Method:    setValueStringN
 789     * Signature: (Ljava/lang/String;Ljava/lang/String;)V
 790     */
 791     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringN
 792         (JNIEnv *, jobject, jstring, jstring);
 793
 794     /*
 795     * Class:     org_iotivity_base_OcRepresentation
 796     * Method:    setValueRepresentation
 797     * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;)V
 798     */
 799     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation
 800         (JNIEnv *, jobject, jstring, jobject);
 801
 802     /*
 803     * Class:     org_iotivity_base_OcRepresentation
 804     * Method:    setValueIntegerArray
 805     * Signature: (Ljava/lang/String;[I)V
 806     */
 807     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueIntegerArray
 808         (JNIEnv *, jobject, jstring, jintArray);
 809
 810     /*
 811     * Class:     org_iotivity_base_OcRepresentation
 812     * Method:    setValueInteger2DArray
 813     * Signature: (Ljava/lang/String;[[I)V
 814     */
 815     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger2DArray
 816         (JNIEnv *, jobject, jstring, jobjectArray);
 817
 818     /*
 819     * Class:     org_iotivity_base_OcRepresentation
 820     * Method:    setValueInteger3DArray
 821     * Signature: (Ljava/lang/String;[[[I)V
 822     */
 823     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger3DArray
 824         (JNIEnv *, jobject, jstring, jobjectArray);
 825
 826     /*
 827     * Class:     org_iotivity_base_OcRepresentation
 828     * Method:    setValueDoubleArray
 829     * Signature: (Ljava/lang/String;[D)V
 830     */
 831     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDoubleArray
 832         (JNIEnv *, jobject, jstring, jdoubleArray);
 833
 834     /*
 835     * Class:     org_iotivity_base_OcRepresentation
 836     * Method:    setValueDouble2DArray
 837     * Signature: (Ljava/lang/String;[[D)V
 838     */
 839     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble2DArray
 840         (JNIEnv *, jobject, jstring, jobjectArray);
 841
 842     /*
 843     * Class:     org_iotivity_base_OcRepresentation
 844     * Method:    setValueDouble3DArray
 845     * Signature: (Ljava/lang/String;[[[D)V
 846     */
 847     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble3DArray
 848         (JNIEnv *, jobject, jstring, jobjectArray);
 849
 850     /*
 851     * Class:     org_iotivity_base_OcRepresentation
 852     * Method:    setValueBooleanArray
 853     * Signature: (Ljava/lang/String;[Z)V
 854     */
 855     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBooleanArray
 856         (JNIEnv *, jobject, jstring, jbooleanArray);
 857
 858     /*
 859     * Class:     org_iotivity_base_OcRepresentation
 860     * Method:    setValueBoolean2DArray
 861     * Signature: (Ljava/lang/String;[[Z)V
 862     */
 863     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean2DArray
 864         (JNIEnv *, jobject, jstring, jobjectArray);
 865
 866     /*
 867     * Class:     org_iotivity_base_OcRepresentation
 868     * Method:    setValueBoolean3DArray
 869     * Signature: (Ljava/lang/String;[[[Z)V
 870     */
 871     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean3DArray
 872         (JNIEnv *, jobject, jstring, jobjectArray);
 873
 874     /*
 875     * Class:     org_iotivity_base_OcRepresentation
 876     * Method:    setValueStringArray
 877     * Signature: (Ljava/lang/String;[Ljava/lang/String;)V
 878     */
 879     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringArray
 880         (JNIEnv *, jobject, jstring, jobjectArray);
 881
 882     /*
 883     * Class:     org_iotivity_base_OcRepresentation
 884     * Method:    setValueString2DArray
 885     * Signature: (Ljava/lang/String;[[Ljava/lang/String;)V
 886     */
 887     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString2DArray
 888         (JNIEnv *, jobject, jstring, jobjectArray);
 889
 890     /*
 891     * Class:     org_iotivity_base_OcRepresentation
 892     * Method:    setValueString3DArray
 893     * Signature: (Ljava/lang/String;[[[Ljava/lang/String;)V
 894     */
 895     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString3DArray
 896         (JNIEnv *, jobject, jstring, jobjectArray);
 897
 898     /*
 899     * Class:     org_iotivity_base_OcRepresentation
 900     * Method:    setValueRepresentationArray
 901     * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OcRepresentation;)V
 902     */
 903     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentationArray
 904         (JNIEnv *, jobject, jstring, jobjectArray);
 905
 906     /*
 907     * Class:     org_iotivity_base_OcRepresentation
 908     * Method:    setValueRepresentation2DArray
 909     * Signature: (Ljava/lang/String;[[Lorg/iotivity/base/OcRepresentation;)V
 910     */
 911     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation2DArray
 912         (JNIEnv *, jobject, jstring, jobjectArray);
 913
 914     /*
 915     * Class:     org_iotivity_base_OcRepresentation
 916     * Method:    setValueRepresentation3DArray
 917     * Signature: (Ljava/lang/String;[[[Lorg/iotivity/base/OcRepresentation;)V
 918     */
 919     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation3DArray
 920         (JNIEnv *, jobject, jstring, jobjectArray);
 921
 922     /*
 923     * Class:     org_iotivity_base_OcRepresentation
 924     * Method:    setValueByteArray
 925     * Signature: (Ljava/lang/String;[B)V
 926     */
 927     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueByteArray
 928         (JNIEnv *, jobject, jstring, jbyteArray);
 929
 930     /*
 931     * Class:     org_iotivity_base_OcRepresentation
 932     * Method:    addChild
 933     * Signature: (Lorg/iotivity/base/OcRepresentation;)V
 934     */
 935     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_addChild
 936         (JNIEnv *, jobject, jobject);
 937
 938     /*
 939     * Class:     org_iotivity_base_OcRepresentation
 940     * Method:    clearChildren
 941     * Signature: ()V
 942     */
 943     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_clearChildren
 944         (JNIEnv *, jobject);
 945
 946     /*
 947     * Class:     org_iotivity_base_OcRepresentation
 948     * Method:    getChildrenArray
 949     * Signature: ()[Lorg/iotivity/base/OcRepresentation;
 950     */
 951     JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcRepresentation_getChildrenArray
 952         (JNIEnv *, jobject);
 953
 954     /*
 955     * Class:     org_iotivity_base_OcRepresentation
 956     * Method:    getUri
 957     * Signature: ()Ljava/lang/String;
 958     */
 959     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getUri
 960         (JNIEnv *, jobject);
 961
 962     /*
 963     * Class:     org_iotivity_base_OcRepresentation
 964     * Method:    getHost
 965     * Signature: ()Ljava/lang/String;
 966     */
 967     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getHost
 968         (JNIEnv *, jobject);
 969
 970     /*
 971     * Class:     org_iotivity_base_OcRepresentation
 972     * Method:    setUri
 973     * Signature: (Ljava/lang/String;)V
 974     */
 975     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setUri
 976         (JNIEnv *, jobject, jstring);
 977
 978     /*
 979     * Class:     org_iotivity_base_OcRepresentation
 980     * Method:    getResourceTypes
 981     * Signature: ()Ljava/util/List;
 982     */
 983     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceTypes
 984         (JNIEnv *, jobject);
 985
 986     /*
 987     * Class:     org_iotivity_base_OcRepresentation
 988     * Method:    setResourceTypeArray
 989     * Signature: ([Ljava/lang/String;)V
 990     */
 991     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceTypeArray
 992         (JNIEnv *, jobject, jobjectArray);
 993
 994     /*
 995     * Class:     org_iotivity_base_OcRepresentation
 996     * Method:    getResourceInterfaces
 997     * Signature: ()Ljava/util/List;
 998     */
 999     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceInterfaces
1000         (JNIEnv *, jobject);
1001
1002     /*
1003     * Class:     org_iotivity_base_OcRepresentation
1004     * Method:    setResourceInterfaceArray
1005     * Signature: ([Ljava/lang/String;)V
1006     */
1007     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceInterfaceArray
1008         (JNIEnv *, jobject, jobjectArray);
1009
1010     /*
1011     * Class:     org_iotivity_base_OcRepresentation
1012     * Method:    isEmpty
1013     * Signature: ()Z
1014     */
1015     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isEmpty
1016         (JNIEnv *, jobject);
1017
1018     /*
1019     * Class:     org_iotivity_base_OcRepresentation
1020     * Method:    size
1021     * Signature: ()I
1022     */
1023     JNIEXPORT jint JNICALL Java_org_iotivity_base_OcRepresentation_size
1024         (JNIEnv *, jobject);
1025
1026     /*
1027     * Class:     org_iotivity_base_OcRepresentation
1028     * Method:    remove
1029     * Signature: (Ljava/lang/String;)Z
1030     */
1031     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_remove
1032         (JNIEnv *, jobject, jstring);
1033
1034     /*
1035     * Class:     org_iotivity_base_OcRepresentation
1036     * Method:    hasAttribute
1037     * Signature: (Ljava/lang/String;)Z
1038     */
1039     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_hasAttribute
1040         (JNIEnv *, jobject, jstring);
1041
1042     /*
1043     * Class:     org_iotivity_base_OcRepresentation
1044     * Method:    setNull
1045     * Signature: (Ljava/lang/String;)V
1046     */
1047     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setNull
1048         (JNIEnv *, jobject, jstring);
1049
1050     /*
1051     * Class:     org_iotivity_base_OcRepresentation
1052     * Method:    isNull
1053     * Signature: (Ljava/lang/String;)Z
1054     */
1055     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isNull
1056         (JNIEnv *, jobject, jstring);
1057
1058     /*
1059     * Class:     org_iotivity_base_OcRepresentation
1060     * Method:    create
1061     * Signature: ()V
1062     */
1063     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_create
1064         (JNIEnv *, jobject);
1065
1066     /*
1067     * Class:     org_iotivity_base_OcRepresentation
1068     * Method:    dispose
1069     * Signature: ()V
1070     */
1071     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_dispose
1072         (JNIEnv *, jobject, jboolean);
1073
1074 #ifdef __cplusplus
1075 }
1076 #endif
1077 #endif