Class: Mykytea::PairVectorVector

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



13520
13521
13522
13523
13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564
13565
13566
13567
13568
13569
13570
13571
13572
13573
13574
 
# File 'ext/mykytea_wrap.cxx', line 13520

SWIGINTERN VALUE _wrap_new_PairVectorVector(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_PairVectorVector__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_PairVectorVector__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PairVectorVector__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) {
      int res = swig::asptr(argv[1], (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PairVectorVector__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "PairVectorVector.new", 
    "    PairVectorVector.new()\n"
    "    PairVectorVector.new(std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > const &other)\n"
    "    PairVectorVector.new(std::vector< std::vector< std::pair< std::string,double > > >::size_type size)\n"
    "    PairVectorVector.new(std::vector< std::vector< std::pair< std::string,double > > >::size_type size, std::vector< std::vector< std::pair< std::string,double > > >::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.



12407
12408
12409
12410
12411
12412
12413
12414
12415
12416
12417
12418
12419
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450
12451
12452
12453
12454
12455
12456
12457
12458
12459
12460
12461
12462
12463
12464
12465
12466
12467
12468
12469
12470
12471
 
# File 'ext/mykytea_wrap.cxx', line 12407

SWIGINTERN VALUE _wrap_PairVectorVector___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< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PairVectorVector___getitem____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_PairVectorVector___getitem____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(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_PairVectorVector___getitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
    "    VALUE __getitem__(std::vector< std::vector< std::pair< std::string,double > > >::difference_type i, std::vector< std::vector< std::pair< std::string,double > > >::difference_type length)\n"
    "    VALUE __getitem__(std::vector< std::vector< std::pair< std::string,double > > >::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.



12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
12620
12621
12622
12623
12624
12625
12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
12655
 
# File 'ext/mykytea_wrap.cxx', line 12595

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

#__delete2__(*args) ⇒ Object 



12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
 
# File 'ext/mykytea_wrap.cxx', line 12140

SWIGINTERN VALUE
_wrap_PairVectorVector___delete2__(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  std::vector< std::vector< std::pair< std::string,double > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > *","__delete2__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  {
    std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *ptr = (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *)0;
    res2 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > >::value_type const &","__delete2__", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< std::pair< std::string,double > > >::value_type const &","__delete2__", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (VALUE)std_vector_Sl_std_vector_Sl_std_pair_Sl_std_string_Sc_double_Sg__Sg__Sg____delete2__(arg1,(std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > const &)*arg2);
  vresult = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}

#assign(*args) ⇒ Object

call-seq:

assign(n, x)

Assign a new PairVectorVector or portion of it.



13649
13650
13651
13652
13653
13654
13655
13656
13657
13658
13659
13660
13661
13662
13663
13664
13665
13666
13667
13668
13669
13670
13671
13672
13673
13674
13675
13676
13677
13678
13679
13680
13681
13682
13683
13684
13685
13686
13687
13688
13689
13690
 
# File 'ext/mykytea_wrap.cxx', line 13649

SWIGINTERN VALUE
_wrap_PairVectorVector_assign(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  std::vector< std::vector< std::pair< std::string,double > > >::size_type arg2 ;
  std::vector< std::vector< std::pair< std::string,double > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > >::size_type","assign", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::vector< std::pair< std::string,double > > >::size_type >(val2);
  {
    std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *ptr = (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *)0;
    res3 = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > >::value_type const &","assign", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< std::pair< std::string,double > > >::value_type const &","assign", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::vector< std::pair< std::string,double > > >::value_type const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}

#at(*args) ⇒ Object

call-seq:

at(i) -> VALUE

Return element at a certain index.



12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
 
# File 'ext/mykytea_wrap.cxx', line 12259

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

#back(*args) ⇒ Object

call-seq:

back -> PairVector

Return the last element in PairVectorVector.



13617
13618
13619
13620
13621
13622
13623
13624
13625
13626
13627
13628
13629
13630
13631
13632
13633
13634
13635
13636
13637
13638
 
# File 'ext/mykytea_wrap.cxx', line 13617

SWIGINTERN VALUE
_wrap_PairVectorVector_back(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< std::pair< std::string,double > > >::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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > const *","back", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  result = (std::vector< std::vector< std::pair< std::string,double > > >::value_type *) &((std::vector< std::vector< std::pair< std::string,double > > > const *)arg1)->back();
  vresult = swig::from(static_cast< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > >(*result));
  return vresult;
fail:
  return Qnil;
}

#begin(*args) ⇒ Object

call-seq:

begin -> std::vector< std::vector< std::pair< std::string,double > > >::iterator

Return an iterator to the beginning of the PairVectorVector.



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

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

#capacity(*args) ⇒ Object

call-seq:

capacity -> std::vector< std::vector< std::pair< std::string,double > > >::size_type

Reserved capacity of the PairVectorVector.



14052
14053
14054
14055
14056
14057
14058
14059
14060
14061
14062
14063
14064
14065
14066
14067
14068
14069
14070
14071
14072
14073
 
# File 'ext/mykytea_wrap.cxx', line 14052

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



13206
13207
13208
13209
13210
13211
13212
13213
13214
13215
13216
13217
13218
13219
13220
13221
13222
13223
13224
 
# File 'ext/mykytea_wrap.cxx', line 13206

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



12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
 
# File 'ext/mykytea_wrap.cxx', line 12219

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

#dup(*args) ⇒ Object

call-seq:

dup -> PairVectorVector

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



11936
11937
11938
11939
11940
11941
11942
11943
11944
11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
 
# File 'ext/mykytea_wrap.cxx', line 11936

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

#each(*args) ⇒ Object

call-seq:

each -> PairVectorVector

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



12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
12136
12137
 
# File 'ext/mykytea_wrap.cxx', line 12116

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

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the PairVectorVector is empty or not.

Returns:

  • (Boolean) 


12974
12975
12976
12977
12978
12979
12980
12981
12982
12983
12984
12985
12986
12987
12988
12989
12990
12991
12992
12993
12994
12995
 
# File 'ext/mykytea_wrap.cxx', line 12974

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

#end(*args) ⇒ Object

call-seq:

end -> std::vector< std::vector< std::pair< std::string,double > > >::iterator

Return an iterator to past the end of the PairVectorVector.



13104
13105
13106
13107
13108
13109
13110
13111
13112
13113
13114
13115
13116
13117
13118
13119
13120
13121
13122
13123
13124
13125
13126
13127
 
# File 'ext/mykytea_wrap.cxx', line 13104

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

#erase(*args, self) ⇒ Object

call-seq:

erase(pos) -> std::vector< std::vector< std::pair< std::string,double > > >::iterator
erase(first, last) -> std::vector< std::vector< std::pair< std::string,double > > >::iterator

Delete a portion of the PairVectorVector.



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

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

#front(*args) ⇒ Object

call-seq:

front -> PairVector

Return the first element in PairVectorVector.



13585
13586
13587
13588
13589
13590
13591
13592
13593
13594
13595
13596
13597
13598
13599
13600
13601
13602
13603
13604
13605
13606
 
# File 'ext/mykytea_wrap.cxx', line 13585

SWIGINTERN VALUE
_wrap_PairVectorVector_front(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< std::pair< std::string,double > > >::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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > const *","front", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  result = (std::vector< std::vector< std::pair< std::string,double > > >::value_type *) &((std::vector< std::vector< std::pair< std::string,double > > > const *)arg1)->front();
  vresult = swig::from(static_cast< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > >(*result));
  return vresult;
fail:
  return Qnil;
}

#get_allocator(*args) ⇒ Object 



13227
13228
13229
13230
13231
13232
13233
13234
13235
13236
13237
13238
13239
13240
13241
13242
13243
13244
13245
13246
13247
13248
 
# File 'ext/mykytea_wrap.cxx', line 13227

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

#insert(*args, self) ⇒ Object

call-seq:

insert(pos, argc) -> PairVectorVector
insert(pos, x) -> std::vector< std::vector< std::pair< std::string,double > > >::iterator
insert(pos, n, x)

Insert one or more new elements in the PairVectorVector.



13922
13923
13924
13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935
13936
13937
13938
13939
13940
13941
13942
13943
13944
13945
13946
13947
13948
13949
13950
13951
13952
13953
13954
13955
13956
13957
13958
13959
13960
13961
13962
13963
13964
13965
13966
13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997
13998
13999
14000
14001
14002
14003
14004
 
# File 'ext/mykytea_wrap.cxx', line 13922

SWIGINTERN VALUE _wrap_PairVectorVector_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< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(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< std::vector< std::pair< std::string,double > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PairVectorVector_insert__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(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_PairVectorVector_insert__SWIG_0(nargs, args, self);
          }
          return _wrap_PairVectorVector_insert__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(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< std::vector< std::pair< std::string,double > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PairVectorVector_insert__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "insert", 
    "    std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > > insert(std::vector< std::vector< std::pair< std::string,double > > >::difference_type pos, int argc, VALUE *argv, ...)\n"
    "    std::vector< std::vector< std::pair< std::string,double > > >::iterator insert(std::vector< std::vector< std::pair< std::string,double > > >::iterator pos, std::vector< std::vector< std::pair< std::string,double > > >::value_type const &x)\n"
    "    void insert(std::vector< std::vector< std::pair< std::string,double > > >::iterator pos, std::vector< std::vector< std::pair< std::string,double > > >::size_type n, std::vector< std::vector< std::pair< std::string,double > > >::value_type const &x)\n");
  
  return Qnil;
}

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
 
# File 'ext/mykytea_wrap.cxx', line 11968

SWIGINTERN VALUE
_wrap_PairVectorVector_inspect(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  result = (VALUE)std_vector_Sl_std_vector_Sl_std_pair_Sl_std_string_Sc_double_Sg__Sg__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 PairVectorVector.



12698
12699
12700
12701
12702
12703
12704
12705
12706
12707
12708
12709
12710
12711
12712
12713
12714
12715
12716
12717
12718
12719
 
# File 'ext/mykytea_wrap.cxx', line 12698

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

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

call-seq:

push(e) -> PairVector

Add an element at the end of the PairVectorVector.



12730
12731
12732
12733
12734
12735
12736
12737
12738
12739
12740
12741
12742
12743
12744
12745
12746
12747
12748
12749
12750
12751
12752
12753
12754
12755
12756
12757
12758
12759
12760
12761
12762
12763
12764
12765
12766
 
# File 'ext/mykytea_wrap.cxx', line 12730

SWIGINTERN VALUE
_wrap_PairVectorVector_push(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  std::vector< std::vector< std::pair< std::string,double > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< std::pair< std::string,double > > >::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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > *","push", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  {
    std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *ptr = (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > *)0;
    res2 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > >::value_type const &","push", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< std::pair< std::string,double > > >::value_type const &","push", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = std_vector_Sl_std_vector_Sl_std_pair_Sl_std_string_Sc_double_Sg__Sg__Sg__push(arg1,(std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > const &)*arg2);
  vresult = swig::from(static_cast< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}

#rbegin(*args) ⇒ Object

call-seq:

rbegin -> std::vector< std::vector< std::pair< std::string,double > > >::reverse_iterator

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



13138
13139
13140
13141
13142
13143
13144
13145
13146
13147
13148
13149
13150
13151
13152
13153
13154
13155
13156
13157
13158
13159
13160
13161
 
# File 'ext/mykytea_wrap.cxx', line 13138

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

#reject(*args) ⇒ Object

call-seq:

reject -> PairVectorVector

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



12777
12778
12779
12780
12781
12782
12783
12784
12785
12786
12787
12788
12789
12790
12791
12792
12793
12794
12795
12796
12797
12798
 
# File 'ext/mykytea_wrap.cxx', line 12777

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

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

call-seq:

reject! -> PairVectorVector

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



12666
12667
12668
12669
12670
12671
12672
12673
12674
12675
12676
12677
12678
12679
12680
12681
12682
12683
12684
12685
12686
12687
 
# File 'ext/mykytea_wrap.cxx', line 12666

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

#rend(*args) ⇒ Object

call-seq:

rend -> std::vector< std::vector< std::pair< std::string,double > > >::reverse_iterator

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



13172
13173
13174
13175
13176
13177
13178
13179
13180
13181
13182
13183
13184
13185
13186
13187
13188
13189
13190
13191
13192
13193
13194
13195
 
# File 'ext/mykytea_wrap.cxx', line 13172

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



14015
14016
14017
14018
14019
14020
14021
14022
14023
14024
14025
14026
14027
14028
14029
14030
14031
14032
14033
14034
14035
14036
14037
14038
14039
14040
14041
 
# File 'ext/mykytea_wrap.cxx', line 14015

SWIGINTERN VALUE
_wrap_PairVectorVector_reserve(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  std::vector< std::vector< std::pair< std::string,double > > >::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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > *","reserve", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > >::size_type","reserve", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::vector< std::pair< std::string,double > > >::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 PairVectorVector.



13746
13747
13748
13749
13750
13751
13752
13753
13754
13755
13756
13757
13758
13759
13760
13761
13762
13763
13764
13765
13766
13767
13768
13769
13770
13771
13772
13773
13774
13775
13776
13777
13778
13779
13780
13781
13782
13783
13784
13785
13786
13787
13788
13789
13790
13791
13792
13793
13794
13795
13796
 
# File 'ext/mykytea_wrap.cxx', line 13746

SWIGINTERN VALUE _wrap_PairVectorVector_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< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PairVectorVector_resize__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PairVectorVector_resize__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PairVectorVector.resize", 
    "    void PairVectorVector.resize(std::vector< std::vector< std::pair< std::string,double > > >::size_type new_size)\n"
    "    void PairVectorVector.resize(std::vector< std::vector< std::pair< std::string,double > > >::size_type new_size, std::vector< std::vector< std::pair< std::string,double > > >::value_type const &x)\n");
  
  return Qnil;
}

#select(*args) ⇒ Object

call-seq:

select -> PairVectorVector

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



12187
12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
 
# File 'ext/mykytea_wrap.cxx', line 12187

SWIGINTERN VALUE
_wrap_PairVectorVector_select(int argc, VALUE *argv, VALUE self) {
  std::vector< std::vector< std::pair< std::string,double > > > *arg1 = (std::vector< std::vector< std::pair< std::string,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > > *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_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< std::pair< std::string,double > > > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::pair< std::string,double > > > * >(argp1);
  result = (std::vector< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > >,std::allocator< std::vector< std::pair< std::string,double >,std::allocator< std::pair< std::string,double > > > > > *)std_vector_Sl_std_vector_Sl_std_pair_Sl_std_string_Sc_double_Sg__Sg__Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_std__string_double_t_std__allocatorT_std__pairT_std__string_double_t_t_t_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 PairVectorVector.



12809
12810
12811
12812
12813
12814
12815
12816
12817
12818
12819
12820
12821
12822
12823
12824
12825
12826
12827
12828
12829
12830
 
# File 'ext/mykytea_wrap.cxx', line 12809

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

#size(*args) ⇒ Object

call-seq:

size -> std::vector< std::vector< std::pair< std::string,double > > >::size_type

Size or Length of the PairVectorVector.



13006
13007
13008
13009
13010
13011
13012
13013
13014
13015
13016
13017
13018
13019
13020
13021
13022
13023
13024
13025
13026
13027
 
# File 'ext/mykytea_wrap.cxx', line 13006

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



12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105
 
# File 'ext/mykytea_wrap.cxx', line 12064

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



13030
13031
13032
13033
13034
13035
13036
13037
13038
13039
13040
13041
13042
13043
13044
13045
13046
13047
13048
13049
13050
13051
13052
13053
13054
13055
13056
13057
13058
13059
 
# File 'ext/mykytea_wrap.cxx', line 13030

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

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert PairVectorVector to an Array.



12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
 
# File 'ext/mykytea_wrap.cxx', line 12000

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



12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
 
# File 'ext/mykytea_wrap.cxx', line 12032

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

#unshift(*args) ⇒ Object

call-seq:

unshift(argc) -> PairVectorVector

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



12890
12891
12892
12893
12894
12895
12896
12897
12898
12899
12900
12901
12902
12903
12904
12905
12906
12907
12908
12909
12910
12911
12912
12913
12914
12915
12916
12917
12918
 
# File 'ext/mykytea_wrap.cxx', line 12890

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