Class: Mykytea::TagsVector

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



15661
15662
15663
15664
15665
15666
15667
15668
15669
15670
15671
15672
15673
15674
15675
15676
15677
15678
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/mykytea_wrap.cxx', line 15661

SWIGINTERN VALUE _wrap_new_TagsVector(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_TagsVector__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_TagsVector__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Tags,std::allocator< Tags > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TagsVector__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_Tags, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TagsVector__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TagsVector.new", 
    "    TagsVector.new()\n"
    "    TagsVector.new(std::vector< Tags > const &other)\n"
    "    TagsVector.new(std::vector< Tags >::size_type size)\n"
    "    TagsVector.new(std::vector< Tags >::size_type size, std::vector< Tags >::value_type const &value)\n");
  
  return Qnil;
}

Instance Method Details

#[](*args, self) ⇒ Object

call-seq:

[](i, length) -> VALUE
[](i) -> VALUE
[](i) -> VALUE

Element accessor/slicing.



14559
14560
14561
14562
14563
14564
14565
14566
14567
14568
14569
14570
14571
14572
14573
14574
14575
14576
14577
14578
14579
14580
14581
14582
14583
14584
14585
14586
14587
14588
14589
14590
14591
14592
14593
14594
14595
14596
14597
14598
14599
14600
14601
14602
14603
14604
14605
14606
14607
14608
14609
14610
14611
14612
14613
14614
14615
14616
14617
14618
14619
14620
14621
14622
14623
 
# File 'ext/mykytea_wrap.cxx', line 14559

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

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

call-seq:

[]=(i, x) -> VALUE
[]=(i, length, v) -> VALUE

Element setter/slicing.



14743
14744
14745
14746
14747
14748
14749
14750
14751
14752
14753
14754
14755
14756
14757
14758
14759
14760
14761
14762
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
14796
14797
14798
14799
14800
14801
14802
14803
14804
 
# File 'ext/mykytea_wrap.cxx', line 14743

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

#__delete2__(*args) ⇒ Object 



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
14325
14326
14327
14328
 
# File 'ext/mykytea_wrap.cxx', line 14296

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

#assign(*args) ⇒ Object

call-seq:

assign(n, x)

Assign a new TagsVector or portion of it.



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
15820
15821
15822
15823
15824
15825
15826
15827
15828
 
# File 'ext/mykytea_wrap.cxx', line 15791

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

#at(*args) ⇒ Object

call-seq:

at(i) -> VALUE

Return element at a certain index.



14411
14412
14413
14414
14415
14416
14417
14418
14419
14420
14421
14422
14423
14424
14425
14426
14427
14428
14429
14430
14431
14432
14433
14434
14435
14436
14437
14438
14439
14440
 
# File 'ext/mykytea_wrap.cxx', line 14411

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

#back(*args) ⇒ Object

call-seq:

back -> Tags

Return the last element in TagsVector.



15759
15760
15761
15762
15763
15764
15765
15766
15767
15768
15769
15770
15771
15772
15773
15774
15775
15776
15777
15778
15779
15780
 
# File 'ext/mykytea_wrap.cxx', line 15759

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

#begin(*args) ⇒ Object

call-seq:

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

Return an iterator to the beginning of the TagsVector.



15215
15216
15217
15218
15219
15220
15221
15222
15223
15224
15225
15226
15227
15228
15229
15230
15231
15232
15233
15234
15235
15236
15237
15238
 
# File 'ext/mykytea_wrap.cxx', line 15215

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

#capacity(*args) ⇒ Object

call-seq:

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

Reserved capacity of the TagsVector.



16181
16182
16183
16184
16185
16186
16187
16188
16189
16190
16191
16192
16193
16194
16195
16196
16197
16198
16199
16200
16201
16202
 
# File 'ext/mykytea_wrap.cxx', line 16181

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



15351
15352
15353
15354
15355
15356
15357
15358
15359
15360
15361
15362
15363
15364
15365
15366
15367
15368
15369
 
# File 'ext/mykytea_wrap.cxx', line 15351

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



14371
14372
14373
14374
14375
14376
14377
14378
14379
14380
14381
14382
14383
14384
14385
14386
14387
14388
14389
14390
14391
14392
14393
14394
14395
14396
14397
14398
14399
14400
 
# File 'ext/mykytea_wrap.cxx', line 14371

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

#dup(*args) ⇒ Object

call-seq:

dup -> TagsVector

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



14092
14093
14094
14095
14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
 
# File 'ext/mykytea_wrap.cxx', line 14092

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

#each(*args) ⇒ Object

call-seq:

each -> TagsVector

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



14272
14273
14274
14275
14276
14277
14278
14279
14280
14281
14282
14283
14284
14285
14286
14287
14288
14289
14290
14291
14292
14293
 
# File 'ext/mykytea_wrap.cxx', line 14272

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

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the TagsVector is empty or not.

Returns:

  • (Boolean) 


15119
15120
15121
15122
15123
15124
15125
15126
15127
15128
15129
15130
15131
15132
15133
15134
15135
15136
15137
15138
15139
15140
 
# File 'ext/mykytea_wrap.cxx', line 15119

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

#end(*args) ⇒ Object

call-seq:

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

Return an iterator to past the end of the TagsVector.



15249
15250
15251
15252
15253
15254
15255
15256
15257
15258
15259
15260
15261
15262
15263
15264
15265
15266
15267
15268
15269
15270
15271
15272
 
# File 'ext/mykytea_wrap.cxx', line 15249

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

#erase(*args, self) ⇒ Object

call-seq:

erase(pos) -> std::vector< Tags >::iterator
erase(first, last) -> std::vector< Tags >::iterator

Delete a portion of the TagsVector.



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
15605
15606
15607
15608
15609
 
# File 'ext/mykytea_wrap.cxx', line 15560

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

#front(*args) ⇒ Object

call-seq:

front -> Tags

Return the first element in TagsVector.



15727
15728
15729
15730
15731
15732
15733
15734
15735
15736
15737
15738
15739
15740
15741
15742
15743
15744
15745
15746
15747
15748
 
# File 'ext/mykytea_wrap.cxx', line 15727

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

#get_allocator(*args) ⇒ Object 



15372
15373
15374
15375
15376
15377
15378
15379
15380
15381
15382
15383
15384
15385
15386
15387
15388
15389
15390
15391
15392
15393
 
# File 'ext/mykytea_wrap.cxx', line 15372

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

#insert(*args, self) ⇒ Object

call-seq:

insert(pos, argc) -> TagsVector
insert(pos, x) -> std::vector< Tags >::iterator
insert(pos, n, x)

Insert one or more new elements in the TagsVector.



16049
16050
16051
16052
16053
16054
16055
16056
16057
16058
16059
16060
16061
16062
16063
16064
16065
16066
16067
16068
16069
16070
16071
16072
16073
16074
16075
16076
16077
16078
16079
16080
16081
16082
16083
16084
16085
16086
16087
16088
16089
16090
16091
16092
16093
16094
16095
16096
16097
16098
16099
16100
16101
16102
16103
16104
16105
16106
16107
16108
16109
16110
16111
16112
16113
16114
16115
16116
16117
16118
16119
16120
16121
16122
16123
16124
16125
16126
16127
16128
16129
16130
16131
16132
16133
 
# File 'ext/mykytea_wrap.cxx', line 16049

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

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



14124
14125
14126
14127
14128
14129
14130
14131
14132
14133
14134
14135
14136
14137
14138
14139
14140
14141
14142
14143
14144
14145
 
# File 'ext/mykytea_wrap.cxx', line 14124

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



14847
14848
14849
14850
14851
14852
14853
14854
14855
14856
14857
14858
14859
14860
14861
14862
14863
14864
14865
14866
14867
14868
 
# File 'ext/mykytea_wrap.cxx', line 14847

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

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

call-seq:

push(e) -> Tags

Add an element at the end of the TagsVector.



14879
14880
14881
14882
14883
14884
14885
14886
14887
14888
14889
14890
14891
14892
14893
14894
14895
14896
14897
14898
14899
14900
14901
14902
14903
14904
14905
14906
14907
14908
14909
14910
14911
 
# File 'ext/mykytea_wrap.cxx', line 14879

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

#rbegin(*args) ⇒ Object

call-seq:

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

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



15283
15284
15285
15286
15287
15288
15289
15290
15291
15292
15293
15294
15295
15296
15297
15298
15299
15300
15301
15302
15303
15304
15305
15306
 
# File 'ext/mykytea_wrap.cxx', line 15283

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

#reject(*args) ⇒ Object

call-seq:

reject -> TagsVector

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



14922
14923
14924
14925
14926
14927
14928
14929
14930
14931
14932
14933
14934
14935
14936
14937
14938
14939
14940
14941
14942
14943
 
# File 'ext/mykytea_wrap.cxx', line 14922

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

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

call-seq:

reject! -> TagsVector

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



14815
14816
14817
14818
14819
14820
14821
14822
14823
14824
14825
14826
14827
14828
14829
14830
14831
14832
14833
14834
14835
14836
 
# File 'ext/mykytea_wrap.cxx', line 14815

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

#rend(*args) ⇒ Object

call-seq:

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

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



15317
15318
15319
15320
15321
15322
15323
15324
15325
15326
15327
15328
15329
15330
15331
15332
15333
15334
15335
15336
15337
15338
15339
15340
 
# File 'ext/mykytea_wrap.cxx', line 15317

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



16144
16145
16146
16147
16148
16149
16150
16151
16152
16153
16154
16155
16156
16157
16158
16159
16160
16161
16162
16163
16164
16165
16166
16167
16168
16169
16170
 
# File 'ext/mykytea_wrap.cxx', line 16144

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

#resize(*args, self) ⇒ Object

call-seq:

resize(new_size)
resize(new_size, x)

Resize the size of the TagsVector.



15880
15881
15882
15883
15884
15885
15886
15887
15888
15889
15890
15891
15892
15893
15894
15895
15896
15897
15898
15899
15900
15901
15902
15903
15904
15905
15906
15907
15908
15909
15910
15911
15912
15913
15914
15915
15916
15917
15918
15919
15920
15921
15922
15923
15924
15925
15926
15927
15928
15929
15930
15931
 
# File 'ext/mykytea_wrap.cxx', line 15880

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

#select(*args) ⇒ Object

call-seq:

select -> TagsVector

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



14339
14340
14341
14342
14343
14344
14345
14346
14347
14348
14349
14350
14351
14352
14353
14354
14355
14356
14357
14358
14359
14360
 
# File 'ext/mykytea_wrap.cxx', line 14339

SWIGINTERN VALUE
_wrap_TagsVector_select(int argc, VALUE *argv, VALUE self) {
  std::vector< Tags > *arg1 = (std::vector< Tags > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Tags,std::allocator< Tags > > *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_Tags_std__allocatorT_Tags_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< Tags > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< Tags > * >(argp1);
  result = (std::vector< Tags,std::allocator< Tags > > *)std_vector_Sl_Tags_Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Tags_std__allocatorT_Tags_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 TagsVector.



14954
14955
14956
14957
14958
14959
14960
14961
14962
14963
14964
14965
14966
14967
14968
14969
14970
14971
14972
14973
14974
14975
 
# File 'ext/mykytea_wrap.cxx', line 14954

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

#size(*args) ⇒ Object

call-seq:

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

Size or Length of the TagsVector.



15151
15152
15153
15154
15155
15156
15157
15158
15159
15160
15161
15162
15163
15164
15165
15166
15167
15168
15169
15170
15171
15172
 
# File 'ext/mykytea_wrap.cxx', line 15151

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



14220
14221
14222
14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233
14234
14235
14236
14237
14238
14239
14240
14241
14242
14243
14244
14245
14246
14247
14248
14249
14250
14251
14252
14253
14254
14255
14256
14257
14258
14259
14260
14261
 
# File 'ext/mykytea_wrap.cxx', line 14220

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



15175
15176
15177
15178
15179
15180
15181
15182
15183
15184
15185
15186
15187
15188
15189
15190
15191
15192
15193
15194
15195
15196
15197
15198
15199
15200
15201
15202
15203
15204
 
# File 'ext/mykytea_wrap.cxx', line 15175

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

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert TagsVector to an Array.



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

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



14188
14189
14190
14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
14202
14203
14204
14205
14206
14207
14208
14209
 
# File 'ext/mykytea_wrap.cxx', line 14188

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

#unshift(*args) ⇒ Object

call-seq:

unshift(argc) -> TagsVector

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



15035
15036
15037
15038
15039
15040
15041
15042
15043
15044
15045
15046
15047
15048
15049
15050
15051
15052
15053
15054
15055
15056
15057
15058
15059
15060
15061
15062
15063
 
# File 'ext/mykytea_wrap.cxx', line 15035

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