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     jobject operator()(const NullType&) const { return nullptr; }
  41     jobject operator()(const int& val) const
  42     {
  43         jobject jobj = env->NewObject(
  44             g_cls_Integer,
  45             g_mid_Integer_ctor,
  46             static_cast<jint>(val));
  47         return jobj;
  48     }
  49     jobject operator()(const double& val) const
  50     {
  51         jobject jobj = env->NewObject(
  52             g_cls_Double,
  53             g_mid_Double_ctor,
  54             static_cast<jdouble>(val));
  55         return jobj;
  56     }
  57     jobject operator()(const bool& val) const
  58     {
  59         jobject jobj = env->NewObject(
  60             g_cls_Boolean,
  61             g_mid_Boolean_ctor,
  62             static_cast<jboolean>(val));
  63         return jobj;
  64     }
  65     jobject operator()(const std::string& val) const
  66     {
  67         jstring jstr = env->NewStringUTF(val.c_str());
  68         return static_cast<jobject>(jstr);
  69     }
  70     jobject operator()(const OC::OCRepresentation& val) const
  71     {
  72         OCRepresentation * rep = new OCRepresentation(val);
  73         jlong handle = reinterpret_cast<jlong>(rep);
  74         jobject jRepresentation = env->NewObject(
  75             g_cls_OcRepresentation,
  76             g_mid_OcRepresentation_N_ctor_bool,
  77             handle, true);
  78         if (!jRepresentation)
  79         {
  80             delete rep;
  81         }
  82         return jRepresentation;
  83     }
  84
  85     // Sequences:
  86     jobject operator()(const std::vector<int>& val) const
  87     {
  88         size_t len = val.size();
  89         jintArray jIntArray = env->NewIntArray(len);
  90         if (!jIntArray) return nullptr;
  91         const int* ints = &val[0];
  92         env->SetIntArrayRegion(jIntArray, 0, len, reinterpret_cast<const jint*>(ints));
  93         return jIntArray;
  94     }
  95     jobject operator()(const std::vector<double>& val) const
  96     {
  97         size_t len = val.size();
  98         jdoubleArray jDoubleArray = env->NewDoubleArray(len);
  99         if (!jDoubleArray) return nullptr;
 100         const double* doubles = &val[0];
 101         env->SetDoubleArrayRegion(jDoubleArray, 0, len, reinterpret_cast<const jdouble*>(doubles));
 102         return jDoubleArray;
 103     }
 104     jobject operator()(const std::vector<bool>& val) const
 105     {
 106         size_t len = val.size();
 107         jbooleanArray jBooleanArray = env->NewBooleanArray(len);
 108         if (!jBooleanArray) return nullptr;
 109         jboolean* booleans = new jboolean[len];
 110         for (size_t i = 0; i < len; ++i) {
 111             booleans[i] = static_cast<jboolean>(val[i]);
 112         }
 113         env->SetBooleanArrayRegion(jBooleanArray, 0, len, booleans);
 114         if (env->ExceptionCheck()) return nullptr;
 115         env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 116         return jBooleanArray;
 117     }
 118     jobject operator()(const std::vector<std::string>& val) const
 119     {
 120         size_t len = val.size();
 121         jobjectArray strArr = env->NewObjectArray(len, g_cls_String, nullptr);
 122         if (!strArr) return nullptr;
 123         for (size_t i = 0; i < len; ++i)
 124         {
 125             jstring jString = env->NewStringUTF(val[i].c_str());
 126             env->SetObjectArrayElement(strArr, static_cast<jsize>(i), jString);
 127             if (env->ExceptionCheck()) return nullptr;
 128             env->DeleteLocalRef(jString);
 129         }
 130         return strArr;
 131     }
 132     jobject operator()(const std::vector<OC::OCRepresentation>& val) const
 133     {
 134         jsize len = static_cast<jsize>(val.size());
 135         jobjectArray repArr = env->NewObjectArray(len, g_cls_OcRepresentation, nullptr);
 136         if (!repArr) return nullptr;
 137         for (jsize i = 0; i < len; ++i)
 138         {
 139             OCRepresentation* rep = new OCRepresentation(val[i]);
 140             jlong handle = reinterpret_cast<jlong>(rep);
 141             jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 142                 handle, true);
 143             if (!jRepresentation)
 144             {
 145                 delete rep;
 146                 return nullptr;
 147             }
 148             env->SetObjectArrayElement(repArr, i, jRepresentation);
 149             if (env->ExceptionCheck())
 150             {
 151                 delete rep;
 152                 return nullptr;
 153             }
 154             env->DeleteLocalRef(jRepresentation);
 155         }
 156         return repArr;
 157     }
 158
 159     // Nested sequences:
 160     jobject operator()(const std::vector<std::vector<int>>& val) const
 161     {
 162         jsize lenOuter = static_cast<jsize>(val.size());
 163         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int1DArray, nullptr);
 164         if (!jOuterArr)
 165         {
 166             return nullptr;
 167         }
 168         for (jsize i = 0; i < lenOuter; ++i)
 169         {
 170             size_t lenInner = val[i].size();
 171             jintArray jIntArray = env->NewIntArray(lenInner);
 172             if (!jIntArray) return nullptr;
 173             const int* ints = &val[i][0];
 174             env->SetIntArrayRegion(jIntArray, 0, lenInner, reinterpret_cast<const jint*>(ints));
 175             if (env->ExceptionCheck()) return nullptr;
 176             env->SetObjectArrayElement(jOuterArr, i, static_cast<jobject>(jIntArray));
 177             if (env->ExceptionCheck()) return nullptr;
 178             env->DeleteLocalRef(jIntArray);
 179         }
 180         return jOuterArr;
 181     }
 182     jobject operator()(const std::vector<std::vector<std::vector<int>>>& val) const
 183     {
 184         jsize lenOuter = static_cast<jsize>(val.size());
 185         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int2DArray, nullptr);
 186         if (!jOuterArr) return nullptr;
 187         for (jsize k = 0; k < lenOuter; ++k)
 188         {
 189             jsize lenMiddle = static_cast<jsize>(val[k].size());
 190             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_int1DArray, nullptr);
 191             if (!jMiddleArr) return nullptr;
 192             for (jsize i = 0; i < lenMiddle; ++i)
 193             {
 194                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 195                 jintArray jIntArray = env->NewIntArray(lenInner);
 196                 if (!jIntArray) return nullptr;
 197                 const int* ints = &val[k][i][0];
 198                 env->SetIntArrayRegion(jIntArray, 0, lenInner, reinterpret_cast<const jint*>(ints));
 199                 if (env->ExceptionCheck()) return nullptr;
 200                 env->SetObjectArrayElement(jMiddleArr, i, jIntArray);
 201                 if (env->ExceptionCheck()) return nullptr;
 202                 env->DeleteLocalRef(jIntArray);
 203             }
 204             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 205             if (env->ExceptionCheck()) return nullptr;
 206             env->DeleteLocalRef(jMiddleArr);
 207         }
 208         return jOuterArr;
 209     }
 210
 211     jobject operator()(const std::vector<std::vector<double>>& val) const
 212     {
 213         jsize lenOuter = static_cast<jsize>(val.size());
 214         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double1DArray, nullptr);
 215         if (!jOuterArr) return nullptr;
 216         for (jsize i = 0; i < lenOuter; ++i)
 217         {
 218             size_t lenInner = val[i].size();
 219             jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);
 220             if (!jDoubleArray) return nullptr;
 221             const double* doubles = &val[i][0];
 222             env->SetDoubleArrayRegion(jDoubleArray, 0, lenInner, reinterpret_cast<const jdouble*>(doubles));
 223             if (env->ExceptionCheck()) return nullptr;
 224             env->SetObjectArrayElement(jOuterArr, i, jDoubleArray);
 225             if (env->ExceptionCheck()) return nullptr;
 226             env->DeleteLocalRef(jDoubleArray);
 227         }
 228
 229         return jOuterArr;
 230     }
 231     jobject operator()(const std::vector<std::vector<std::vector<double>>>& val) const
 232     {
 233         jsize lenOuter = static_cast<jsize>(val.size());
 234         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double2DArray, nullptr);
 235         if (!jOuterArr) return nullptr;
 236         for (jsize k = 0; k < lenOuter; ++k)
 237         {
 238             jsize lenMiddle = static_cast<jsize>(val[k].size());
 239             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_double1DArray, nullptr);
 240             if (!jMiddleArr) return nullptr;
 241             for (jsize i = 0; i < lenMiddle; ++i)
 242             {
 243                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 244                 jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);
 245                 if (!jDoubleArray) return nullptr;
 246                 const double* doubles = &val[k][i][0];
 247                 env->SetDoubleArrayRegion(jDoubleArray, 0, lenInner, reinterpret_cast<const jdouble*>(doubles));
 248                 if (env->ExceptionCheck()) return nullptr;
 249                 env->SetObjectArrayElement(jMiddleArr, i, jDoubleArray);
 250                 if (env->ExceptionCheck()) return nullptr;
 251                 env->DeleteLocalRef(jDoubleArray);
 252             }
 253             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 254             if (env->ExceptionCheck()) return nullptr;
 255             env->DeleteLocalRef(jMiddleArr);
 256         }
 257         return jOuterArr;
 258     }
 259
 260     jobject operator()(const std::vector<std::vector<bool>>& val) const
 261     {
 262         jsize lenOuter = static_cast<jsize>(val.size());
 263         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean1DArray, 0);
 264         if (!jOuterArr) return nullptr;
 265         for (jsize i = 0; i < lenOuter; ++i)
 266         {
 267             size_t lenInner = val[i].size();
 268             jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);
 269             if (!jBooleanArray) return nullptr;
 270             jboolean* booleans = new jboolean[lenInner];
 271             for (size_t j = 0; j < lenInner; ++j) {
 272                 booleans[j] = static_cast<jboolean>(val[i][j]);
 273             }
 274             env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 275             if (env->ExceptionCheck()) return nullptr;
 276             env->SetObjectArrayElement(jOuterArr, i, jBooleanArray);
 277             if (env->ExceptionCheck()) return nullptr;
 278             env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 279             if (env->ExceptionCheck()) return nullptr;
 280             env->DeleteLocalRef(jBooleanArray);
 281         }
 282         return jOuterArr;
 283     }
 284     jobject operator()(const std::vector<std::vector<std::vector<bool>>>& val) const
 285     {
 286         jsize lenOuter = static_cast<jsize>(val.size());
 287         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean2DArray, nullptr);
 288         if (!jOuterArr) return nullptr;
 289         for (jsize k = 0; k < lenOuter; ++k)
 290         {
 291             jsize lenMiddle = static_cast<jsize>(val[k].size());
 292             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_boolean1DArray, nullptr);
 293             if (!jMiddleArr) return nullptr;
 294             for (jsize i = 0; i < lenMiddle; ++i)
 295             {
 296                 size_t lenInner = val[k][i].size();
 297                 jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);
 298                 jboolean* booleans = new jboolean[lenInner];
 299                 for (size_t j = 0; j < lenInner; ++j) {
 300                     booleans[j] = val[k][i][j];
 301                 }
 302                 env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 303                 if (env->ExceptionCheck()) return nullptr;
 304                 env->SetObjectArrayElement(jMiddleArr, i, jBooleanArray);
 305                 if (env->ExceptionCheck()) return nullptr;
 306                 env->ReleaseBooleanArrayElements(jBooleanArray, booleans, 0);
 307                 if (env->ExceptionCheck()) return nullptr;
 308                 env->DeleteLocalRef(jBooleanArray);
 309             }
 310             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 311             if (env->ExceptionCheck()) return nullptr;
 312             env->DeleteLocalRef(jMiddleArr);
 313         }
 314         return jOuterArr;
 315     }
 316
 317     jobject operator()(const std::vector<std::vector<std::string>>& val) const
 318     {
 319         jsize lenOuter = static_cast<jsize>(val.size());
 320         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String1DArray, nullptr);
 321         if (!jOuterArr) return nullptr;
 322         for (jsize i = 0; i < lenOuter; ++i)
 323         {
 324             jsize lenInner = static_cast<jsize>(val[i].size());
 325             jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, nullptr);
 326             if (!strArr) return nullptr;
 327             for (jsize j = 0; j < lenInner; ++j)
 328             {
 329                 jstring jString = env->NewStringUTF(val[i][j].c_str());
 330                 env->SetObjectArrayElement(strArr, j, jString);
 331                 if (env->ExceptionCheck()) return nullptr;
 332                 env->DeleteLocalRef(jString);
 333             }
 334             env->SetObjectArrayElement(jOuterArr, i, strArr);
 335             if (env->ExceptionCheck()) return nullptr;
 336             env->DeleteLocalRef(strArr);
 337         }
 338
 339         return jOuterArr;
 340     }
 341     jobject operator()(const std::vector<std::vector<std::vector<std::string>>>& val) const
 342     {
 343         jsize lenOuter = static_cast<jsize>(val.size());
 344         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String2DArray, nullptr);
 345         if (!jOuterArr) return nullptr;
 346         for (jsize k = 0; k < lenOuter; ++k)
 347         {
 348             jsize lenMiddle = static_cast<jsize>(val[k].size());
 349             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_String1DArray, nullptr);
 350             if (!jMiddleArr) return nullptr;
 351             for (jsize i = 0; i < lenMiddle; ++i)
 352             {
 353                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 354                 jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, nullptr);
 355                 if (!strArr) return nullptr;
 356                 for (jsize j = 0; j < lenInner; ++j)
 357                 {
 358                     jstring jString = env->NewStringUTF(val[k][i][j].c_str());
 359                     env->SetObjectArrayElement(strArr, j, jString);
 360                     if (env->ExceptionCheck()) return nullptr;
 361                     env->DeleteLocalRef(jString);
 362                 }
 363                 env->SetObjectArrayElement(jMiddleArr, i, strArr);
 364                 if (env->ExceptionCheck()) return nullptr;
 365                 env->DeleteLocalRef(strArr);
 366             }
 367             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 368             if (env->ExceptionCheck()) return nullptr;
 369             env->DeleteLocalRef(jMiddleArr);
 370         }
 371         return jOuterArr;
 372     }
 373
 374     jobject operator()(const std::vector<std::vector<OC::OCRepresentation>>& val) const
 375     {
 376         jsize lenOuter = static_cast<jsize>(val.size());
 377         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation1DArray, nullptr);
 378         if (!jOuterArr) return nullptr;
 379         for (jsize i = 0; i < lenOuter; ++i)
 380         {
 381             jsize lenInner = static_cast<jsize>(val[i].size());
 382             jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, nullptr);
 383             if (!repArr) return nullptr;
 384             for (jsize j = 0; j < lenInner; ++j)
 385             {
 386                 OCRepresentation* rep = new OCRepresentation(val[i][j]);
 387                 jlong handle = reinterpret_cast<jlong>(rep);
 388                 jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 389                     handle, true);
 390                 if (!jRepresentation)
 391                 {
 392                     delete rep;
 393                     return nullptr;
 394                 }
 395                 env->SetObjectArrayElement(repArr, j, jRepresentation);
 396                 if (env->ExceptionCheck()) return nullptr;
 397                 env->DeleteLocalRef(jRepresentation);
 398             }
 399             env->SetObjectArrayElement(jOuterArr, i, repArr);
 400             if (env->ExceptionCheck()) return nullptr;
 401             env->DeleteLocalRef(repArr);
 402         }
 403         return jOuterArr;
 404     }
 405     jobject operator()(const std::vector<std::vector<std::vector<OC::OCRepresentation>>>& val) const
 406     {
 407         jsize lenOuter = static_cast<jsize>(val.size());
 408         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation2DArray, nullptr);
 409         if (!jOuterArr) return nullptr;
 410         for (jsize k = 0; k < lenOuter; ++k)
 411         {
 412             jsize lenMiddle = static_cast<jsize>(val[k].size());
 413             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_OcRepresentation1DArray, nullptr);
 414             if (!jMiddleArr) return nullptr;
 415             for (jsize i = 0; i < lenMiddle; ++i)
 416             {
 417                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 418                 jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, nullptr);
 419                 if (!repArr) return nullptr;
 420                 for (jsize j = 0; j < lenInner; ++j)
 421                 {
 422                     OCRepresentation* rep = new OCRepresentation(val[k][i][j]);
 423                     jlong handle = reinterpret_cast<jlong>(rep);
 424                     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,
 425                         handle, true);
 426                     if (!jRepresentation)
 427                     {
 428                         delete rep;
 429                         return nullptr;
 430                     }
 431                     env->SetObjectArrayElement(repArr, j, jRepresentation);
 432                     if (env->ExceptionCheck()) return nullptr;
 433                     env->DeleteLocalRef(jRepresentation);
 434                 }
 435                 env->SetObjectArrayElement(jMiddleArr, i, repArr);
 436                 if (env->ExceptionCheck()) return nullptr;
 437                 env->DeleteLocalRef(repArr);
 438             }
 439             env->SetObjectArrayElement(jOuterArr, k, jMiddleArr);
 440             if (env->ExceptionCheck()) return nullptr;
 441             env->DeleteLocalRef(jMiddleArr);
 442         }
 443         return jOuterArr;
 444     }
 445
 446 private:
 447     JNIEnv *env;
 448 };
 449
 450 #ifdef __cplusplus
 451 extern "C" {
 452 #endif
 453
 454     /*
 455     * Class:     org_iotivity_base_OcRepresentation
 456     * Method:    getValueN
 457     * Signature: (Ljava/lang/String;)Ljava/lang/Object;
 458     */
 459     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getValueN
 460         (JNIEnv *, jobject, jstring);
 461
 462     /*
 463     * Class:     org_iotivity_base_OcRepresentation
 464     * Method:    setValueInteger
 465     * Signature: (Ljava/lang/String;I)V
 466     */
 467     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger
 468         (JNIEnv *, jobject, jstring, jint);
 469
 470     /*
 471     * Class:     org_iotivity_base_OcRepresentation
 472     * Method:    setValueDouble
 473     * Signature: (Ljava/lang/String;D)V
 474     */
 475     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble
 476         (JNIEnv *, jobject, jstring, jdouble);
 477
 478     /*
 479     * Class:     org_iotivity_base_OcRepresentation
 480     * Method:    setValueBoolean
 481     * Signature: (Ljava/lang/String;Z)V
 482     */
 483     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean
 484         (JNIEnv *, jobject, jstring, jboolean);
 485
 486     /*
 487     * Class:     org_iotivity_base_OcRepresentation
 488     * Method:    setValueStringN
 489     * Signature: (Ljava/lang/String;Ljava/lang/String;)V
 490     */
 491     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringN
 492         (JNIEnv *, jobject, jstring, jstring);
 493
 494     /*
 495     * Class:     org_iotivity_base_OcRepresentation
 496     * Method:    setValueRepresentation
 497     * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;)V
 498     */
 499     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation
 500         (JNIEnv *, jobject, jstring, jobject);
 501
 502     /*
 503     * Class:     org_iotivity_base_OcRepresentation
 504     * Method:    setValueIntegerArray
 505     * Signature: (Ljava/lang/String;[I)V
 506     */
 507     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueIntegerArray
 508         (JNIEnv *, jobject, jstring, jintArray);
 509
 510     /*
 511     * Class:     org_iotivity_base_OcRepresentation
 512     * Method:    setValueInteger2DArray
 513     * Signature: (Ljava/lang/String;[[I)V
 514     */
 515     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger2DArray
 516         (JNIEnv *, jobject, jstring, jobjectArray);
 517
 518     /*
 519     * Class:     org_iotivity_base_OcRepresentation
 520     * Method:    setValueInteger3DArray
 521     * Signature: (Ljava/lang/String;[[[I)V
 522     */
 523     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger3DArray
 524         (JNIEnv *, jobject, jstring, jobjectArray);
 525
 526     /*
 527     * Class:     org_iotivity_base_OcRepresentation
 528     * Method:    setValueDoubleArray
 529     * Signature: (Ljava/lang/String;[D)V
 530     */
 531     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDoubleArray
 532         (JNIEnv *, jobject, jstring, jdoubleArray);
 533
 534     /*
 535     * Class:     org_iotivity_base_OcRepresentation
 536     * Method:    setValueDouble2DArray
 537     * Signature: (Ljava/lang/String;[[D)V
 538     */
 539     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble2DArray
 540         (JNIEnv *, jobject, jstring, jobjectArray);
 541
 542     /*
 543     * Class:     org_iotivity_base_OcRepresentation
 544     * Method:    setValueDouble3DArray
 545     * Signature: (Ljava/lang/String;[[[D)V
 546     */
 547     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble3DArray
 548         (JNIEnv *, jobject, jstring, jobjectArray);
 549
 550     /*
 551     * Class:     org_iotivity_base_OcRepresentation
 552     * Method:    setValueBooleanArray
 553     * Signature: (Ljava/lang/String;[Z)V
 554     */
 555     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBooleanArray
 556         (JNIEnv *, jobject, jstring, jbooleanArray);
 557
 558     /*
 559     * Class:     org_iotivity_base_OcRepresentation
 560     * Method:    setValueBoolean2DArray
 561     * Signature: (Ljava/lang/String;[[Z)V
 562     */
 563     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean2DArray
 564         (JNIEnv *, jobject, jstring, jobjectArray);
 565
 566     /*
 567     * Class:     org_iotivity_base_OcRepresentation
 568     * Method:    setValueBoolean3DArray
 569     * Signature: (Ljava/lang/String;[[[Z)V
 570     */
 571     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean3DArray
 572         (JNIEnv *, jobject, jstring, jobjectArray);
 573
 574     /*
 575     * Class:     org_iotivity_base_OcRepresentation
 576     * Method:    setValueStringArray
 577     * Signature: (Ljava/lang/String;[Ljava/lang/String;)V
 578     */
 579     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringArray
 580         (JNIEnv *, jobject, jstring, jobjectArray);
 581
 582     /*
 583     * Class:     org_iotivity_base_OcRepresentation
 584     * Method:    setValueString2DArray
 585     * Signature: (Ljava/lang/String;[[Ljava/lang/String;)V
 586     */
 587     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString2DArray
 588         (JNIEnv *, jobject, jstring, jobjectArray);
 589
 590     /*
 591     * Class:     org_iotivity_base_OcRepresentation
 592     * Method:    setValueString3DArray
 593     * Signature: (Ljava/lang/String;[[[Ljava/lang/String;)V
 594     */
 595     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString3DArray
 596         (JNIEnv *, jobject, jstring, jobjectArray);
 597
 598     /*
 599     * Class:     org_iotivity_base_OcRepresentation
 600     * Method:    setValueRepresentationArray
 601     * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OcRepresentation;)V
 602     */
 603     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentationArray
 604         (JNIEnv *, jobject, jstring, jobjectArray);
 605
 606     /*
 607     * Class:     org_iotivity_base_OcRepresentation
 608     * Method:    setValueRepresentation2DArray
 609     * Signature: (Ljava/lang/String;[[Lorg/iotivity/base/OcRepresentation;)V
 610     */
 611     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation2DArray
 612         (JNIEnv *, jobject, jstring, jobjectArray);
 613
 614     /*
 615     * Class:     org_iotivity_base_OcRepresentation
 616     * Method:    setValueRepresentation3DArray
 617     * Signature: (Ljava/lang/String;[[[Lorg/iotivity/base/OcRepresentation;)V
 618     */
 619     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation3DArray
 620         (JNIEnv *, jobject, jstring, jobjectArray);
 621
 622     /*
 623     * Class:     org_iotivity_base_OcRepresentation
 624     * Method:    addChild
 625     * Signature: (Lorg/iotivity/base/OcRepresentation;)V
 626     */
 627     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_addChild
 628         (JNIEnv *, jobject, jobject);
 629
 630     /*
 631     * Class:     org_iotivity_base_OcRepresentation
 632     * Method:    clearChildren
 633     * Signature: ()V
 634     */
 635     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_clearChildren
 636         (JNIEnv *, jobject);
 637
 638     /*
 639     * Class:     org_iotivity_base_OcRepresentation
 640     * Method:    getChildrenArray
 641     * Signature: ()[Lorg/iotivity/base/OcRepresentation;
 642     */
 643     JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcRepresentation_getChildrenArray
 644         (JNIEnv *, jobject);
 645
 646     /*
 647     * Class:     org_iotivity_base_OcRepresentation
 648     * Method:    getUri
 649     * Signature: ()Ljava/lang/String;
 650     */
 651     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getUri
 652         (JNIEnv *, jobject);
 653
 654     /*
 655     * Class:     org_iotivity_base_OcRepresentation
 656     * Method:    getHost
 657     * Signature: ()Ljava/lang/String;
 658     */
 659     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getHost
 660         (JNIEnv *, jobject);
 661
 662     /*
 663     * Class:     org_iotivity_base_OcRepresentation
 664     * Method:    setUri
 665     * Signature: (Ljava/lang/String;)V
 666     */
 667     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setUri
 668         (JNIEnv *, jobject, jstring);
 669
 670     /*
 671     * Class:     org_iotivity_base_OcRepresentation
 672     * Method:    getResourceTypes
 673     * Signature: ()Ljava/util/List;
 674     */
 675     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceTypes
 676         (JNIEnv *, jobject);
 677
 678     /*
 679     * Class:     org_iotivity_base_OcRepresentation
 680     * Method:    setResourceTypeArray
 681     * Signature: ([Ljava/lang/String;)V
 682     */
 683     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceTypeArray
 684         (JNIEnv *, jobject, jobjectArray);
 685
 686     /*
 687     * Class:     org_iotivity_base_OcRepresentation
 688     * Method:    getResourceInterfaces
 689     * Signature: ()Ljava/util/List;
 690     */
 691     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceInterfaces
 692         (JNIEnv *, jobject);
 693
 694     /*
 695     * Class:     org_iotivity_base_OcRepresentation
 696     * Method:    setResourceInterfaceArray
 697     * Signature: ([Ljava/lang/String;)V
 698     */
 699     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceInterfaceArray
 700         (JNIEnv *, jobject, jobjectArray);
 701
 702     /*
 703     * Class:     org_iotivity_base_OcRepresentation
 704     * Method:    isEmpty
 705     * Signature: ()Z
 706     */
 707     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isEmpty
 708         (JNIEnv *, jobject);
 709
 710     /*
 711     * Class:     org_iotivity_base_OcRepresentation
 712     * Method:    size
 713     * Signature: ()I
 714     */
 715     JNIEXPORT jint JNICALL Java_org_iotivity_base_OcRepresentation_size
 716         (JNIEnv *, jobject);
 717
 718     /*
 719     * Class:     org_iotivity_base_OcRepresentation
 720     * Method:    remove
 721     * Signature: (Ljava/lang/String;)Z
 722     */
 723     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_remove
 724         (JNIEnv *, jobject, jstring);
 725
 726     /*
 727     * Class:     org_iotivity_base_OcRepresentation
 728     * Method:    hasAttribute
 729     * Signature: (Ljava/lang/String;)Z
 730     */
 731     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_hasAttribute
 732         (JNIEnv *, jobject, jstring);
 733
 734     /*
 735     * Class:     org_iotivity_base_OcRepresentation
 736     * Method:    setNull
 737     * Signature: (Ljava/lang/String;)V
 738     */
 739     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setNull
 740         (JNIEnv *, jobject, jstring);
 741
 742     /*
 743     * Class:     org_iotivity_base_OcRepresentation
 744     * Method:    isNull
 745     * Signature: (Ljava/lang/String;)Z
 746     */
 747     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isNull
 748         (JNIEnv *, jobject, jstring);
 749
 750     /*
 751     * Class:     org_iotivity_base_OcRepresentation
 752     * Method:    create
 753     * Signature: ()V
 754     */
 755     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_create
 756         (JNIEnv *, jobject);
 757
 758     /*
 759     * Class:     org_iotivity_base_OcRepresentation
 760     * Method:    dispose
 761     * Signature: ()V
 762     */
 763     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_dispose
 764         (JNIEnv *, jobject, jboolean);
 765
 766 #ifdef __cplusplus
 767 }
 768 #endif
 769 #endif