Class: OpalKelly::OkTRegisterEntries

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object



15549
15550
15551
15552
15553
15554
15555
15556
15557
15558
15559
15560
15561
15562
15563
15564
15565
15566
15567
15568
15569
15570
15571
15572
15573
15574
15575
15576
15577
15578
15579
15580
15581
15582
15583
15584
15585
15586
15587
15588
15589
15590
15591
15592
15593
15594
15595
15596
15597
15598
15599
15600
15601
15602
15603
15604
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15549

SWIGINTERN VALUE _wrap_new_okTRegisterEntries(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_okTRegisterEntries__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_okTRegisterEntries__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_okTRegisterEntries__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_okTRegisterEntry, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_okTRegisterEntries__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "okTRegisterEntries.new", 
    "    okTRegisterEntries.new()\n"
    "    okTRegisterEntries.new(std::vector< okTRegisterEntry > const &other)\n"
    "    okTRegisterEntries.new(std::vector< okTRegisterEntry >::size_type size)\n"
    "    okTRegisterEntries.new(std::vector< okTRegisterEntry >::size_type size, std::vector< okTRegisterEntry >::value_type const &value)\n");
  
  return Qnil;
}

Instance Method Details

#[](*args, self) ⇒ Object



14443
14444
14445
14446
14447
14448
14449
14450
14451
14452
14453
14454
14455
14456
14457
14458
14459
14460
14461
14462
14463
14464
14465
14466
14467
14468
14469
14470
14471
14472
14473
14474
14475
14476
14477
14478
14479
14480
14481
14482
14483
14484
14485
14486
14487
14488
14489
14490
14491
14492
14493
14494
14495
14496
14497
14498
14499
14500
14501
14502
14503
14504
14505
14506
14507
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14443

SWIGINTERN VALUE _wrap_okTRegisterEntries___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< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_okTRegisterEntries___getitem____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_okTRegisterEntries___getitem____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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_okTRegisterEntries___getitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
    "    VALUE __getitem__(std::vector< okTRegisterEntry >::difference_type i, std::vector< okTRegisterEntry >::difference_type length)\n"
    "    VALUE __getitem__(std::vector< okTRegisterEntry >::difference_type i)\n"
    "    VALUE __getitem__(VALUE i)\n");
  
  return Qnil;
}

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



14627
14628
14629
14630
14631
14632
14633
14634
14635
14636
14637
14638
14639
14640
14641
14642
14643
14644
14645
14646
14647
14648
14649
14650
14651
14652
14653
14654
14655
14656
14657
14658
14659
14660
14661
14662
14663
14664
14665
14666
14667
14668
14669
14670
14671
14672
14673
14674
14675
14676
14677
14678
14679
14680
14681
14682
14683
14684
14685
14686
14687
14688
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14627

SWIGINTERN VALUE _wrap_okTRegisterEntries___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< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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_okTRegisterEntry, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_okTRegisterEntries___setitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_okTRegisterEntries___setitem____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__setitem__", 
    "    VALUE __setitem__(std::vector< okTRegisterEntry >::difference_type i, std::vector< okTRegisterEntry >::value_type const &x)\n"
    "    VALUE __setitem__(std::vector< okTRegisterEntry >::difference_type i, std::vector< okTRegisterEntry >::difference_type length, std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > const &v)\n");
  
  return Qnil;
}

#__delete2__(*args) ⇒ Object



14180
14181
14182
14183
14184
14185
14186
14187
14188
14189
14190
14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
14202
14203
14204
14205
14206
14207
14208
14209
14210
14211
14212
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14180

SWIGINTERN VALUE
_wrap_okTRegisterEntries___delete2__(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","__delete2__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_okTRegisterEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::value_type const &","__delete2__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTRegisterEntry >::value_type const &","__delete2__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< okTRegisterEntry >::value_type * >(argp2);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_Sg____delete2__(arg1,(okTRegisterEntry const &)*arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#assign(*args) ⇒ Object

call-seq:

assign(n, x)

Assign a new okTRegisterEntries or portion of it.



15679
15680
15681
15682
15683
15684
15685
15686
15687
15688
15689
15690
15691
15692
15693
15694
15695
15696
15697
15698
15699
15700
15701
15702
15703
15704
15705
15706
15707
15708
15709
15710
15711
15712
15713
15714
15715
15716
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15679

SWIGINTERN VALUE
_wrap_okTRegisterEntries_assign(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::size_type arg2 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::size_type","assign", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTRegisterEntry >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_okTRegisterEntry,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::value_type const &","assign", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTRegisterEntry >::value_type const &","assign", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< std::vector< okTRegisterEntry >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< okTRegisterEntry >::value_type const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}

#at(*args) ⇒ Object

call-seq:

at(i) -> VALUE

Return element at a certain index.



14295
14296
14297
14298
14299
14300
14301
14302
14303
14304
14305
14306
14307
14308
14309
14310
14311
14312
14313
14314
14315
14316
14317
14318
14319
14320
14321
14322
14323
14324
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14295

SWIGINTERN VALUE
_wrap_okTRegisterEntries_at(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::difference_type","at", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTRegisterEntry >::difference_type >(val2);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_Sg__at((std::vector< okTRegisterEntry > const *)arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#back(*args) ⇒ Object

call-seq:

back -> okTRegisterEntry

Return the last element in okTRegisterEntries.



15647
15648
15649
15650
15651
15652
15653
15654
15655
15656
15657
15658
15659
15660
15661
15662
15663
15664
15665
15666
15667
15668
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15647

SWIGINTERN VALUE
_wrap_okTRegisterEntries_back(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","back", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry >::value_type *) &((std::vector< okTRegisterEntry > const *)arg1)->back();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_okTRegisterEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#begin(*args) ⇒ Object

call-seq:

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

Return an iterator to the beginning of the okTRegisterEntries.



15101
15102
15103
15104
15105
15106
15107
15108
15109
15110
15111
15112
15113
15114
15115
15116
15117
15118
15119
15120
15121
15122
15123
15124
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15101

SWIGINTERN VALUE
_wrap_okTRegisterEntries_begin(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (arg1)->begin();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTRegisterEntry >::iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#capacity(*args) ⇒ Object

call-seq:

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

Reserved capacity of the okTRegisterEntries.



16069
16070
16071
16072
16073
16074
16075
16076
16077
16078
16079
16080
16081
16082
16083
16084
16085
16086
16087
16088
16089
16090
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 16069

SWIGINTERN VALUE
_wrap_okTRegisterEntries_capacity(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","capacity", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = ((std::vector< okTRegisterEntry > 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 okTRegisterEntries contents.



15237
15238
15239
15240
15241
15242
15243
15244
15245
15246
15247
15248
15249
15250
15251
15252
15253
15254
15255
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15237

SWIGINTERN VALUE
_wrap_okTRegisterEntries_clear(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(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.



14255
14256
14257
14258
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268
14269
14270
14271
14272
14273
14274
14275
14276
14277
14278
14279
14280
14281
14282
14283
14284
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14255

SWIGINTERN VALUE
_wrap_okTRegisterEntries_delete_at(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","delete_at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::difference_type","delete_at", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTRegisterEntry >::difference_type >(val2);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_Sg__delete_at(arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#dup(*args) ⇒ Object

call-seq:

dup -> okTRegisterEntries

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



13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 13976

SWIGINTERN VALUE
_wrap_okTRegisterEntries_dup(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","dup", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *)std_vector_Sl_okTRegisterEntry_Sg__dup(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#each(*args) ⇒ Object

call-seq:

each -> okTRegisterEntries

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



14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
14175
14176
14177
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14156

SWIGINTERN VALUE
_wrap_okTRegisterEntries_each(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","each", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *)std_vector_Sl_okTRegisterEntry_Sg__each(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the okTRegisterEntries is empty or not.

Returns:

  • (Boolean)


15005
15006
15007
15008
15009
15010
15011
15012
15013
15014
15015
15016
15017
15018
15019
15020
15021
15022
15023
15024
15025
15026
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15005

SWIGINTERN VALUE
_wrap_okTRegisterEntries_emptyq___(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","empty", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (bool)((std::vector< okTRegisterEntry > const *)arg1)->empty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#end(*args) ⇒ Object

call-seq:

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

Return an iterator to past the end of the okTRegisterEntries.



15135
15136
15137
15138
15139
15140
15141
15142
15143
15144
15145
15146
15147
15148
15149
15150
15151
15152
15153
15154
15155
15156
15157
15158
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15135

SWIGINTERN VALUE
_wrap_okTRegisterEntries_end(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (arg1)->end();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTRegisterEntry >::iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#erase(*args, self) ⇒ Object



15447
15448
15449
15450
15451
15452
15453
15454
15455
15456
15457
15458
15459
15460
15461
15462
15463
15464
15465
15466
15467
15468
15469
15470
15471
15472
15473
15474
15475
15476
15477
15478
15479
15480
15481
15482
15483
15484
15485
15486
15487
15488
15489
15490
15491
15492
15493
15494
15495
15496
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15447

SWIGINTERN VALUE _wrap_okTRegisterEntries_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< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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< okTRegisterEntry >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_okTRegisterEntries_erase__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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< okTRegisterEntry >::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< okTRegisterEntry >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_okTRegisterEntries_erase__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "erase", 
    "    std::vector< okTRegisterEntry >::iterator erase(std::vector< okTRegisterEntry >::iterator pos)\n"
    "    std::vector< okTRegisterEntry >::iterator erase(std::vector< okTRegisterEntry >::iterator first, std::vector< okTRegisterEntry >::iterator last)\n");
  
  return Qnil;
}

#front(*args) ⇒ Object

call-seq:

front -> okTRegisterEntry

Return the first element in okTRegisterEntries.



15615
15616
15617
15618
15619
15620
15621
15622
15623
15624
15625
15626
15627
15628
15629
15630
15631
15632
15633
15634
15635
15636
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15615

SWIGINTERN VALUE
_wrap_okTRegisterEntries_front(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","front", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry >::value_type *) &((std::vector< okTRegisterEntry > const *)arg1)->front();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_okTRegisterEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#get_allocator(*args) ⇒ Object



15258
15259
15260
15261
15262
15263
15264
15265
15266
15267
15268
15269
15270
15271
15272
15273
15274
15275
15276
15277
15278
15279
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15258

SWIGINTERN VALUE
_wrap_okTRegisterEntries_get_allocator(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::allocator< okTRegisterEntry > > 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","get_allocator", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = ((std::vector< okTRegisterEntry > const *)arg1)->get_allocator();
  vresult = SWIG_NewPointerObj((new std::vector< okTRegisterEntry >::allocator_type(static_cast< const std::vector< okTRegisterEntry >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_okTRegisterEntry_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#insert(*args, self) ⇒ Object



15937
15938
15939
15940
15941
15942
15943
15944
15945
15946
15947
15948
15949
15950
15951
15952
15953
15954
15955
15956
15957
15958
15959
15960
15961
15962
15963
15964
15965
15966
15967
15968
15969
15970
15971
15972
15973
15974
15975
15976
15977
15978
15979
15980
15981
15982
15983
15984
15985
15986
15987
15988
15989
15990
15991
15992
15993
15994
15995
15996
15997
15998
15999
16000
16001
16002
16003
16004
16005
16006
16007
16008
16009
16010
16011
16012
16013
16014
16015
16016
16017
16018
16019
16020
16021
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15937

SWIGINTERN VALUE _wrap_okTRegisterEntries_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< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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< okTRegisterEntry >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_okTRegisterEntry, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_okTRegisterEntries_insert__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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_okTRegisterEntries_insert__SWIG_0(nargs, args, self);
          }
          return _wrap_okTRegisterEntries_insert__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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< okTRegisterEntry >::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_okTRegisterEntry, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_okTRegisterEntries_insert__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "insert", 
    "    std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > insert(std::vector< okTRegisterEntry >::difference_type pos, int argc, VALUE *argv, ...)\n"
    "    std::vector< okTRegisterEntry >::iterator insert(std::vector< okTRegisterEntry >::iterator pos, std::vector< okTRegisterEntry >::value_type const &x)\n"
    "    void insert(std::vector< okTRegisterEntry >::iterator pos, std::vector< okTRegisterEntry >::size_type n, std::vector< okTRegisterEntry >::value_type const &x)\n");
  
  return Qnil;
}

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



14008
14009
14010
14011
14012
14013
14014
14015
14016
14017
14018
14019
14020
14021
14022
14023
14024
14025
14026
14027
14028
14029
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14008

SWIGINTERN VALUE
_wrap_okTRegisterEntries_inspect(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_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 okTRegisterEntries.



14731
14732
14733
14734
14735
14736
14737
14738
14739
14740
14741
14742
14743
14744
14745
14746
14747
14748
14749
14750
14751
14752
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14731

SWIGINTERN VALUE
_wrap_okTRegisterEntries_pop(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","pop", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_Sg__pop(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

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

call-seq:

push(e) -> okTRegisterEntry

Add an element at the end of the okTRegisterEntries.



14763
14764
14765
14766
14767
14768
14769
14770
14771
14772
14773
14774
14775
14776
14777
14778
14779
14780
14781
14782
14783
14784
14785
14786
14787
14788
14789
14790
14791
14792
14793
14794
14795
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14763

SWIGINTERN VALUE
_wrap_okTRegisterEntries_push(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","push", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_okTRegisterEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::value_type const &","push", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTRegisterEntry >::value_type const &","push", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< okTRegisterEntry >::value_type * >(argp2);
  result = std_vector_Sl_okTRegisterEntry_Sg__push(arg1,(okTRegisterEntry const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::vector< okTRegisterEntry >::value_type(static_cast< const std::vector< okTRegisterEntry >::value_type& >(result))), SWIGTYPE_p_okTRegisterEntry, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#rbegin(*args) ⇒ Object

call-seq:

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

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



15169
15170
15171
15172
15173
15174
15175
15176
15177
15178
15179
15180
15181
15182
15183
15184
15185
15186
15187
15188
15189
15190
15191
15192
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15169

SWIGINTERN VALUE
_wrap_okTRegisterEntries_rbegin(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","rbegin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (arg1)->rbegin();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTRegisterEntry >::reverse_iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#reject(*args) ⇒ Object

call-seq:

reject -> okTRegisterEntries

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



14806
14807
14808
14809
14810
14811
14812
14813
14814
14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14806

SWIGINTERN VALUE
_wrap_okTRegisterEntries_reject(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","reject", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *)std_vector_Sl_okTRegisterEntry_Sg__reject(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

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

call-seq:

reject! -> okTRegisterEntries

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



14699
14700
14701
14702
14703
14704
14705
14706
14707
14708
14709
14710
14711
14712
14713
14714
14715
14716
14717
14718
14719
14720
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14699

SWIGINTERN VALUE
_wrap_okTRegisterEntries_rejectN___(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","reject_bang", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *)std_vector_Sl_okTRegisterEntry_Sg__reject_bang(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#rend(*args) ⇒ Object

call-seq:

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

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



15203
15204
15205
15206
15207
15208
15209
15210
15211
15212
15213
15214
15215
15216
15217
15218
15219
15220
15221
15222
15223
15224
15225
15226
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15203

SWIGINTERN VALUE
_wrap_okTRegisterEntries_rend(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","rend", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (arg1)->rend();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< okTRegisterEntry >::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 okTRegisterEntries for a number of elements.



16032
16033
16034
16035
16036
16037
16038
16039
16040
16041
16042
16043
16044
16045
16046
16047
16048
16049
16050
16051
16052
16053
16054
16055
16056
16057
16058
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 16032

SWIGINTERN VALUE
_wrap_okTRegisterEntries_reserve(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","reserve", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::size_type","reserve", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTRegisterEntry >::size_type >(val2);
  (arg1)->reserve(arg2);
  return Qnil;
fail:
  return Qnil;
}

#resize(*args, self) ⇒ Object



15768
15769
15770
15771
15772
15773
15774
15775
15776
15777
15778
15779
15780
15781
15782
15783
15784
15785
15786
15787
15788
15789
15790
15791
15792
15793
15794
15795
15796
15797
15798
15799
15800
15801
15802
15803
15804
15805
15806
15807
15808
15809
15810
15811
15812
15813
15814
15815
15816
15817
15818
15819
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15768

SWIGINTERN VALUE _wrap_okTRegisterEntries_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< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_okTRegisterEntries_resize__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > >**)(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_okTRegisterEntry, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_okTRegisterEntries_resize__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "okTRegisterEntries.resize", 
    "    void okTRegisterEntries.resize(std::vector< okTRegisterEntry >::size_type new_size)\n"
    "    void okTRegisterEntries.resize(std::vector< okTRegisterEntry >::size_type new_size, std::vector< okTRegisterEntry >::value_type const &x)\n");
  
  return Qnil;
}

#select(*args) ⇒ Object

call-seq:

select -> okTRegisterEntries

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



14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233
14234
14235
14236
14237
14238
14239
14240
14241
14242
14243
14244
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14223

SWIGINTERN VALUE
_wrap_okTRegisterEntries_select(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *)std_vector_Sl_okTRegisterEntry_Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_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 okTRegisterEntries.



14838
14839
14840
14841
14842
14843
14844
14845
14846
14847
14848
14849
14850
14851
14852
14853
14854
14855
14856
14857
14858
14859
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14838

SWIGINTERN VALUE
_wrap_okTRegisterEntries_shift(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","shift", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_Sg__shift(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#size(*args) ⇒ Object

call-seq:

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

Size or Length of the okTRegisterEntries.



15037
15038
15039
15040
15041
15042
15043
15044
15045
15046
15047
15048
15049
15050
15051
15052
15053
15054
15055
15056
15057
15058
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15037

SWIGINTERN VALUE
_wrap_okTRegisterEntries_size(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = ((std::vector< okTRegisterEntry > 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 okTRegisterEntries.



14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120
14121
14122
14123
14124
14125
14126
14127
14128
14129
14130
14131
14132
14133
14134
14135
14136
14137
14138
14139
14140
14141
14142
14143
14144
14145
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14104

SWIGINTERN VALUE
_wrap_okTRegisterEntries_slice(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry >::difference_type arg2 ;
  std::vector< okTRegisterEntry >::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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","slice", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry >::difference_type","slice", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< okTRegisterEntry >::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< okTRegisterEntry >::difference_type","slice", 3, argv[1] ));
  } 
  arg3 = static_cast< std::vector< okTRegisterEntry >::difference_type >(val3);
  try {
    result = (VALUE)std_vector_Sl_okTRegisterEntry_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



15061
15062
15063
15064
15065
15066
15067
15068
15069
15070
15071
15072
15073
15074
15075
15076
15077
15078
15079
15080
15081
15082
15083
15084
15085
15086
15087
15088
15089
15090
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 15061

SWIGINTERN VALUE
_wrap_okTRegisterEntries_swap(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  std::vector< okTRegisterEntry > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< okTRegisterEntry > &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert okTRegisterEntries to an Array.



14040
14041
14042
14043
14044
14045
14046
14047
14048
14049
14050
14051
14052
14053
14054
14055
14056
14057
14058
14059
14060
14061
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14040

SWIGINTERN VALUE
_wrap_okTRegisterEntries_to_a(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","to_a", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_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.



14072
14073
14074
14075
14076
14077
14078
14079
14080
14081
14082
14083
14084
14085
14086
14087
14088
14089
14090
14091
14092
14093
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14072

SWIGINTERN VALUE
_wrap_okTRegisterEntries_to_s(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","to_s", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  result = (VALUE)std_vector_Sl_okTRegisterEntry_Sg__to_s(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#unshift(*args) ⇒ Object

call-seq:

unshift(argc) -> okTRegisterEntries

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



14919
14920
14921
14922
14923
14924
14925
14926
14927
14928
14929
14930
14931
14932
14933
14934
14935
14936
14937
14938
14939
14940
14941
14942
14943
14944
14945
14946
14947
# File 'ext/OpalKelly/FrontPanelDLL_wrap.cxx', line 14919

SWIGINTERN VALUE
_wrap_okTRegisterEntries_unshift(int argc, VALUE *argv, VALUE self) {
  std::vector< okTRegisterEntry > *arg1 = (std::vector< okTRegisterEntry > *) 0 ;
  int arg2 ;
  VALUE *arg3 = (VALUE *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *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_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< okTRegisterEntry > *","unshift", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< okTRegisterEntry > * >(argp1);
  {
    arg2 = argc;
    arg3 = argv;
  }
  result = (std::vector< okTRegisterEntry,std::allocator< okTRegisterEntry > > *)std_vector_Sl_okTRegisterEntry_Sg__unshift(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_okTRegisterEntry_std__allocatorT_okTRegisterEntry_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}