Class: OpalKelly::OkDeviceSensors

Inherits:
Object
  • Object
show all
Defined in:
ext/OpalKelly/FrontPanelDLL_wrap.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



13416
13417
13418
13419
13420
13421
13422
13423
13424
13425
13426
13427
13428
13429
13430
13431
13432
13433
13434
13435
13436
13437
13438
13439
13440
13441
13442
13443
13444
13445
13446
13447
13448
13449
13450
13451
13452
13453
13454
13455
13456
13457
13458
13459
13460
13461
13462
13463
13464
13465
13466
13467
13468
13469
13470
13471
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13416

SWIGINTERN VALUE _wrap_new_okDeviceSensors(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_okDeviceSensors__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_okDeviceSensors__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_okDeviceSensors__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_okTDeviceSensor, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_okDeviceSensors__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "okDeviceSensors.new", 
    "    okDeviceSensors.new()\n"
    "    okDeviceSensors.new(std::vector< okTDeviceSensor > const &other)\n"
    "    okDeviceSensors.new(std::vector< okTDeviceSensor >::size_type size)\n"
    "    okDeviceSensors.new(std::vector< okTDeviceSensor >::size_type size, std::vector< okTDeviceSensor >::value_type const &value)\n");
  
  return Qnil;
}

Instance Method Details

#[](*args, self) ⇒ Object 



12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
12321
12322
12323
12324
12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370
12371
12372
12373
12374
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12310

SWIGINTERN VALUE _wrap_okDeviceSensors___getitem__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_okDeviceSensors___getitem____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_okDeviceSensors___getitem____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_okDeviceSensors___getitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
    "    VALUE __getitem__(std::vector< okTDeviceSensor >::difference_type i, std::vector< okTDeviceSensor >::difference_type length)\n"
    "    VALUE __getitem__(std::vector< okTDeviceSensor >::difference_type i)\n"
    "    VALUE __getitem__(VALUE i)\n");
  
  return Qnil;
}

#[]=(*args, self) ⇒ Object 



12494
12495
12496
12497
12498
12499
12500
12501
12502
12503
12504
12505
12506
12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
12535
12536
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12494

SWIGINTERN VALUE _wrap_okDeviceSensors___setitem__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_okTDeviceSensor, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_okDeviceSensors___setitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_okDeviceSensors___setitem____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__setitem__", 
    "    VALUE __setitem__(std::vector< okTDeviceSensor >::difference_type i, std::vector< okTDeviceSensor >::value_type const &x)\n"
    "    VALUE __setitem__(std::vector< okTDeviceSensor >::difference_type i, std::vector< okTDeviceSensor >::difference_type length, std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > const &v)\n");
  
  return Qnil;
}

#__delete2__(*args) ⇒ Object 



12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12047

SWIGINTERN VALUE
_wrap_okDeviceSensors___delete2__(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","__delete2__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_okTDeviceSensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::value_type const &","__delete2__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTDeviceSensor >::value_type const &","__delete2__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< okTDeviceSensor >::value_type * >(argp2);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg____delete2__(arg1,(okTDeviceSensor const &)*arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#assign(*args) ⇒ Object

call-seq:

assign(n, x)

Assign a new okDeviceSensors or portion of it.



13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564
13565
13566
13567
13568
13569
13570
13571
13572
13573
13574
13575
13576
13577
13578
13579
13580
13581
13582
13583
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13546

SWIGINTERN VALUE
_wrap_okDeviceSensors_assign(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::size_type arg2 ;
  std::vector< okTDeviceSensor >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::size_type","assign", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTDeviceSensor >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_okTDeviceSensor,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::value_type const &","assign", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTDeviceSensor >::value_type const &","assign", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< std::vector< okTDeviceSensor >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< okTDeviceSensor >::value_type const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}

#at(*args) ⇒ Object

call-seq:

at(i) -> VALUE

Return element at a certain index.



12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
12188
12189
12190
12191
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12162

SWIGINTERN VALUE
_wrap_okDeviceSensors_at(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::difference_type","at", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTDeviceSensor >::difference_type >(val2);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__at((std::vector< okTDeviceSensor > const *)arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#back(*args) ⇒ Object

call-seq:

back -> okTDeviceSensor

Return the last element in okDeviceSensors.



13514
13515
13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13514

SWIGINTERN VALUE
_wrap_okDeviceSensors_back(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::value_type *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","back", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor >::value_type *) &((std::vector< okTDeviceSensor > const *)arg1)->back();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_okTDeviceSensor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#begin(*args) ⇒ Object

call-seq:

begin -> std::vector< okTDeviceSensor >::iterator

Return an iterator to the beginning of the okDeviceSensors.



12968
12969
12970
12971
12972
12973
12974
12975
12976
12977
12978
12979
12980
12981
12982
12983
12984
12985
12986
12987
12988
12989
12990
12991
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12968

SWIGINTERN VALUE
_wrap_okDeviceSensors_begin(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (arg1)->begin();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTDeviceSensor >::iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#capacity(*args) ⇒ Object

call-seq:

capacity -> std::vector< okTDeviceSensor >::size_type

Reserved capacity of the okDeviceSensors.



13936
13937
13938
13939
13940
13941
13942
13943
13944
13945
13946
13947
13948
13949
13950
13951
13952
13953
13954
13955
13956
13957
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13936

SWIGINTERN VALUE
_wrap_okDeviceSensors_capacity(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::size_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","capacity", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = ((std::vector< okTDeviceSensor > const *)arg1)->capacity();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#clear(*args) ⇒ Object

call-seq:

clear

Clear okDeviceSensors contents.



13104
13105
13106
13107
13108
13109
13110
13111
13112
13113
13114
13115
13116
13117
13118
13119
13120
13121
13122
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13104

SWIGINTERN VALUE
_wrap_okDeviceSensors_clear(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}

#delete_at(*args) ⇒ Object

call-seq:

delete_at(i) -> VALUE

Delete an element at a certain index.



12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12122

SWIGINTERN VALUE
_wrap_okDeviceSensors_delete_at(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","delete_at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::difference_type","delete_at", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTDeviceSensor >::difference_type >(val2);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__delete_at(arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#dup(*args) ⇒ Object

call-seq:

dup -> okDeviceSensors

Create a duplicate of the class and unfreeze it if needed.



11843
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 11843

SWIGINTERN VALUE
_wrap_okDeviceSensors_dup(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","dup", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *)std_vector_Sl_okTDeviceSensor_Sg__dup(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#each(*args) ⇒ Object

call-seq:

each -> okDeviceSensors

Iterate thru each element in the okDeviceSensors. A block must be provided.



12023
12024
12025
12026
12027
12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12023

SWIGINTERN VALUE
_wrap_okDeviceSensors_each(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","each", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *)std_vector_Sl_okTDeviceSensor_Sg__each(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the okDeviceSensors is empty or not.

Returns:

  • (Boolean) 


12872
12873
12874
12875
12876
12877
12878
12879
12880
12881
12882
12883
12884
12885
12886
12887
12888
12889
12890
12891
12892
12893
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12872

SWIGINTERN VALUE
_wrap_okDeviceSensors_emptyq___(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","empty", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (bool)((std::vector< okTDeviceSensor > const *)arg1)->empty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#end(*args) ⇒ Object

call-seq:

end -> std::vector< okTDeviceSensor >::iterator

Return an iterator to past the end of the okDeviceSensors.



13002
13003
13004
13005
13006
13007
13008
13009
13010
13011
13012
13013
13014
13015
13016
13017
13018
13019
13020
13021
13022
13023
13024
13025
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13002

SWIGINTERN VALUE
_wrap_okDeviceSensors_end(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (arg1)->end();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTDeviceSensor >::iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#erase(*args, self) ⇒ Object 



13314
13315
13316
13317
13318
13319
13320
13321
13322
13323
13324
13325
13326
13327
13328
13329
13330
13331
13332
13333
13334
13335
13336
13337
13338
13339
13340
13341
13342
13343
13344
13345
13346
13347
13348
13349
13350
13351
13352
13353
13354
13355
13356
13357
13358
13359
13360
13361
13362
13363
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13314

SWIGINTERN VALUE _wrap_okDeviceSensors_erase(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< okTDeviceSensor >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_okDeviceSensors_erase__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< okTDeviceSensor >::iterator > *>(iter) != 0));
      if (_v) {
        swig::ConstIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< okTDeviceSensor >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_okDeviceSensors_erase__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "erase", 
    "    std::vector< okTDeviceSensor >::iterator erase(std::vector< okTDeviceSensor >::iterator pos)\n"
    "    std::vector< okTDeviceSensor >::iterator erase(std::vector< okTDeviceSensor >::iterator first, std::vector< okTDeviceSensor >::iterator last)\n");
  
  return Qnil;
}

#front(*args) ⇒ Object

call-seq:

front -> okTDeviceSensor

Return the first element in okDeviceSensors.



13482
13483
13484
13485
13486
13487
13488
13489
13490
13491
13492
13493
13494
13495
13496
13497
13498
13499
13500
13501
13502
13503
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13482

SWIGINTERN VALUE
_wrap_okDeviceSensors_front(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::value_type *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","front", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor >::value_type *) &((std::vector< okTDeviceSensor > const *)arg1)->front();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_okTDeviceSensor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#get_allocator(*args) ⇒ Object 



13125
13126
13127
13128
13129
13130
13131
13132
13133
13134
13135
13136
13137
13138
13139
13140
13141
13142
13143
13144
13145
13146
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13125

SWIGINTERN VALUE
_wrap_okDeviceSensors_get_allocator(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::allocator< okTDeviceSensor > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","get_allocator", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = ((std::vector< okTDeviceSensor > const *)arg1)->get_allocator();
  vresult = SWIG_NewPointerObj((new std::vector< okTDeviceSensor >::allocator_type(static_cast< const std::vector< okTDeviceSensor >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_okTDeviceSensor_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#insert(*args, self) ⇒ Object 



13804
13805
13806
13807
13808
13809
13810
13811
13812
13813
13814
13815
13816
13817
13818
13819
13820
13821
13822
13823
13824
13825
13826
13827
13828
13829
13830
13831
13832
13833
13834
13835
13836
13837
13838
13839
13840
13841
13842
13843
13844
13845
13846
13847
13848
13849
13850
13851
13852
13853
13854
13855
13856
13857
13858
13859
13860
13861
13862
13863
13864
13865
13866
13867
13868
13869
13870
13871
13872
13873
13874
13875
13876
13877
13878
13879
13880
13881
13882
13883
13884
13885
13886
13887
13888
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13804

SWIGINTERN VALUE _wrap_okDeviceSensors_insert(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< okTDeviceSensor >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_okTDeviceSensor, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_okDeviceSensors_insert__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_okDeviceSensors_insert__SWIG_0(nargs, args, self);
          }
          return _wrap_okDeviceSensors_insert__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< okTDeviceSensor >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_okTDeviceSensor, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_okDeviceSensors_insert__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "insert", 
    "    std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > insert(std::vector< okTDeviceSensor >::difference_type pos, int argc, VALUE *argv, ...)\n"
    "    std::vector< okTDeviceSensor >::iterator insert(std::vector< okTDeviceSensor >::iterator pos, std::vector< okTDeviceSensor >::value_type const &x)\n"
    "    void insert(std::vector< okTDeviceSensor >::iterator pos, std::vector< okTDeviceSensor >::size_type n, std::vector< okTDeviceSensor >::value_type const &x)\n");
  
  return Qnil;
}

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



11875
11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
11892
11893
11894
11895
11896
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 11875

SWIGINTERN VALUE
_wrap_okDeviceSensors_inspect(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__inspect(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#pop(*args) ⇒ Object

call-seq:

pop -> VALUE

Remove and return element at the end of the okDeviceSensors.



12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12598

SWIGINTERN VALUE
_wrap_okDeviceSensors_pop(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","pop", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__pop(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#push(*args) ⇒ Object Also known as: <<

call-seq:

push(e) -> okTDeviceSensor

Add an element at the end of the okDeviceSensors.



12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
12655
12656
12657
12658
12659
12660
12661
12662
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12630

SWIGINTERN VALUE
_wrap_okDeviceSensors_push(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< okTDeviceSensor >::value_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","push", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_okTDeviceSensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::value_type const &","push", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTDeviceSensor >::value_type const &","push", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< okTDeviceSensor >::value_type * >(argp2);
  result = std_vector_Sl_okTDeviceSensor_Sg__push(arg1,(okTDeviceSensor const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::vector< okTDeviceSensor >::value_type(static_cast< const std::vector< okTDeviceSensor >::value_type& >(result))), SWIGTYPE_p_okTDeviceSensor, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#rbegin(*args) ⇒ Object

call-seq:

rbegin -> std::vector< okTDeviceSensor >::reverse_iterator

Return a reverse iterator to the beginning (the end) of the okDeviceSensors.



13036
13037
13038
13039
13040
13041
13042
13043
13044
13045
13046
13047
13048
13049
13050
13051
13052
13053
13054
13055
13056
13057
13058
13059
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13036

SWIGINTERN VALUE
_wrap_okDeviceSensors_rbegin(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::reverse_iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","rbegin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (arg1)->rbegin();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTDeviceSensor >::reverse_iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#reject(*args) ⇒ Object

call-seq:

reject -> okDeviceSensors

Iterate thru each element in the okDeviceSensors and reject those that fail a condition returning a new okDeviceSensors. A block must be provided.



12673
12674
12675
12676
12677
12678
12679
12680
12681
12682
12683
12684
12685
12686
12687
12688
12689
12690
12691
12692
12693
12694
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12673

SWIGINTERN VALUE
_wrap_okDeviceSensors_reject(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","reject", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *)std_vector_Sl_okTDeviceSensor_Sg__reject(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#reject!(*args) ⇒ Object Also known as: delete_if

call-seq:

reject! -> okDeviceSensors

Iterate thru each element in the okDeviceSensors and reject those that fail a condition. A block must be provided. okDeviceSensors is modified in place.



12566
12567
12568
12569
12570
12571
12572
12573
12574
12575
12576
12577
12578
12579
12580
12581
12582
12583
12584
12585
12586
12587
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12566

SWIGINTERN VALUE
_wrap_okDeviceSensors_rejectN___(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","reject_bang", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *)std_vector_Sl_okTDeviceSensor_Sg__reject_bang(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#rend(*args) ⇒ Object

call-seq:

rend -> std::vector< okTDeviceSensor >::reverse_iterator

Return a reverse iterator to past the end (past the beginning) of the okDeviceSensors.



13070
13071
13072
13073
13074
13075
13076
13077
13078
13079
13080
13081
13082
13083
13084
13085
13086
13087
13088
13089
13090
13091
13092
13093
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13070

SWIGINTERN VALUE
_wrap_okDeviceSensors_rend(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::reverse_iterator result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","rend", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (arg1)->rend();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTDeviceSensor >::reverse_iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#reserve(*args) ⇒ Object

call-seq:

reserve(n)

Reserve memory in the okDeviceSensors for a number of elements.



13899
13900
13901
13902
13903
13904
13905
13906
13907
13908
13909
13910
13911
13912
13913
13914
13915
13916
13917
13918
13919
13920
13921
13922
13923
13924
13925
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13899

SWIGINTERN VALUE
_wrap_okDeviceSensors_reserve(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","reserve", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::size_type","reserve", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTDeviceSensor >::size_type >(val2);
  (arg1)->reserve(arg2);
  return Qnil;
fail:
  return Qnil;
}

#resize(*args, self) ⇒ Object 



13635
13636
13637
13638
13639
13640
13641
13642
13643
13644
13645
13646
13647
13648
13649
13650
13651
13652
13653
13654
13655
13656
13657
13658
13659
13660
13661
13662
13663
13664
13665
13666
13667
13668
13669
13670
13671
13672
13673
13674
13675
13676
13677
13678
13679
13680
13681
13682
13683
13684
13685
13686
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13635

SWIGINTERN VALUE _wrap_okDeviceSensors_resize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_okDeviceSensors_resize__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_okTDeviceSensor, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_okDeviceSensors_resize__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "okDeviceSensors.resize", 
    "    void okDeviceSensors.resize(std::vector< okTDeviceSensor >::size_type new_size)\n"
    "    void okDeviceSensors.resize(std::vector< okTDeviceSensor >::size_type new_size, std::vector< okTDeviceSensor >::value_type const &x)\n");
  
  return Qnil;
}

#select(*args) ⇒ Object

call-seq:

select -> okDeviceSensors

Iterate thru each element in the okDeviceSensors and select those that match a condition. A block must be provided.



12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12090

SWIGINTERN VALUE
_wrap_okDeviceSensors_select(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *)std_vector_Sl_okTDeviceSensor_Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#shift(*args) ⇒ Object

call-seq:

shift -> VALUE

Remove and return element at the beginning of the okDeviceSensors.



12705
12706
12707
12708
12709
12710
12711
12712
12713
12714
12715
12716
12717
12718
12719
12720
12721
12722
12723
12724
12725
12726
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12705

SWIGINTERN VALUE
_wrap_okDeviceSensors_shift(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","shift", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__shift(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#size(*args) ⇒ Object

call-seq:

size -> std::vector< okTDeviceSensor >::size_type

Size or Length of the okDeviceSensors.



12904
12905
12906
12907
12908
12909
12910
12911
12912
12913
12914
12915
12916
12917
12918
12919
12920
12921
12922
12923
12924
12925
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12904

SWIGINTERN VALUE
_wrap_okDeviceSensors_size(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor >::size_type result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = ((std::vector< okTDeviceSensor > const *)arg1)->size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#slice(*args) ⇒ Object

call-seq:

slice(i, length) -> VALUE

Return a slice (portion of) the okDeviceSensors.



11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990
11991
11992
11993
11994
11995
11996
11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 11971

SWIGINTERN VALUE
_wrap_okDeviceSensors_slice(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor >::difference_type arg2 ;
  std::vector< okTDeviceSensor >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","slice", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::difference_type","slice", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTDeviceSensor >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor >::difference_type","slice", 3, argv[1] ));
  } 
  arg3 = static_cast< std::vector< okTDeviceSensor >::difference_type >(val3);
  try {
    result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__slice(arg1,arg2,arg3);
  } catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#swap(*args) ⇒ Object 



12928
12929
12930
12931
12932
12933
12934
12935
12936
12937
12938
12939
12940
12941
12942
12943
12944
12945
12946
12947
12948
12949
12950
12951
12952
12953
12954
12955
12956
12957
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12928

SWIGINTERN VALUE
_wrap_okDeviceSensors_swap(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  std::vector< okTDeviceSensor > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTDeviceSensor > &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert okDeviceSensors to an Array.



11907
11908
11909
11910
11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 11907

SWIGINTERN VALUE
_wrap_okDeviceSensors_to_a(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","to_a", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__to_a(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#to_s(*args) ⇒ Object

call-seq:

to_s -> VALUE

Convert class to a String representation.



11939
11940
11941
11942
11943
11944
11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 11939

SWIGINTERN VALUE
_wrap_okDeviceSensors_to_s(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","to_s", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  result = (VALUE)std_vector_Sl_okTDeviceSensor_Sg__to_s(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#unshift(*args) ⇒ Object

call-seq:

unshift(argc) -> okDeviceSensors

Add one or more elements at the beginning of the okDeviceSensors.



12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
12796
12797
12798
12799
12800
12801
12802
12803
12804
12805
12806
12807
12808
12809
12810
12811
12812
12813
12814
 
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 12786

SWIGINTERN VALUE
_wrap_okDeviceSensors_unshift(int argc, VALUE *argv, VALUE self) {
  std::vector< okTDeviceSensor > *arg1 = (std::vector< okTDeviceSensor > *) 0 ;
  int arg2 ;
  VALUE *arg3 = (VALUE *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc < 1) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTDeviceSensor > *","unshift", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTDeviceSensor > * >(argp1);
  {
    arg2 = argc;
    arg3 = argv;
  }
  result = (std::vector< okTDeviceSensor,std::allocator< okTDeviceSensor > > *)std_vector_Sl_okTDeviceSensor_Sg__unshift(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTDeviceSensor_std__allocatorT_okTDeviceSensor_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}