samples/java/drv/SampleHLRJni/SampleHLRJni_TColStd_Array1OfBoolean_java.cxx

   1 //
   2 //                     Copyright (C) 1991 - 2000 by
   3 //                      Matra Datavision SA.  All rights reserved.
   4 //
   5 //                     Copyright (C) 2001 - 2004 by
   6 //                     Open CASCADE SA.  All rights reserved.
   7 //
   8 // This file is part of the Open CASCADE Technology software.
   9 //
  10 // This software may be distributed and/or modified under the terms and
  11 // conditions of the Open CASCADE Public License as defined by Open CASCADE SA
  12 // and appearing in the file LICENSE included in the packaging of this file.
  13 //
  14 // This software is distributed on an "AS IS" basis, without warranty of any
  15 // kind, and Open CASCADE SA hereby disclaims all such warranties,
  16 // including without limitation, any warranties of merchantability, fitness
  17 // for a particular purpose or non-infringement. Please see the License for
  18 // the specific terms and conditions governing rights and limitations under the
  19 // License.
  20
  21 #include <SampleHLRJni_TColStd_Array1OfBoolean.h>
  22 #include <TColStd_Array1OfBoolean.hxx>
  23 #include <jcas.hxx>
  24 #include <stdlib.h>
  25 #include <Standard_ErrorHandler.hxx>
  26 #include <Standard_Failure.hxx>
  27 #include <Standard_SStream.hxx>
  28
  29 #include <Standard_Integer.hxx>
  30 #include <Standard_Boolean.hxx>
  31
  32
  33 extern "C" {
  34
  35
  36 JNIEXPORT void JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_TColStd_1Array1OfBoolean_1Create_11 (JNIEnv *env, jobject theobj, jint Low, jint Up)
  37 {
  38
  39 jcas_Locking alock(env);
  40 {
  41 try {
  42 TColStd_Array1OfBoolean* theret = new TColStd_Array1OfBoolean((Standard_Integer) Low,(Standard_Integer) Up);
  43 jcas_SetHandle(env,theobj,theret);
  44
  45 }
  46 catch (Standard_Failure) {
  47   Standard_SStream Err;
  48   Err <<   Standard_Failure::Caught();
  49   Err << (char) 0;
  50   jcas_ThrowException(env,Err.str().c_str());
  51 }
  52 }
  53 alock.Release();
  54
  55 }
  56
  57
  58
  59 JNIEXPORT void JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_TColStd_1Array1OfBoolean_1Create_12 (JNIEnv *env, jobject theobj, jboolean Item, jint Low, jint Up)
  60 {
  61
  62 jcas_Locking alock(env);
  63 {
  64 try {
  65 TColStd_Array1OfBoolean* theret = new TColStd_Array1OfBoolean((Standard_Boolean) Item,(Standard_Integer) Low,(Standard_Integer) Up);
  66 jcas_SetHandle(env,theobj,theret);
  67
  68 }
  69 catch (Standard_Failure) {
  70   Standard_SStream Err;
  71   Err <<   Standard_Failure::Caught();
  72   Err << (char) 0;
  73   jcas_ThrowException(env,Err.str().c_str());
  74 }
  75 }
  76 alock.Release();
  77
  78 }
  79
  80
  81
  82 JNIEXPORT void JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Init (JNIEnv *env, jobject theobj, jboolean V)
  83 {
  84
  85 jcas_Locking alock(env);
  86 {
  87 try {
  88 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
  89 the_this->Init((Standard_Boolean) V);
  90
  91 }
  92 catch (Standard_Failure) {
  93   Standard_SStream Err;
  94   Err <<   Standard_Failure::Caught();
  95   Err << (char) 0;
  96   jcas_ThrowException(env,Err.str().c_str());
  97 }
  98 }
  99 alock.Release();
 100
 101 }
 102
 103
 104
 105 JNIEXPORT void JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Destroy (JNIEnv *env, jobject theobj)
 106 {
 107
 108 jcas_Locking alock(env);
 109 {
 110 try {
 111 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 112 the_this->Destroy();
 113
 114 }
 115 catch (Standard_Failure) {
 116   Standard_SStream Err;
 117   Err <<   Standard_Failure::Caught();
 118   Err << (char) 0;
 119   jcas_ThrowException(env,Err.str().c_str());
 120 }
 121 }
 122 alock.Release();
 123
 124 }
 125
 126
 127
 128 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_IsAllocated (JNIEnv *env, jobject theobj)
 129 {
 130 jboolean thejret;
 131
 132 jcas_Locking alock(env);
 133 {
 134 try {
 135 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 136  thejret = the_this->IsAllocated();
 137
 138 }
 139 catch (Standard_Failure) {
 140   Standard_SStream Err;
 141   Err <<   Standard_Failure::Caught();
 142   Err << (char) 0;
 143   jcas_ThrowException(env,Err.str().c_str());
 144 }
 145 }
 146 alock.Release();
 147 return thejret;
 148 }
 149
 150
 151
 152 JNIEXPORT jobject JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Assign (JNIEnv *env, jobject theobj, jobject Other)
 153 {
 154 jobject thejret;
 155
 156 jcas_Locking alock(env);
 157 {
 158 try {
 159 TColStd_Array1OfBoolean* the_Other = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,Other);
 160 if ( the_Other == NULL ) {
 161
 162  // The following assumes availability of the default constructor (what may not
 163  // always be the case). Therefore explicit exception is thrown if the null
 164  // object has been passed.
 165  // the_Other = new TColStd_Array1OfBoolean ();
 166  // jcas_SetHandle ( env, Other, the_Other );
 167  jcas_ThrowException (env, "NULL object has been passed while expecting an object manipulated by value");
 168
 169 }  // end if
 170 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 171 const TColStd_Array1OfBoolean& theret = the_this->Assign(*the_Other);
 172 thejret = jcas_CreateObject(env,"CASCADESamplesJni/TColStd_Array1OfBoolean",&theret,0);
 173
 174 }
 175 catch (Standard_Failure) {
 176   Standard_SStream Err;
 177   Err <<   Standard_Failure::Caught();
 178   Err << (char) 0;
 179   jcas_ThrowException(env,Err.str().c_str());
 180 }
 181 }
 182 alock.Release();
 183 return thejret;
 184 }
 185
 186
 187
 188 JNIEXPORT jint JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Length (JNIEnv *env, jobject theobj)
 189 {
 190 jint thejret;
 191
 192 jcas_Locking alock(env);
 193 {
 194 try {
 195 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 196  thejret = the_this->Length();
 197
 198 }
 199 catch (Standard_Failure) {
 200   Standard_SStream Err;
 201   Err <<   Standard_Failure::Caught();
 202   Err << (char) 0;
 203   jcas_ThrowException(env,Err.str().c_str());
 204 }
 205 }
 206 alock.Release();
 207 return thejret;
 208 }
 209
 210
 211
 212 JNIEXPORT jint JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Lower (JNIEnv *env, jobject theobj)
 213 {
 214 jint thejret;
 215
 216 jcas_Locking alock(env);
 217 {
 218 try {
 219 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 220  thejret = the_this->Lower();
 221
 222 }
 223 catch (Standard_Failure) {
 224   Standard_SStream Err;
 225   Err <<   Standard_Failure::Caught();
 226   Err << (char) 0;
 227   jcas_ThrowException(env,Err.str().c_str());
 228 }
 229 }
 230 alock.Release();
 231 return thejret;
 232 }
 233
 234
 235
 236 JNIEXPORT jint JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Upper (JNIEnv *env, jobject theobj)
 237 {
 238 jint thejret;
 239
 240 jcas_Locking alock(env);
 241 {
 242 try {
 243 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 244  thejret = the_this->Upper();
 245
 246 }
 247 catch (Standard_Failure) {
 248   Standard_SStream Err;
 249   Err <<   Standard_Failure::Caught();
 250   Err << (char) 0;
 251   jcas_ThrowException(env,Err.str().c_str());
 252 }
 253 }
 254 alock.Release();
 255 return thejret;
 256 }
 257
 258
 259
 260 JNIEXPORT void JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_SetValue (JNIEnv *env, jobject theobj, jint Index, jboolean Value)
 261 {
 262
 263 jcas_Locking alock(env);
 264 {
 265 try {
 266 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 267 the_this->SetValue((Standard_Integer) Index,(Standard_Boolean) Value);
 268
 269 }
 270 catch (Standard_Failure) {
 271   Standard_SStream Err;
 272   Err <<   Standard_Failure::Caught();
 273   Err << (char) 0;
 274   jcas_ThrowException(env,Err.str().c_str());
 275 }
 276 }
 277 alock.Release();
 278
 279 }
 280
 281
 282
 283 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_Value (JNIEnv *env, jobject theobj, jint Index)
 284 {
 285 jboolean thejret;
 286
 287 jcas_Locking alock(env);
 288 {
 289 try {
 290 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 291  thejret = the_this->Value((Standard_Integer) Index);
 292
 293 }
 294 catch (Standard_Failure) {
 295   Standard_SStream Err;
 296   Err <<   Standard_Failure::Caught();
 297   Err << (char) 0;
 298   jcas_ThrowException(env,Err.str().c_str());
 299 }
 300 }
 301 alock.Release();
 302 return thejret;
 303 }
 304
 305
 306
 307 JNIEXPORT jboolean JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_ChangeValue (JNIEnv *env, jobject theobj, jint Index)
 308 {
 309 jboolean thejret;
 310
 311 jcas_Locking alock(env);
 312 {
 313 try {
 314 TColStd_Array1OfBoolean* the_this = (TColStd_Array1OfBoolean*) jcas_GetHandle(env,theobj);
 315  thejret = the_this->ChangeValue((Standard_Integer) Index);
 316
 317 }
 318 catch (Standard_Failure) {
 319   Standard_SStream Err;
 320   Err <<   Standard_Failure::Caught();
 321   Err << (char) 0;
 322   jcas_ThrowException(env,Err.str().c_str());
 323 }
 324 }
 325 alock.Release();
 326 return thejret;
 327 }
 328
 329
 330
 331 JNIEXPORT void JNICALL Java_SampleHLRJni_TColStd_1Array1OfBoolean_FinalizeValue(JNIEnv *, jclass, jlong theid)
 332 {
 333 if (theid) {
 334   TColStd_Array1OfBoolean* theobj = (TColStd_Array1OfBoolean*) theid;
 335   delete theobj;
 336 }
 337 }
 338
 339
 340 }