android/android_api/base/jni/JniOcRepresentation.h

   1 /*\r
   2 * //******************************************************************\r
   3 * //\r
   4 * // Copyright 2015 Intel Corporation.\r
   5 * //\r
   6 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
   7 * //\r
   8 * // Licensed under the Apache License, Version 2.0 (the "License");\r
   9 * // you may not use this file except in compliance with the License.\r
  10 * // You may obtain a copy of the License at\r
  11 * //\r
  12 * //      http://www.apache.org/licenses/LICENSE-2.0\r
  13 * //\r
  14 * // Unless required by applicable law or agreed to in writing, software\r
  15 * // distributed under the License is distributed on an "AS IS" BASIS,\r
  16 * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17 * // See the License for the specific language governing permissions and\r
  18 * // limitations under the License.\r
  19 * //\r
  20 * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\r
  21 */\r
  22 #include "JniOcStack.h"\r
  23 #include <AttributeValue.h>\r
  24 \r
  25 #ifndef _Included_org_iotivity_base_OcRepresentation\r
  26 #define _Included_org_iotivity_base_OcRepresentation\r
  27 \r
  28 using namespace OC;\r
  29 \r
  30 class JniOcRepresentation\r
  31 {\r
  32 public:\r
  33     static OCRepresentation* getOCRepresentationPtr(JNIEnv *env, jobject thiz);\r
  34 };\r
  35 \r
  36 struct JObjectConverter : boost::static_visitor < jobject >\r
  37 {\r
  38     JObjectConverter(JNIEnv *env) : env(env){}\r
  39 \r
  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);\r
  73         jlong handle = reinterpret_cast<jlong>(rep);\r
  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);\r
  90         if (!jIntArray) return nullptr;\r
  91         const int* ints = &val[0];\r
  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);\r
  99         if (!jDoubleArray) return nullptr;\r
 100         const double* doubles = &val[0];\r
 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);\r
 108         if (!jBooleanArray) return nullptr;\r
 109         jboolean* booleans = new jboolean[len];\r
 110         for (size_t i = 0; i < len; ++i) {\r
 111             booleans[i] = static_cast<jboolean>(val[i]);\r
 112         }\r
 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();\r
 121         jobjectArray strArr = env->NewObjectArray(len, g_cls_String, NULL);\r
 122         if (!strArr) return nullptr;\r
 123         for (size_t i = 0; i < len; ++i)\r
 124         {\r
 125             jstring jString = env->NewStringUTF(val[i].c_str());\r
 126             env->SetObjectArrayElement(strArr, static_cast<jsize>(i), jString);\r
 127             if (env->ExceptionCheck()) return nullptr;\r
 128             env->DeleteLocalRef(jString);\r
 129         }\r
 130         return strArr;
 131     }
 132     jobject operator()(const std::vector<OC::OCRepresentation>& val) const
 133     {
 134         jsize len = static_cast<jsize>(val.size());\r
 135         jobjectArray repArr = env->NewObjectArray(len, g_cls_OcRepresentation, NULL);\r
 136         if (!repArr) return nullptr;\r
 137         for (jsize i = 0; i < len; ++i)\r
 138         {\r
 139             OCRepresentation* rep = new OCRepresentation(val[i]);\r
 140             jlong handle = reinterpret_cast<jlong>(rep);\r
 141             jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,\r
 142                 handle, true);\r
 143             if (!jRepresentation)\r
 144             {\r
 145                 delete rep;\r
 146                 return nullptr;\r
 147             }\r
 148             env->SetObjectArrayElement(repArr, i, jRepresentation);\r
 149             if (env->ExceptionCheck())\r
 150             {\r
 151                 delete rep;\r
 152                 return nullptr;\r
 153             }\r
 154             env->DeleteLocalRef(jRepresentation);\r
 155         }\r
 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());\r
 163         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int1DArray, NULL);\r
 164         if (!jOuterArr)
 165         {
 166             return nullptr;
 167         }\r
 168         for (jsize i = 0; i < lenOuter; ++i)\r
 169         {
 170             size_t lenInner = val[i].size();
 171             jintArray jIntArray = env->NewIntArray(lenInner);\r
 172             if (!jIntArray) return nullptr;\r
 173             const int* ints = &val[i][0];\r
 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());\r
 185         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_int2DArray, NULL);\r
 186         if (!jOuterArr) return nullptr;\r
 187         for (jsize k = 0; k < lenOuter; ++k)\r
 188         {\r
 189             jsize lenMiddle = static_cast<jsize>(val[k].size());\r
 190             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_int1DArray, NULL);\r
 191             if (!jMiddleArr) return nullptr;\r
 192             for (jsize i = 0; i < lenMiddle; ++i)\r
 193             {
 194                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 195                 jintArray jIntArray = env->NewIntArray(lenInner);\r
 196                 if (!jIntArray) return nullptr;\r
 197                 const int* ints = &val[k][i][0];\r
 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());\r
 214         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double1DArray, NULL);\r
 215         if (!jOuterArr) return nullptr;\r
 216         for (jsize i = 0; i < lenOuter; ++i)\r
 217         {
 218             size_t lenInner = val[i].size();
 219             jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);\r
 220             if (!jDoubleArray) return nullptr;\r
 221             const double* doubles = &val[i][0];\r
 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());\r
 234         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_double2DArray, NULL);\r
 235         if (!jOuterArr) return nullptr;\r
 236         for (jsize k = 0; k < lenOuter; ++k)\r
 237         {\r
 238             jsize lenMiddle = static_cast<jsize>(val[k].size());\r
 239             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_double1DArray, NULL);\r
 240             if (!jMiddleArr) return nullptr;\r
 241             for (jsize i = 0; i < lenMiddle; ++i)\r
 242             {
 243                 jsize lenInner = static_cast<jsize>(val[k][i].size());
 244                 jdoubleArray jDoubleArray = env->NewDoubleArray(lenInner);\r
 245                 if (!jDoubleArray) return nullptr;\r
 246                 const double* doubles = &val[k][i][0];\r
 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());\r
 263         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean1DArray, 0);\r
 264         if (!jOuterArr) return nullptr;\r
 265         for (jsize i = 0; i < lenOuter; ++i)\r
 266         {
 267             size_t lenInner = val[i].size();
 268             jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);\r
 269             if (!jBooleanArray) return nullptr;\r
 270             jboolean* booleans = new jboolean[lenInner];\r
 271             for (size_t j = 0; j < lenInner; ++j) {\r
 272                 booleans[j] = static_cast<jboolean>(val[i][j]);\r
 273             }\r
 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());\r
 287         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_boolean2DArray, NULL);\r
 288         if (!jOuterArr) return nullptr;\r
 289         for (jsize k = 0; k < lenOuter; ++k)\r
 290         {\r
 291             jsize lenMiddle = static_cast<jsize>(val[k].size());\r
 292             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_boolean1DArray, NULL);\r
 293             if (!jMiddleArr) return nullptr;\r
 294             for (jsize i = 0; i < lenMiddle; ++i)\r
 295             {
 296                 size_t lenInner = val[k][i].size();
 297                 jbooleanArray jBooleanArray = env->NewBooleanArray(lenInner);\r
 298                 jboolean* booleans = new jboolean[lenInner];\r
 299                 for (size_t j = 0; j < lenInner; ++j) {\r
 300                     booleans[j] = val[k][i][j];\r
 301                 }\r
 302                 env->SetBooleanArrayRegion(jBooleanArray, 0, lenInner, booleans);
 303                 if (env->ExceptionCheck()) return nullptr;
 304                 env->SetObjectArrayElement(jMiddleArr, i, jBooleanArray);\r
 305                 if (env->ExceptionCheck()) return nullptr;\r
 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());\r
 320         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String1DArray, NULL);\r
 321         if (!jOuterArr) return nullptr;\r
 322         for (jsize i = 0; i < lenOuter; ++i)\r
 323         {
 324             jsize lenInner = static_cast<jsize>(val[i].size());\r
 325             jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, NULL);\r
 326             if (!strArr) return nullptr;\r
 327             for (jsize j = 0; j < lenInner; ++j)\r
 328             {\r
 329                 jstring jString = env->NewStringUTF(val[i][j].c_str());\r
 330                 env->SetObjectArrayElement(strArr, j, jString);\r
 331                 if (env->ExceptionCheck()) return nullptr;\r
 332                 env->DeleteLocalRef(jString);\r
 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());\r
 344         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_String2DArray, NULL);\r
 345         if (!jOuterArr) return nullptr;\r
 346         for (jsize k = 0; k < lenOuter; ++k)\r
 347         {\r
 348             jsize lenMiddle = static_cast<jsize>(val[k].size());\r
 349             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_String1DArray, NULL);\r
 350             if (!jMiddleArr) return nullptr;\r
 351             for (jsize i = 0; i < lenMiddle; ++i)\r
 352             {
 353                 jsize lenInner = static_cast<jsize>(val[k][i].size());\r
 354                 jobjectArray strArr = env->NewObjectArray(lenInner, g_cls_String, NULL);\r
 355                 if (!strArr) return nullptr;\r
 356                 for (jsize j = 0; j < lenInner; ++j)\r
 357                 {\r
 358                     jstring jString = env->NewStringUTF(val[k][i][j].c_str());\r
 359                     env->SetObjectArrayElement(strArr, j, jString);\r
 360                     if (env->ExceptionCheck()) return nullptr;\r
 361                     env->DeleteLocalRef(jString);\r
 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());\r
 377         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation1DArray, NULL);\r
 378         if (!jOuterArr) return nullptr;\r
 379         for (jsize i = 0; i < lenOuter; ++i)\r
 380         {
 381             jsize lenInner = static_cast<jsize>(val[i].size());\r
 382             jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, NULL);\r
 383             if (!repArr) return nullptr;\r
 384             for (jsize j = 0; j < lenInner; ++j)\r
 385             {\r
 386                 OCRepresentation* rep = new OCRepresentation(val[i][j]);\r
 387                 jlong handle = reinterpret_cast<jlong>(rep);\r
 388                 jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,\r
 389                     handle, true);\r
 390                 if (!jRepresentation)\r
 391                 {\r
 392                     delete rep;\r
 393                     return nullptr;\r
 394                 }\r
 395                 env->SetObjectArrayElement(repArr, j, jRepresentation);\r
 396                 if (env->ExceptionCheck()) return nullptr;\r
 397                 env->DeleteLocalRef(jRepresentation);\r
 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\r
 406     {\r
 407         jsize lenOuter = static_cast<jsize>(val.size());\r
 408         jobjectArray jOuterArr = env->NewObjectArray(lenOuter, g_cls_OcRepresentation2DArray, NULL);\r
 409         if (!jOuterArr) return nullptr;\r
 410         for (jsize k = 0; k < lenOuter; ++k)\r
 411         {\r
 412             jsize lenMiddle = static_cast<jsize>(val[k].size());\r
 413             jobjectArray jMiddleArr = env->NewObjectArray(lenMiddle, g_cls_OcRepresentation1DArray, NULL);\r
 414             if (!jMiddleArr) return nullptr;\r
 415             for (jsize i = 0; i < lenMiddle; ++i)\r
 416             {
 417                 jsize lenInner = static_cast<jsize>(val[k][i].size());\r
 418                 jobjectArray repArr = env->NewObjectArray(lenInner, g_cls_OcRepresentation, NULL);\r
 419                 if (!repArr) return nullptr;\r
 420                 for (jsize j = 0; j < lenInner; ++j)\r
 421                 {\r
 422                     OCRepresentation* rep = new OCRepresentation(val[k][i][j]);\r
 423                     jlong handle = reinterpret_cast<jlong>(rep);\r
 424                     jobject jRepresentation = env->NewObject(g_cls_OcRepresentation, g_mid_OcRepresentation_N_ctor_bool,\r
 425                         handle, true);\r
 426                     if (!jRepresentation)\r
 427                     {\r
 428                         delete rep;\r
 429                         return nullptr;\r
 430                     }\r
 431                     env->SetObjectArrayElement(repArr, j, jRepresentation);\r
 432                     if (env->ExceptionCheck()) return nullptr;\r
 433                     env->DeleteLocalRef(jRepresentation);\r
 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;\r
 444     }\r
 445 \r
 446 private:\r
 447     JNIEnv *env;\r
 448 };\r
 449 \r
 450 #ifdef __cplusplus\r
 451 extern "C" {\r
 452 #endif\r
 453 \r
 454     /*\r
 455     * Class:     org_iotivity_base_OcRepresentation\r
 456     * Method:    getValueN\r
 457     * Signature: (Ljava/lang/String;)Ljava/lang/Object;\r
 458     */\r
 459     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getValueN\r
 460         (JNIEnv *, jobject, jstring);\r
 461 \r
 462     /*\r
 463     * Class:     org_iotivity_base_OcRepresentation\r
 464     * Method:    setValueInteger\r
 465     * Signature: (Ljava/lang/String;I)V\r
 466     */\r
 467     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger\r
 468         (JNIEnv *, jobject, jstring, jint);\r
 469 \r
 470     /*\r
 471     * Class:     org_iotivity_base_OcRepresentation\r
 472     * Method:    setValueDouble\r
 473     * Signature: (Ljava/lang/String;D)V\r
 474     */\r
 475     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble\r
 476         (JNIEnv *, jobject, jstring, jdouble);\r
 477 \r
 478     /*\r
 479     * Class:     org_iotivity_base_OcRepresentation\r
 480     * Method:    setValueBoolean\r
 481     * Signature: (Ljava/lang/String;Z)V\r
 482     */\r
 483     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean\r
 484         (JNIEnv *, jobject, jstring, jboolean);\r
 485 \r
 486     /*\r
 487     * Class:     org_iotivity_base_OcRepresentation\r
 488     * Method:    setValueStringN\r
 489     * Signature: (Ljava/lang/String;Ljava/lang/String;)V\r
 490     */\r
 491     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringN\r
 492         (JNIEnv *, jobject, jstring, jstring);\r
 493 \r
 494     /*\r
 495     * Class:     org_iotivity_base_OcRepresentation\r
 496     * Method:    setValueRepresentation\r
 497     * Signature: (Ljava/lang/String;Lorg/iotivity/base/OcRepresentation;)V\r
 498     */\r
 499     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation\r
 500         (JNIEnv *, jobject, jstring, jobject);\r
 501 \r
 502     /*\r
 503     * Class:     org_iotivity_base_OcRepresentation\r
 504     * Method:    setValueIntegerArray\r
 505     * Signature: (Ljava/lang/String;[I)V\r
 506     */\r
 507     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueIntegerArray\r
 508         (JNIEnv *, jobject, jstring, jintArray);\r
 509 \r
 510     /*\r
 511     * Class:     org_iotivity_base_OcRepresentation\r
 512     * Method:    setValueInteger2DArray\r
 513     * Signature: (Ljava/lang/String;[[I)V\r
 514     */\r
 515     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger2DArray\r
 516         (JNIEnv *, jobject, jstring, jobjectArray);\r
 517 \r
 518     /*\r
 519     * Class:     org_iotivity_base_OcRepresentation\r
 520     * Method:    setValueInteger3DArray\r
 521     * Signature: (Ljava/lang/String;[[[I)V\r
 522     */\r
 523     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueInteger3DArray\r
 524         (JNIEnv *, jobject, jstring, jobjectArray);\r
 525 \r
 526     /*\r
 527     * Class:     org_iotivity_base_OcRepresentation\r
 528     * Method:    setValueDoubleArray\r
 529     * Signature: (Ljava/lang/String;[D)V\r
 530     */\r
 531     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDoubleArray\r
 532         (JNIEnv *, jobject, jstring, jdoubleArray);\r
 533 \r
 534     /*\r
 535     * Class:     org_iotivity_base_OcRepresentation\r
 536     * Method:    setValueDouble2DArray\r
 537     * Signature: (Ljava/lang/String;[[D)V\r
 538     */\r
 539     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble2DArray\r
 540         (JNIEnv *, jobject, jstring, jobjectArray);\r
 541 \r
 542     /*\r
 543     * Class:     org_iotivity_base_OcRepresentation\r
 544     * Method:    setValueDouble3DArray\r
 545     * Signature: (Ljava/lang/String;[[[D)V\r
 546     */\r
 547     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueDouble3DArray\r
 548         (JNIEnv *, jobject, jstring, jobjectArray);\r
 549 \r
 550     /*\r
 551     * Class:     org_iotivity_base_OcRepresentation\r
 552     * Method:    setValueBooleanArray\r
 553     * Signature: (Ljava/lang/String;[Z)V\r
 554     */\r
 555     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBooleanArray\r
 556         (JNIEnv *, jobject, jstring, jbooleanArray);\r
 557 \r
 558     /*\r
 559     * Class:     org_iotivity_base_OcRepresentation\r
 560     * Method:    setValueBoolean2DArray\r
 561     * Signature: (Ljava/lang/String;[[Z)V\r
 562     */\r
 563     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean2DArray\r
 564         (JNIEnv *, jobject, jstring, jobjectArray);\r
 565 \r
 566     /*\r
 567     * Class:     org_iotivity_base_OcRepresentation\r
 568     * Method:    setValueBoolean3DArray\r
 569     * Signature: (Ljava/lang/String;[[[Z)V\r
 570     */\r
 571     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueBoolean3DArray\r
 572         (JNIEnv *, jobject, jstring, jobjectArray);\r
 573 \r
 574     /*\r
 575     * Class:     org_iotivity_base_OcRepresentation\r
 576     * Method:    setValueStringArray\r
 577     * Signature: (Ljava/lang/String;[Ljava/lang/String;)V\r
 578     */\r
 579     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueStringArray\r
 580         (JNIEnv *, jobject, jstring, jobjectArray);\r
 581 \r
 582     /*\r
 583     * Class:     org_iotivity_base_OcRepresentation\r
 584     * Method:    setValueString2DArray\r
 585     * Signature: (Ljava/lang/String;[[Ljava/lang/String;)V\r
 586     */\r
 587     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString2DArray\r
 588         (JNIEnv *, jobject, jstring, jobjectArray);\r
 589 \r
 590     /*\r
 591     * Class:     org_iotivity_base_OcRepresentation\r
 592     * Method:    setValueString3DArray\r
 593     * Signature: (Ljava/lang/String;[[[Ljava/lang/String;)V\r
 594     */\r
 595     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueString3DArray\r
 596         (JNIEnv *, jobject, jstring, jobjectArray);\r
 597 \r
 598     /*\r
 599     * Class:     org_iotivity_base_OcRepresentation\r
 600     * Method:    setValueRepresentationArray\r
 601     * Signature: (Ljava/lang/String;[Lorg/iotivity/base/OcRepresentation;)V\r
 602     */\r
 603     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentationArray\r
 604         (JNIEnv *, jobject, jstring, jobjectArray);\r
 605 \r
 606     /*\r
 607     * Class:     org_iotivity_base_OcRepresentation\r
 608     * Method:    setValueRepresentation2DArray\r
 609     * Signature: (Ljava/lang/String;[[Lorg/iotivity/base/OcRepresentation;)V\r
 610     */\r
 611     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation2DArray\r
 612         (JNIEnv *, jobject, jstring, jobjectArray);\r
 613 \r
 614     /*\r
 615     * Class:     org_iotivity_base_OcRepresentation\r
 616     * Method:    setValueRepresentation3DArray\r
 617     * Signature: (Ljava/lang/String;[[[Lorg/iotivity/base/OcRepresentation;)V\r
 618     */\r
 619     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setValueRepresentation3DArray\r
 620         (JNIEnv *, jobject, jstring, jobjectArray);\r
 621 \r
 622     /*\r
 623     * Class:     org_iotivity_base_OcRepresentation\r
 624     * Method:    addChild\r
 625     * Signature: (Lorg/iotivity/base/OcRepresentation;)V\r
 626     */\r
 627     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_addChild\r
 628         (JNIEnv *, jobject, jobject);\r
 629 \r
 630     /*\r
 631     * Class:     org_iotivity_base_OcRepresentation\r
 632     * Method:    clearChildren\r
 633     * Signature: ()V\r
 634     */\r
 635     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_clearChildren\r
 636         (JNIEnv *, jobject);\r
 637 \r
 638     /*\r
 639     * Class:     org_iotivity_base_OcRepresentation\r
 640     * Method:    getChildrenArray\r
 641     * Signature: ()[Lorg/iotivity/base/OcRepresentation;\r
 642     */\r
 643     JNIEXPORT jobjectArray JNICALL Java_org_iotivity_base_OcRepresentation_getChildrenArray\r
 644         (JNIEnv *, jobject);\r
 645 \r
 646     /*\r
 647     * Class:     org_iotivity_base_OcRepresentation\r
 648     * Method:    getUri\r
 649     * Signature: ()Ljava/lang/String;\r
 650     */\r
 651     JNIEXPORT jstring JNICALL Java_org_iotivity_base_OcRepresentation_getUri\r
 652         (JNIEnv *, jobject);\r
 653 \r
 654     /*\r
 655     * Class:     org_iotivity_base_OcRepresentation\r
 656     * Method:    setUri\r
 657     * Signature: (Ljava/lang/String;)V\r
 658     */\r
 659     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setUri\r
 660         (JNIEnv *, jobject, jstring);\r
 661 \r
 662     /*\r
 663     * Class:     org_iotivity_base_OcRepresentation\r
 664     * Method:    getResourceTypes\r
 665     * Signature: ()Ljava/util/List;\r
 666     */\r
 667     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceTypes\r
 668         (JNIEnv *, jobject);\r
 669 \r
 670     /*\r
 671     * Class:     org_iotivity_base_OcRepresentation\r
 672     * Method:    setResourceTypeArray\r
 673     * Signature: ([Ljava/lang/String;)V\r
 674     */\r
 675     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceTypeArray\r
 676         (JNIEnv *, jobject, jobjectArray);\r
 677 \r
 678     /*\r
 679     * Class:     org_iotivity_base_OcRepresentation\r
 680     * Method:    getResourceInterfaces\r
 681     * Signature: ()Ljava/util/List;\r
 682     */\r
 683     JNIEXPORT jobject JNICALL Java_org_iotivity_base_OcRepresentation_getResourceInterfaces\r
 684         (JNIEnv *, jobject);\r
 685 \r
 686     /*\r
 687     * Class:     org_iotivity_base_OcRepresentation\r
 688     * Method:    setResourceInterfaceArray\r
 689     * Signature: ([Ljava/lang/String;)V\r
 690     */\r
 691     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setResourceInterfaceArray\r
 692         (JNIEnv *, jobject, jobjectArray);\r
 693 \r
 694     /*\r
 695     * Class:     org_iotivity_base_OcRepresentation\r
 696     * Method:    isEmpty\r
 697     * Signature: ()Z\r
 698     */\r
 699     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isEmpty\r
 700         (JNIEnv *, jobject);\r
 701 \r
 702     /*\r
 703     * Class:     org_iotivity_base_OcRepresentation\r
 704     * Method:    size\r
 705     * Signature: ()I\r
 706     */\r
 707     JNIEXPORT jint JNICALL Java_org_iotivity_base_OcRepresentation_size\r
 708         (JNIEnv *, jobject);\r
 709 \r
 710     /*\r
 711     * Class:     org_iotivity_base_OcRepresentation\r
 712     * Method:    remove\r
 713     * Signature: (Ljava/lang/String;)Z\r
 714     */\r
 715     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_remove\r
 716         (JNIEnv *, jobject, jstring);\r
 717 \r
 718     /*\r
 719     * Class:     org_iotivity_base_OcRepresentation\r
 720     * Method:    hasAttribute\r
 721     * Signature: (Ljava/lang/String;)Z\r
 722     */\r
 723     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_hasAttribute\r
 724         (JNIEnv *, jobject, jstring);\r
 725 \r
 726     /*\r
 727     * Class:     org_iotivity_base_OcRepresentation\r
 728     * Method:    setNull\r
 729     * Signature: (Ljava/lang/String;)V\r
 730     */\r
 731     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_setNull\r
 732         (JNIEnv *, jobject, jstring);\r
 733 \r
 734     /*\r
 735     * Class:     org_iotivity_base_OcRepresentation\r
 736     * Method:    isNull\r
 737     * Signature: (Ljava/lang/String;)Z\r
 738     */\r
 739     JNIEXPORT jboolean JNICALL Java_org_iotivity_base_OcRepresentation_isNull\r
 740         (JNIEnv *, jobject, jstring);\r
 741 \r
 742     /*\r
 743     * Class:     org_iotivity_base_OcRepresentation\r
 744     * Method:    create\r
 745     * Signature: ()V\r
 746     */\r
 747     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_create\r
 748         (JNIEnv *, jobject);\r
 749 \r
 750     /*\r
 751     * Class:     org_iotivity_base_OcRepresentation\r
 752     * Method:    dispose\r
 753     * Signature: ()V\r
 754     */\r
 755     JNIEXPORT void JNICALL Java_org_iotivity_base_OcRepresentation_dispose\r
 756         (JNIEnv *, jobject, jboolean);\r
 757 \r
 758 #ifdef __cplusplus\r
 759 }\r
 760 #endif\r
 761 #endif