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     jobject operator()(const std::vector<OC::OCRepresentation>& val) const
 158     {
 159         jsize len = static_cast<jsize>(val.size());
 160         jobjectArray repArr = env->NewObjectArray(len, g_cls_OcRepresentation, nullptr);
 161         if (!repArr)
 162         {
 163             return nullptr;
 164         }
 165         for (jsize i = 0; i < len; ++i)
 166         {
 167             OCRepresentation* rep = new OCRepresentation(val[i]);
 168             jlong handle = reinterpret_cast<jlong>(rep);
 169             jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 170                 handle, true);
 171             if (!jRepresentation)
 172             {
 173                 delete rep;
 174                 return nullptr;
 175             }
 176             env->SetObjectArrayElement(repArr, i, jRepresentation);
 177             if (env->ExceptionCheck())
 178             {
 179                 delete rep;
 180                 return nullptr;
 181             }
 182             env->DeleteLocalRef(jRepresentation);
 183         }
 184         return repArr;
 185     }
 186     jobject operator()(const std::vector<uint8_t>& val) const
 187     {
 188         size_t len = val.size();
 189         jbyteArray jByteArray = env->NewByteArray(len);
 190         if (!jByteArray)
 191         {
 192             return nullptr;
 193         }
 194         const uint8_t* bytes = &val[0];
 195         env->SetByteArrayRegion(jByteArray, 0, len, reinterpret_cast<const jbyte*>(bytes));
 196         return jByteArray;
 197     }
 198
 199     // Nested sequences:
 200     jobject operator()(const std::vector<std::vector<int>>& val) const
 201     {
 202         jsize lenOuter = static_cast<jsize>(val.size());
 203         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int1DArray, nullptr);
 204         if (!jOuterArr)
 205         {
 206             return nullptr;
 207         }
 208         for (jsize i = 0; i < lenOuter; ++i)
 209         {
 210             size_t lenInner = val[i].size();
 211             jintArray jIntArray = env->NewIntArray(lenInner);
 212             if (!jIntArray)
 213             {
 214                 return nullptr;
 215             }
 216             const int* ints = &val[i][0];
 217             env->SetIntArrayRegion(jIntArray, 0, lenInner, reinterpret_cast<const jint*>(ints));
 218             if (env->ExceptionCheck())
 219             {
 220                 return nullptr;
 221             }
 222             env->SetObjectArrayElement(jOuterArr, i, static_cast<jobject>(jIntArray));
 223             if (env->ExceptionCheck())
 224             {
 225                 return nullptr;
 226             }
 227             env->DeleteLocalRef(jIntArray);
 228         }
 229         return jOuterArr;
 230     }
 231     jobject operator()(const std::vector<std::vector<std::vector<int>>>& val) const
 232     {
 233         jsize lenOuter = static_cast<jsize>(val.size());
 234         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int2DArray, nullptr);
 235         if (!jOuterArr)
 236         {
 237             return nullptr;
 238         }
 239
 240         for (jsize k = 0; k < lenOuter; ++k)
 241         {
 242             jsize lenMiddle = static_cast<jsize>(val[k].size());
 243             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_int1DArray, nullptr);
 244             if (!jMiddleArr)
 245             {
 246                 return nullptr;
 247             }
 248
 249             for (jsize i = 0; i < lenMiddle; ++i)
 250             {
 251                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 252                 jintArray jIntArray = env->NewIntArray(lenInner);
 253                 if (!jIntArray)
 254                 {
 255                     return nullptr;
 256                 }
 257                 const int* ints = &val[k][i][0];
 258                 env->SetIntArrayRegion(jIntArray, 0, lenInner, reinterpret_cast<const jint*>(ints));
 259                 if (env->ExceptionCheck())
 260                 {
 261                     return nullptr;
 262                 }
 263                 env->SetObjectArrayElement(jMiddleArr, i, jIntArray);
 264                 if (env->ExceptionCheck())
 265                 {
 266                     return nullptr;
 267                 }
 268                 env->DeleteLocalRef(jIntArray);
 269             }
 270             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 271             if (env->ExceptionCheck())
 272             {
 273                 return nullptr;
 274             }
 275             env->DeleteLocalRef(jMiddleArr);
 276         }
 277         return jOuterArr;
 278     }
 279
 280     jobject operator()(const std::vector<std::vector<double>>& val) const
 281     {
 282         jsize lenOuter = static_cast<jsize>(val.size());
 283         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double1DArray, nullptr);
 284         if (!jOuterArr)
 285         {
 286             return nullptr;
 287         }
 288
 289         for (jsize i = 0; i < lenOuter; ++i)
 290         {
 291             size_t lenInner = val[i].size();
 292             jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);
 293             if (!jDoubleArray)
 294             {
 295                 return nullptr;
 296             }
 297
 298             const double* doubles = &val[i][0];
 299             env->SetDoubleArrayRegion(jDoubleArray, 0, lenInner, reinterpret_cast<const jdouble*>(doubles));
 300             if (env->ExceptionCheck())
 301             {
 302                 return nullptr;
 303             }
 304             env->SetObjectArrayElement(jOuterArr, i, jDoubleArray);
 305             if (env->ExceptionCheck())
 306             {
 307                 return nullptr;
 308             }
 309             env->DeleteLocalRef(jDoubleArray);
 310         }
 311
 312         return jOuterArr;
 313     }
 314     jobject operator()(const std::vector<std::vector<std::vector<double>>>& val) const
 315     {
 316         jsize lenOuter = static_cast<jsize>(val.size());
 317         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double2DArray, nullptr);
 318         if (!jOuterArr)
 319         {
 320             return nullptr;
 321         }
 322         for (jsize k = 0; k < lenOuter; ++k)
 323         {
 324             jsize lenMiddle = static_cast<jsize>(val[k].size());
 325             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_double1DArray, nullptr);
 326             if (!jMiddleArr)
 327             {
 328                 return nullptr;
 329             }
 330             for (jsize i = 0; i < lenMiddle; ++i)
 331             {
 332                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 333                 jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);
 334                 if (!jDoubleArray)
 335                 {
 336                     return nullptr;
 337                 }
 338                 const double* doubles = &val[k][i][0];
 339                 env->SetDoubleArrayRegion(jDoubleArray, 0, lenInner, reinterpret_cast<const jdouble*>(doubles));
 340                 if (env->ExceptionCheck())
 341                 {
 342                     return nullptr;
 343                 }
 344                 env->SetObjectArrayElement(jMiddleArr, i, jDoubleArray);
 345                 if (env->ExceptionCheck())
 346                 {
 347                     return nullptr;
 348                 }
 349                 env->DeleteLocalRef(jDoubleArray);
 350             }
 351             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 352             if (env->ExceptionCheck())
 353             {
 354                 return nullptr;
 355             }
 356             env->DeleteLocalRef(jMiddleArr);
 357         }
 358         return jOuterArr;
 359     }
 360
 361     jobject operator()(const std::vector<std::vector<bool>>& val) const
 362     {
 363         jsize lenOuter = static_cast<jsize>(val.size());
 364         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean1DArray, 0);
 365         if (!jOuterArr)
 366         {
 367             return nullptr;
 368         }
 369         for (jsize i = 0; i < lenOuter; ++i)
 370         {
 371             size_t lenInner = val[i].size();
 372             jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);
 373             if (!jBooleanArray)
 374             {
 375                 return nullptr;
 376             }
 377             jboolean* booleans = new jboolean[lenInner];
 378             for (size_t j = 0; j < lenInner; ++j)
 379             {
 380                 booleans[j] = static_cast<jboolean>(val[i][j]);
 381             }
 382             env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 383             if (env->ExceptionCheck())
 384             {
 385                 return nullptr;
 386             }
 387             env->SetObjectArrayElement(jOuterArr, i, jBooleanArray);
 388             if (env->ExceptionCheck())
 389             {
 390                 return nullptr;
 391             }
 392             env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 393             if (env->ExceptionCheck())
 394             {
 395                 return nullptr;
 396             }
 397             env->DeleteLocalRef(jBooleanArray);
 398         }
 399         return jOuterArr;
 400     }
 401     jobject operator()(const std::vector<std::vector<std::vector<bool>>>& val) const
 402     {
 403         jsize lenOuter = static_cast<jsize>(val.size());
 404         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean2DArray, nullptr);
 405         if (!jOuterArr)
 406         {
 407             return nullptr;
 408         }
 409         for (jsize k = 0; k < lenOuter; ++k)
 410         {
 411             jsize lenMiddle = static_cast<jsize>(val[k].size());
 412             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_boolean1DArray, nullptr);
 413             if (!jMiddleArr)
 414             {
 415                 return nullptr;
 416             }
 417             for (jsize i = 0; i < lenMiddle; ++i)
 418             {
 419                 size_t lenInner = val[k][i].size();
 420                 jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);
 421                 jboolean* booleans = new jboolean[lenInner];
 422                 for (size_t j = 0; j < lenInner; ++j)
 423                 {
 424                     booleans[j] = val[k][i][j];
 425                 }
 426                 env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 427                 if (env->ExceptionCheck())
 428                 {
 429                     return nullptr;
 430                 }
 431                 env->SetObjectArrayElement(jMiddleArr, i, jBooleanArray);
 432                 if (env->ExceptionCheck())
 433                 {
 434                     return nullptr;
 435                 }
 436                 env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 437                 if (env->ExceptionCheck())
 438                 {
 439                     return nullptr;
 440                 }
 441                 env->DeleteLocalRef(jBooleanArray);
 442             }
 443             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 444             if (env->ExceptionCheck())
 445             {
 446                 return nullptr;
 447             }            env->DeleteLocalRef(jMiddleArr);
 448         }
 449         return jOuterArr;
 450     }
 451
 452     jobject operator()(const std::vector<std::vector<std::string>>& val) const
 453     {
 454         jsize lenOuter = static_cast<jsize>(val.size());
 455         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String1DArray, nullptr);
 456         if (!jOuterArr)
 457         {
 458             return nullptr;
 459         }
 460         for (jsize i = 0; i < lenOuter; ++i)
 461         {
 462             jsize lenInner = static_cast<jsize>(val[i].size());
 463             jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, nullptr);
 464             if (!strArr)
 465             {
 466                 return nullptr;
 467             }
 468             for (jsize j = 0; j < lenInner; ++j)
 469             {
 470                 jstring jString = env->NewStringUTF(val[i][j].c_str());
 471                 env->SetObjectArrayElement(strArr, j, jString);
 472                 if (env->ExceptionCheck())
 473                 {
 474                     return nullptr;
 475                 }
 476                 env->DeleteLocalRef(jString);
 477             }
 478             env->SetObjectArrayElement(jOuterArr, i, strArr);
 479             if (env->ExceptionCheck())
 480             {
 481                 return nullptr;
 482             }
 483             env->DeleteLocalRef(strArr);
 484         }
 485
 486         return jOuterArr;
 487     }
 488     jobject operator()(const std::vector<std::vector<std::vector<std::string>>>& val) const
 489     {
 490         jsize lenOuter = static_cast<jsize>(val.size());
 491         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String2DArray, nullptr);
 492         if (!jOuterArr)
 493         {
 494             return nullptr;
 495         }
 496         for (jsize k = 0; k < lenOuter; ++k)
 497         {
 498             jsize lenMiddle = static_cast<jsize>(val[k].size());
 499             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_String1DArray, nullptr);
 500             if (!jMiddleArr)
 501             {
 502                 return nullptr;
 503             }
 504             for (jsize i = 0; i < lenMiddle; ++i)
 505             {
 506                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 507                 jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, nullptr);
 508                 if (!strArr)
 509                 {
 510                     return nullptr;
 511                 }
 512                 for (jsize j = 0; j < lenInner; ++j)
 513                 {
 514                     jstring jString = env->NewStringUTF(val[k][i][j].c_str());
 515                     env->SetObjectArrayElement(strArr, j, jString);
 516                     if (env->ExceptionCheck())
 517                     {
 518                         return nullptr;
 519                     }
 520                     env->DeleteLocalRef(jString);
 521                 }
 522                 env->SetObjectArrayElement(jMiddleArr, i, strArr);
 523                 if (env->ExceptionCheck())
 524                 {
 525                     return nullptr;
 526                 }
 527                 env->DeleteLocalRef(strArr);
 528             }
 529             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 530             if (env->ExceptionCheck())
 531             {
 532                 return nullptr;
 533             }
 534             env->DeleteLocalRef(jMiddleArr);
 535         }
 536         return jOuterArr;
 537     }
 538
 539     jobject operator()(const std::vector<std::vector<OC::OCRepresentation>>& val) const
 540     {
 541         jsize lenOuter = static_cast<jsize>(val.size());
 542         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation1DArray, nullptr);
 543         if (!jOuterArr)
 544         {
 545             return nullptr;
 546         }
 547         for (jsize i = 0; i < lenOuter; ++i)
 548         {
 549             jsize lenInner = static_cast<jsize>(val[i].size());
 550             jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, nullptr);
 551             if (!repArr)
 552             {
 553                 return nullptr;
 554             }
 555             for (jsize j = 0; j < lenInner; ++j)
 556             {
 557                 OCRepresentation* rep = new OCRepresentation(val[i][j]);
 558                 jlong handle = reinterpret_cast<jlong>(rep);
 559                 jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 560                     handle, true);
 561                 if (!jRepresentation)
 562                 {
 563                     delete rep;
 564                     return nullptr;
 565                 }
 566                 env->SetObjectArrayElement(repArr, j, jRepresentation);
 567                 if (env->ExceptionCheck())
 568                 {
 569                     return nullptr;
 570                 }
 571                 env->DeleteLocalRef(jRepresentation);
 572             }
 573             env->SetObjectArrayElement(jOuterArr, i, repArr);
 574             if (env->ExceptionCheck())
 575             {
 576                 return nullptr;
 577             }
 578             env->DeleteLocalRef(repArr);
 579         }
 580         return jOuterArr;
 581     }
 582     jobject operator()(const std::vector<std::vector<std::vector<OC::OCRepresentation>>>& val) const
 583     {
 584         jsize lenOuter = static_cast<jsize>(val.size());
 585         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation2DArray, nullptr);
 586         if (!jOuterArr)
 587         {
 588             return nullptr;
 589         }
 590         for (jsize k = 0; k < lenOuter; ++k)
 591         {
 592             jsize lenMiddle = static_cast<jsize>(val[k].size());
 593             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_OcRepresentation1DArray, nullptr);
 594             if (!jMiddleArr)
 595             {
 596                 return nullptr;
 597             }
 598             for (jsize i = 0; i < lenMiddle; ++i)
 599             {
 600                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 601                 jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, nullptr);
 602                 if (!repArr)
 603                 {
 604                     return nullptr;
 605                 }
 606                 for (jsize j = 0; j < lenInner; ++j)
 607                 {
 608                     OCRepresentation* rep = new OCRepresentation(val[k][i][j]);
 609                     jlong handle = reinterpret_cast<jlong>(rep);
 610                     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 611                         handle, true);
 612                     if (!jRepresentation)
 613                     {
 614                         delete rep;
 615                         return nullptr;
 616                     }
 617                     env->SetObjectArrayElement(repArr, j, jRepresentation);
 618                     if (env->ExceptionCheck())
 619                     {
 620                         return nullptr;
 621                     }
 622                     env->DeleteLocalRef(jRepresentation);
 623                 }
 624                 env->SetObjectArrayElement(jMiddleArr, i, repArr);
 625                 if (env->ExceptionCheck())
 626                 {
 627                     return nullptr;
 628                 }
 629                 env->DeleteLocalRef(repArr);
 630             }
 631             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 632             if (env->ExceptionCheck())
 633             {
 634                 return nullptr;
 635             }
 636             env->DeleteLocalRef(jMiddleArr);
 637         }
 638         return jOuterArr;
 639     }
 640
 641 private:
 642     JNIEnv *env;
 643 };
 644
 645 #ifdef __cplusplus
 646 extern "C" {
 647 #endif
 648
 649     /*
 650     * Class:     org_iotivity_base_OcRepresentation
 651     * Method:    getValues
 652     * Signature: ()Ljava/util/Map;
 653     */
 654     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getValues
 655         (JNIEnv *, jobject);
 656
 657     /*
 658     * Class:     org_iotivity_base_OcRepresentation
 659     * Method:    getValueN
 660     * Signature: (Ljava/lang/String;)Ljava/lang/Object;
 661     */
 662     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getValueN
 663         (JNIEnv *, jobject, jstring);
 664
 665     /*
 666     * Class:     org_iotivity_base_OcRepresentation
 667     * Method:    setValueInteger
 668     * Signature: (Ljava/lang/String;I)V
 669     */
 670     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger
 671         (JNIEnv *, jobject, jstring, jint);
 672
 673     /*
 674     * Class:     org_iotivity_base_OcRepresentation
 675     * Method:    setValueDouble
 676     * Signature: (Ljava/lang/String;D)V
 677     */
 678     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble
 679         (JNIEnv *, jobject, jstring, jdouble);
 680
 681     /*
 682     * Class:     org_iotivity_base_OcRepresentation
 683     * Method:    setValueBoolean
 684     * Signature: (Ljava/lang/String;Z)V
 685     */
 686     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean
 687         (JNIEnv *, jobject, jstring, jboolean);
 688
 689     /*
 690     * Class:     org_iotivity_base_OcRepresentation
 691     * Method:    setValueStringN
 692     * Signature: (Ljava/lang/String;Ljava/lang/String;)V
 693     */
 694     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringN
 695         (JNIEnv *, jobject, jstring, jstring);
 696
 697     /*
 698     * Class:     org_iotivity_base_OcRepresentation
 699     * Method:    setValueRepresentation
 700     * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;)V
 701     */
 702     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation
 703         (JNIEnv *, jobject, jstring, jobject);
 704
 705     /*
 706     * Class:     org_iotivity_base_OcRepresentation
 707     * Method:    setValueIntegerArray
 708     * Signature: (Ljava/lang/String;[I)V
 709     */
 710     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueIntegerArray
 711         (JNIEnv *, jobject, jstring, jintArray);
 712
 713     /*
 714     * Class:     org_iotivity_base_OcRepresentation
 715     * Method:    setValueInteger2DArray
 716     * Signature: (Ljava/lang/String;[[I)V
 717     */
 718     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger2DArray
 719         (JNIEnv *, jobject, jstring, jobjectArray);
 720
 721     /*
 722     * Class:     org_iotivity_base_OcRepresentation
 723     * Method:    setValueInteger3DArray
 724     * Signature: (Ljava/lang/String;[[[I)V
 725     */
 726     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger3DArray
 727         (JNIEnv *, jobject, jstring, jobjectArray);
 728
 729     /*
 730     * Class:     org_iotivity_base_OcRepresentation
 731     * Method:    setValueDoubleArray
 732     * Signature: (Ljava/lang/String;[D)V
 733     */
 734     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDoubleArray
 735         (JNIEnv *, jobject, jstring, jdoubleArray);
 736
 737     /*
 738     * Class:     org_iotivity_base_OcRepresentation
 739     * Method:    setValueDouble2DArray
 740     * Signature: (Ljava/lang/String;[[D)V
 741     */
 742     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble2DArray
 743         (JNIEnv *, jobject, jstring, jobjectArray);
 744
 745     /*
 746     * Class:     org_iotivity_base_OcRepresentation
 747     * Method:    setValueDouble3DArray
 748     * Signature: (Ljava/lang/String;[[[D)V
 749     */
 750     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble3DArray
 751         (JNIEnv *, jobject, jstring, jobjectArray);
 752
 753     /*
 754     * Class:     org_iotivity_base_OcRepresentation
 755     * Method:    setValueBooleanArray
 756     * Signature: (Ljava/lang/String;[Z)V
 757     */
 758     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBooleanArray
 759         (JNIEnv *, jobject, jstring, jbooleanArray);
 760
 761     /*
 762     * Class:     org_iotivity_base_OcRepresentation
 763     * Method:    setValueBoolean2DArray
 764     * Signature: (Ljava/lang/String;[[Z)V
 765     */
 766     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean2DArray
 767         (JNIEnv *, jobject, jstring, jobjectArray);
 768
 769     /*
 770     * Class:     org_iotivity_base_OcRepresentation
 771     * Method:    setValueBoolean3DArray
 772     * Signature: (Ljava/lang/String;[[[Z)V
 773     */
 774     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean3DArray
 775         (JNIEnv *, jobject, jstring, jobjectArray);
 776
 777     /*
 778     * Class:     org_iotivity_base_OcRepresentation
 779     * Method:    setValueStringArray
 780     * Signature: (Ljava/lang/String;[Ljava/lang/String;)V
 781     */
 782     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringArray
 783         (JNIEnv *, jobject, jstring, jobjectArray);
 784
 785     /*
 786     * Class:     org_iotivity_base_OcRepresentation
 787     * Method:    setValueString2DArray
 788     * Signature: (Ljava/lang/String;[[Ljava/lang/String;)V
 789     */
 790     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString2DArray
 791         (JNIEnv *, jobject, jstring, jobjectArray);
 792
 793     /*
 794     * Class:     org_iotivity_base_OcRepresentation
 795     * Method:    setValueString3DArray
 796     * Signature: (Ljava/lang/String;[[[Ljava/lang/String;)V
 797     */
 798     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString3DArray
 799         (JNIEnv *, jobject, jstring, jobjectArray);
 800
 801     /*
 802     * Class:     org_iotivity_base_OcRepresentation
 803     * Method:    setValueRepresentationArray
 804     * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OcRepresentation;)V
 805     */
 806     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentationArray
 807         (JNIEnv *, jobject, jstring, jobjectArray);
 808
 809     /*
 810     * Class:     org_iotivity_base_OcRepresentation
 811     * Method:    setValueRepresentation2DArray
 812     * Signature: (Ljava/lang/String;[[Lorg/iotivity/base/OcRepresentation;)V
 813     */
 814     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation2DArray
 815         (JNIEnv *, jobject, jstring, jobjectArray);
 816
 817     /*
 818     * Class:     org_iotivity_base_OcRepresentation
 819     * Method:    setValueRepresentation3DArray
 820     * Signature: (Ljava/lang/String;[[[Lorg/iotivity/base/OcRepresentation;)V
 821     */
 822     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation3DArray
 823         (JNIEnv *, jobject, jstring, jobjectArray);
 824
 825     /*
 826     * Class:     org_iotivity_base_OcRepresentation
 827     * Method:    setValueByteArray
 828     * Signature: (Ljava/lang/String;[B)V
 829     */
 830     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueByteArray
 831         (JNIEnv *, jobject, jstring, jbyteArray);
 832
 833     /*
 834     * Class:     org_iotivity_base_OcRepresentation
 835     * Method:    addChild
 836     * Signature: (Lorg/iotivity/base/OcRepresentation;)V
 837     */
 838     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_addChild
 839         (JNIEnv *, jobject, jobject);
 840
 841     /*
 842     * Class:     org_iotivity_base_OcRepresentation
 843     * Method:    clearChildren
 844     * Signature: ()V
 845     */
 846     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_clearChildren
 847         (JNIEnv *, jobject);
 848
 849     /*
 850     * Class:     org_iotivity_base_OcRepresentation
 851     * Method:    getChildrenArray
 852     * Signature: ()[Lorg/iotivity/base/OcRepresentation;
 853     */
 854     JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcRepresentation_getChildrenArray
 855         (JNIEnv *, jobject);
 856
 857     /*
 858     * Class:     org_iotivity_base_OcRepresentation
 859     * Method:    getUri
 860     * Signature: ()Ljava/lang/String;
 861     */
 862     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getUri
 863         (JNIEnv *, jobject);
 864
 865     /*
 866     * Class:     org_iotivity_base_OcRepresentation
 867     * Method:    getHost
 868     * Signature: ()Ljava/lang/String;
 869     */
 870     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getHost
 871         (JNIEnv *, jobject);
 872
 873     /*
 874     * Class:     org_iotivity_base_OcRepresentation
 875     * Method:    setUri
 876     * Signature: (Ljava/lang/String;)V
 877     */
 878     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setUri
 879         (JNIEnv *, jobject, jstring);
 880
 881     /*
 882     * Class:     org_iotivity_base_OcRepresentation
 883     * Method:    getResourceTypes
 884     * Signature: ()Ljava/util/List;
 885     */
 886     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceTypes
 887         (JNIEnv *, jobject);
 888
 889     /*
 890     * Class:     org_iotivity_base_OcRepresentation
 891     * Method:    setResourceTypeArray
 892     * Signature: ([Ljava/lang/String;)V
 893     */
 894     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceTypeArray
 895         (JNIEnv *, jobject, jobjectArray);
 896
 897     /*
 898     * Class:     org_iotivity_base_OcRepresentation
 899     * Method:    getResourceInterfaces
 900     * Signature: ()Ljava/util/List;
 901     */
 902     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceInterfaces
 903         (JNIEnv *, jobject);
 904
 905     /*
 906     * Class:     org_iotivity_base_OcRepresentation
 907     * Method:    setResourceInterfaceArray
 908     * Signature: ([Ljava/lang/String;)V
 909     */
 910     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceInterfaceArray
 911         (JNIEnv *, jobject, jobjectArray);
 912
 913     /*
 914     * Class:     org_iotivity_base_OcRepresentation
 915     * Method:    isEmpty
 916     * Signature: ()Z
 917     */
 918     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isEmpty
 919         (JNIEnv *, jobject);
 920
 921     /*
 922     * Class:     org_iotivity_base_OcRepresentation
 923     * Method:    size
 924     * Signature: ()I
 925     */
 926     JNIEXPORT jint JNICALL Java_org_iotivity_base_OcRepresentation_size
 927         (JNIEnv *, jobject);
 928
 929     /*
 930     * Class:     org_iotivity_base_OcRepresentation
 931     * Method:    remove
 932     * Signature: (Ljava/lang/String;)Z
 933     */
 934     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_remove
 935         (JNIEnv *, jobject, jstring);
 936
 937     /*
 938     * Class:     org_iotivity_base_OcRepresentation
 939     * Method:    hasAttribute
 940     * Signature: (Ljava/lang/String;)Z
 941     */
 942     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_hasAttribute
 943         (JNIEnv *, jobject, jstring);
 944
 945     /*
 946     * Class:     org_iotivity_base_OcRepresentation
 947     * Method:    setNull
 948     * Signature: (Ljava/lang/String;)V
 949     */
 950     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setNull
 951         (JNIEnv *, jobject, jstring);
 952
 953     /*
 954     * Class:     org_iotivity_base_OcRepresentation
 955     * Method:    isNull
 956     * Signature: (Ljava/lang/String;)Z
 957     */
 958     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isNull
 959         (JNIEnv *, jobject, jstring);
 960
 961     /*
 962     * Class:     org_iotivity_base_OcRepresentation
 963     * Method:    create
 964     * Signature: ()V
 965     */
 966     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_create
 967         (JNIEnv *, jobject);
 968
 969     /*
 970     * Class:     org_iotivity_base_OcRepresentation
 971     * Method:    dispose
 972     * Signature: ()V
 973     */
 974     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_dispose
 975         (JNIEnv *, jobject, jboolean);
 976
 977 #ifdef __cplusplus
 978 }
 979 #endif
 980 #endif