Class: CNTK::StdVectorDictionaryValue

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

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



12099
12100
12101
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
 
# File 'ext/cntk/cntk_wrap.cxx', line 12099

SWIGINTERN VALUE _wrap_new_StdVectorDictionaryValue(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_StdVectorDictionaryValue__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_StdVectorDictionaryValue__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StdVectorDictionaryValue__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_CNTK__DictionaryValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StdVectorDictionaryValue__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StdVectorDictionaryValue.new", 
    "    StdVectorDictionaryValue.new()\n"
    "    StdVectorDictionaryValue.new(std::vector< CNTK::DictionaryValue > const &)\n"
    "    StdVectorDictionaryValue.new(std::vector< CNTK::DictionaryValue >::size_type size)\n"
    "    StdVectorDictionaryValue.new(std::vector< CNTK::DictionaryValue >::size_type size, std::vector< CNTK::DictionaryValue >::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.



10975
10976
10977
10978
10979
10980
10981
10982
10983
10984
10985
10986
10987
10988
10989
10990
10991
10992
10993
10994
10995
10996
10997
10998
10999
11000
11001
11002
11003
11004
11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
11029
11030
11031
11032
11033
11034
11035
11036
11037
11038
11039
 
# File 'ext/cntk/cntk_wrap.cxx', line 10975

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



11165
11166
11167
11168
11169
11170
11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
11181
11182
11183
11184
11185
11186
11187
11188
11189
11190
11191
11192
11193
11194
11195
11196
11197
11198
11199
11200
11201
11202
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11214
11215
11216
11217
11218
11219
11220
11221
11222
11223
11224
11225
11226
 
# File 'ext/cntk/cntk_wrap.cxx', line 11165

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

#__delete2__(*args) ⇒ Object 



10704
10705
10706
10707
10708
10709
10710
10711
10712
10713
10714
10715
10716
10717
10718
10719
10720
10721
10722
10723
10724
10725
10726
10727
10728
10729
10730
10731
10732
10733
10734
10735
10736
 
# File 'ext/cntk/cntk_wrap.cxx', line 10704

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

#assign(*args) ⇒ Object

call-seq:

assign(n, x)

Assign a new StdVectorDictionaryValue or portion of it.



12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
 
# File 'ext/cntk/cntk_wrap.cxx', line 12232

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

#at(*args) ⇒ Object

call-seq:

at(i) -> VALUE

Return element at a certain index.



10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
10843
10844
10845
10846
10847
10848
10849
10850
10851
 
# File 'ext/cntk/cntk_wrap.cxx', line 10822

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

#back(*args) ⇒ Object

call-seq:

back -> DictionaryValue

Return the last element in StdVectorDictionaryValue.



12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
12210
12211
12212
12213
12214
12215
12216
12217
12218
12219
12220
 
# File 'ext/cntk/cntk_wrap.cxx', line 12199

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

#begin(*args) ⇒ Object

call-seq:

begin -> std::vector< CNTK::DictionaryValue >::iterator

Return an iterator to the beginning of the StdVectorDictionaryValue.



11647
11648
11649
11650
11651
11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
11664
11665
11666
11667
11668
11669
11670
 
# File 'ext/cntk/cntk_wrap.cxx', line 11647

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

#capacity(*args) ⇒ Object

call-seq:

capacity -> std::vector< CNTK::DictionaryValue >::size_type

Reserved capacity of the StdVectorDictionaryValue.



12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
 
# File 'ext/cntk/cntk_wrap.cxx', line 12626

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



11787
11788
11789
11790
11791
11792
11793
11794
11795
11796
11797
11798
11799
11800
11801
11802
11803
11804
11805
 
# File 'ext/cntk/cntk_wrap.cxx', line 11787

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



10781
10782
10783
10784
10785
10786
10787
10788
10789
10790
10791
10792
10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
 
# File 'ext/cntk/cntk_wrap.cxx', line 10781

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

#dup(*args) ⇒ Object

call-seq:

dup -> StdVectorDictionaryValue

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



10493
10494
10495
10496
10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10507
10508
10509
10510
10511
10512
10513
10514
 
# File 'ext/cntk/cntk_wrap.cxx', line 10493

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

#each(*args) ⇒ Object

call-seq:

each -> StdVectorDictionaryValue

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



10680
10681
10682
10683
10684
10685
10686
10687
10688
10689
10690
10691
10692
10693
10694
10695
10696
10697
10698
10699
10700
10701
 
# File 'ext/cntk/cntk_wrap.cxx', line 10680

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

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the StdVectorDictionaryValue is empty or not.

Returns:

  • (Boolean) 


11549
11550
11551
11552
11553
11554
11555
11556
11557
11558
11559
11560
11561
11562
11563
11564
11565
11566
11567
11568
11569
11570
 
# File 'ext/cntk/cntk_wrap.cxx', line 11549

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

#end(*args) ⇒ Object

call-seq:

end -> std::vector< CNTK::DictionaryValue >::iterator

Return an iterator to past the end of the StdVectorDictionaryValue.



11682
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
 
# File 'ext/cntk/cntk_wrap.cxx', line 11682

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

#erase(*args, self) ⇒ Object

call-seq:

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

Delete a portion of the StdVectorDictionaryValue.



11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
12027
12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
 
# File 'ext/cntk/cntk_wrap.cxx', line 11998

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

#front(*args) ⇒ Object

call-seq:

front -> DictionaryValue

Return the first element in StdVectorDictionaryValue.



12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
 
# File 'ext/cntk/cntk_wrap.cxx', line 12166

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

#get_allocator(*args) ⇒ Object 



11808
11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
 
# File 'ext/cntk/cntk_wrap.cxx', line 11808

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

#insert(*args, self) ⇒ Object

call-seq:

insert(pos, argc) -> StdVectorDictionaryValue
insert(pos, x) -> std::vector< CNTK::DictionaryValue >::iterator
insert(pos, n, x)

Insert one or more new elements in the StdVectorDictionaryValue.



12492
12493
12494
12495
12496
12497
12498
12499
12500
12501
12502
12503
12504
12505
12506
12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
12535
12536
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
12556
12557
12558
12559
12560
12561
12562
12563
12564
12565
12566
12567
12568
12569
12570
12571
12572
12573
12574
12575
12576
 
# File 'ext/cntk/cntk_wrap.cxx', line 12492

SWIGINTERN VALUE _wrap_StdVectorDictionaryValue_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< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > >**)(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< CNTK::DictionaryValue >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__DictionaryValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StdVectorDictionaryValue_insert__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > >**)(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_StdVectorDictionaryValue_insert__SWIG_0(nargs, args, self);
          }
          return _wrap_StdVectorDictionaryValue_insert__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > >**)(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< CNTK::DictionaryValue >::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_CNTK__DictionaryValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StdVectorDictionaryValue_insert__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "insert", 
    "    std::vector< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > > insert(std::vector< CNTK::DictionaryValue >::difference_type pos, int argc, VALUE *argv, ...)\n"
    "    std::vector< CNTK::DictionaryValue >::iterator insert(std::vector< CNTK::DictionaryValue >::iterator pos, std::vector< CNTK::DictionaryValue >::value_type const &x)\n"
    "    void insert(std::vector< CNTK::DictionaryValue >::iterator pos, std::vector< CNTK::DictionaryValue >::size_type n, std::vector< CNTK::DictionaryValue >::value_type const &x)\n");
  
  return Qnil;
}

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



10526
10527
10528
10529
10530
10531
10532
10533
10534
10535
10536
10537
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
 
# File 'ext/cntk/cntk_wrap.cxx', line 10526

SWIGINTERN VALUE
_wrap_StdVectorDictionaryValue_inspect(int argc, VALUE *argv, VALUE self) {
  std::vector< CNTK::DictionaryValue > *arg1 = (std::vector< CNTK::DictionaryValue > *) 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_CNTK__DictionaryValue_std__allocatorT_CNTK__DictionaryValue_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< CNTK::DictionaryValue > *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< CNTK::DictionaryValue > * >(argp1);
  result = (VALUE)std_vector_Sl_CNTK_DictionaryValue_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 StdVectorDictionaryValue.



11271
11272
11273
11274
11275
11276
11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288
11289
11290
11291
11292
 
# File 'ext/cntk/cntk_wrap.cxx', line 11271

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

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

call-seq:

push(e) -> DictionaryValue

Add an element at the end of the StdVectorDictionaryValue.



11304
11305
11306
11307
11308
11309
11310
11311
11312
11313
11314
11315
11316
11317
11318
11319
11320
11321
11322
11323
11324
11325
11326
11327
11328
11329
11330
11331
11332
11333
11334
11335
11336
 
# File 'ext/cntk/cntk_wrap.cxx', line 11304

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

#rbegin(*args) ⇒ Object

call-seq:

rbegin -> std::vector< CNTK::DictionaryValue >::reverse_iterator

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



11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
 
# File 'ext/cntk/cntk_wrap.cxx', line 11717

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

#reject(*args) ⇒ Object

call-seq:

reject -> StdVectorDictionaryValue

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



11348
11349
11350
11351
11352
11353
11354
11355
11356
11357
11358
11359
11360
11361
11362
11363
11364
11365
11366
11367
11368
11369
 
# File 'ext/cntk/cntk_wrap.cxx', line 11348

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

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

call-seq:

reject! -> StdVectorDictionaryValue

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



11238
11239
11240
11241
11242
11243
11244
11245
11246
11247
11248
11249
11250
11251
11252
11253
11254
11255
11256
11257
11258
11259
 
# File 'ext/cntk/cntk_wrap.cxx', line 11238

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

#rend(*args) ⇒ Object

call-seq:

rend -> std::vector< CNTK::DictionaryValue >::reverse_iterator

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



11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
 
# File 'ext/cntk/cntk_wrap.cxx', line 11752

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



12588
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
 
# File 'ext/cntk/cntk_wrap.cxx', line 12588

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



12322
12323
12324
12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370
12371
12372
12373
 
# File 'ext/cntk/cntk_wrap.cxx', line 12322

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

#select(*args) ⇒ Object

call-seq:

select -> StdVectorDictionaryValue

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



10748
10749
10750
10751
10752
10753
10754
10755
10756
10757
10758
10759
10760
10761
10762
10763
10764
10765
10766
10767
10768
10769
 
# File 'ext/cntk/cntk_wrap.cxx', line 10748

SWIGINTERN VALUE
_wrap_StdVectorDictionaryValue_select(int argc, VALUE *argv, VALUE self) {
  std::vector< CNTK::DictionaryValue > *arg1 = (std::vector< CNTK::DictionaryValue > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > > *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_CNTK__DictionaryValue_std__allocatorT_CNTK__DictionaryValue_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< CNTK::DictionaryValue > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< CNTK::DictionaryValue > * >(argp1);
  result = (std::vector< CNTK::DictionaryValue,std::allocator< CNTK::DictionaryValue > > *)std_vector_Sl_CNTK_DictionaryValue_Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CNTK__DictionaryValue_std__allocatorT_CNTK__DictionaryValue_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 StdVectorDictionaryValue.



11381
11382
11383
11384
11385
11386
11387
11388
11389
11390
11391
11392
11393
11394
11395
11396
11397
11398
11399
11400
11401
11402
 
# File 'ext/cntk/cntk_wrap.cxx', line 11381

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

#size(*args) ⇒ Object

call-seq:

size -> std::vector< CNTK::DictionaryValue >::size_type

Size or Length of the StdVectorDictionaryValue.



11582
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
 
# File 'ext/cntk/cntk_wrap.cxx', line 11582

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



10625
10626
10627
10628
10629
10630
10631
10632
10633
10634
10635
10636
10637
10638
10639
10640
10641
10642
10643
10644
10645
10646
10647
10648
10649
10650
10651
10652
10653
10654
10655
10656
10657
10658
10659
10660
10661
10662
10663
10664
10665
10666
10667
10668
 
# File 'ext/cntk/cntk_wrap.cxx', line 10625

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



11606
11607
11608
11609
11610
11611
11612
11613
11614
11615
11616
11617
11618
11619
11620
11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
 
# File 'ext/cntk/cntk_wrap.cxx', line 11606

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

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert StdVectorDictionaryValue to an Array.



10559
10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
10576
10577
10578
10579
10580
 
# File 'ext/cntk/cntk_wrap.cxx', line 10559

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



10592
10593
10594
10595
10596
10597
10598
10599
10600
10601
10602
10603
10604
10605
10606
10607
10608
10609
10610
10611
10612
10613
 
# File 'ext/cntk/cntk_wrap.cxx', line 10592

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

#unshift(*args) ⇒ Object

call-seq:

unshift(argc) -> StdVectorDictionaryValue

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



11464
11465
11466
11467
11468
11469
11470
11471
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
11491
11492
 
# File 'ext/cntk/cntk_wrap.cxx', line 11464

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