Class: CNTK::MinibatchTable

Inherits:
Object
  • Object
show all
Defined in:
lib/cntk/io.rb,
ext/cntk/cntk_wrap.cxx

Overview

std::unordered_map<StreamInfo, MinibatchData>

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



17012
17013
17014
17015
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027
17028
17029
17030
17031
17032
17033
17034
17035
17036
17037
17038
17039
17040
 
# File 'ext/cntk/cntk_wrap.cxx', line 17012

SWIGINTERN VALUE _wrap_new_MinibatchTable(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MinibatchTable__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinibatchTable__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MinibatchTable.new", 
    "    MinibatchTable.new()\n"
    "    MinibatchTable.new(std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const &)\n");
  
  return Qnil;
}

Instance Method Details

#[](*args) ⇒ Object

call-seq:

[](key) -> VALUE

Element accessor/slicing.



16760
16761
16762
16763
16764
16765
16766
16767
16768
16769
16770
16771
 
# File 'ext/cntk/cntk_wrap.cxx', line 16760

def [](key)
  if key.respond_to?(:to_str)
    key = key.to_str
    a = self.keys.find_all{|k| k.name == key }
    if a.size > 1
      raise "The number of input data having the name is not 1."
    end
    __get__(a[0])
  else
    __get__(key)
  end
end

#[]=(*args) ⇒ Object

call-seq:

[]=(key, x)

Element setter/slicing.



16804
16805
16806
16807
16808
16809
16810
16811
16812
16813
16814
16815
16816
16817
16818
16819
16820
16821
16822
16823
16824
16825
16826
16827
16828
16829
16830
16831
16832
16833
16834
16835
16836
16837
16838
16839
16840
16841
16842
16843
16844
16845
16846
16847
16848
16849
16850
 
# File 'ext/cntk/cntk_wrap.cxx', line 16804

SWIGINTERN VALUE
_wrap_MinibatchTable___setitem__(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type *arg2 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","__setitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_CNTK__StreamInformation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","__setitem__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","__setitem__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_CNTK__MinibatchData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::mapped_type const &","__setitem__", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::mapped_type const &","__setitem__", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::mapped_type * >(argp3);
  try {
    std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg____setitem__(arg1,(CNTK::StreamInformation const &)*arg2,(CNTK::MinibatchData const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  return Qnil;
fail:
  return Qnil;
}

#__get__ ⇒ Object 



35
 
# File 'lib/cntk/io.rb', line 35

alias __get__ :[]

#begin(*args) ⇒ Object

call-seq:

begin -> std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator

Return an iterator to the beginning of the MinibatchTable.



17150
17151
17152
17153
17154
17155
17156
17157
17158
17159
17160
17161
17162
17163
17164
17165
17166
17167
17168
17169
17170
17171
 
# File 'ext/cntk/cntk_wrap.cxx', line 17150

SWIGINTERN VALUE
_wrap_MinibatchTable_begin(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (arg1)->begin();
  vresult = SWIG_NewPointerObj((new std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator(static_cast< const std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator& >(result))), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#clear(*args) ⇒ Object

call-seq:

clear

Clear MinibatchTable contents.



17216
17217
17218
17219
17220
17221
17222
17223
17224
17225
17226
17227
17228
17229
17230
17231
17232
17233
17234
 
# File 'ext/cntk/cntk_wrap.cxx', line 17216

SWIGINTERN VALUE
_wrap_MinibatchTable_clear(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}

#count(*args) ⇒ Object 



17307
17308
17309
17310
17311
17312
17313
17314
17315
17316
17317
17318
17319
17320
17321
17322
17323
17324
17325
17326
17327
17328
17329
17330
17331
17332
17333
17334
17335
17336
17337
17338
17339
 
# File 'ext/cntk/cntk_wrap.cxx', line 17307

SWIGINTERN VALUE
_wrap_MinibatchTable_count(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::size_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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const *","count", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_CNTK__StreamInformation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","count", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","count", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type * >(argp2);
  result = ((std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const *)arg1)->count((std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#delete(*args) ⇒ Object

call-seq:

delete(key) -> VALUE

Delete a matching element.



16332
16333
16334
16335
16336
16337
16338
16339
16340
16341
16342
16343
16344
16345
16346
16347
16348
16349
16350
16351
16352
16353
16354
16355
16356
16357
16358
16359
16360
16361
16362
16363
16364
 
# File 'ext/cntk/cntk_wrap.cxx', line 16332

SWIGINTERN VALUE
_wrap_MinibatchTable_delete(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","__delete__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_CNTK__StreamInformation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","__delete__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","__delete__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type * >(argp2);
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg____delete__(arg1,(CNTK::StreamInformation const &)*arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#dup(*args) ⇒ Object

call-seq:

dup -> MinibatchTable

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



16299
16300
16301
16302
16303
16304
16305
16306
16307
16308
16309
16310
16311
16312
16313
16314
16315
16316
16317
16318
16319
16320
 
# File 'ext/cntk/cntk_wrap.cxx', line 16299

SWIGINTERN VALUE
_wrap_MinibatchTable_dup(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","dup", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__dup(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#each(*args) ⇒ Object

call-seq:

each -> MinibatchTable

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



16444
16445
16446
16447
16448
16449
16450
16451
16452
16453
16454
16455
16456
16457
16458
16459
16460
16461
16462
16463
16464
16465
 
# File 'ext/cntk/cntk_wrap.cxx', line 16444

SWIGINTERN VALUE
_wrap_MinibatchTable_each(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","each", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__each(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#each_key(*args) ⇒ Object

call-seq:

each_key -> MinibatchTable

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



16550
16551
16552
16553
16554
16555
16556
16557
16558
16559
16560
16561
16562
16563
16564
16565
16566
16567
16568
16569
16570
16571
 
# File 'ext/cntk/cntk_wrap.cxx', line 16550

SWIGINTERN VALUE
_wrap_MinibatchTable_each_key(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","each_key", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__each_key(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#each_value(*args) ⇒ Object

call-seq:

each_value -> MinibatchTable

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



16616
16617
16618
16619
16620
16621
16622
16623
16624
16625
16626
16627
16628
16629
16630
16631
16632
16633
16634
16635
16636
16637
 
# File 'ext/cntk/cntk_wrap.cxx', line 16616

SWIGINTERN VALUE
_wrap_MinibatchTable_each_value(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","each_value", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__each_value(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the MinibatchTable is empty or not.

Returns:

  • (Boolean) 


17052
17053
17054
17055
17056
17057
17058
17059
17060
17061
17062
17063
17064
17065
17066
17067
17068
17069
17070
17071
17072
17073
 
# File 'ext/cntk/cntk_wrap.cxx', line 17052

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

#end(*args) ⇒ Object

call-seq:

end -> std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator

Return an iterator to past the end of the MinibatchTable.



17183
17184
17185
17186
17187
17188
17189
17190
17191
17192
17193
17194
17195
17196
17197
17198
17199
17200
17201
17202
17203
17204
 
# File 'ext/cntk/cntk_wrap.cxx', line 17183

SWIGINTERN VALUE
_wrap_MinibatchTable_end(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (arg1)->end();
  vresult = SWIG_NewPointerObj((new std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator(static_cast< const std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator& >(result))), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#entries(*args) ⇒ Object 



16640
16641
16642
16643
16644
16645
16646
16647
16648
16649
16650
16651
16652
16653
16654
16655
16656
16657
16658
16659
16660
16661
 
# File 'ext/cntk/cntk_wrap.cxx', line 16640

SWIGINTERN VALUE
_wrap_MinibatchTable_entries(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","entries", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__entries(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#erase(*args, self) ⇒ Object

call-seq:

erase(x) -> std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::size_type
erase(position)
erase(first, last)

Delete a portion of the MinibatchTable.



17426
17427
17428
17429
17430
17431
17432
17433
17434
17435
17436
17437
17438
17439
17440
17441
17442
17443
17444
17445
17446
17447
17448
17449
17450
17451
17452
17453
17454
17455
17456
17457
17458
17459
17460
17461
17462
17463
17464
17465
17466
17467
17468
17469
17470
17471
17472
17473
17474
17475
17476
17477
17478
17479
17480
17481
17482
17483
17484
17485
17486
17487
17488
17489
 
# File 'ext/cntk/cntk_wrap.cxx', line 17426

SWIGINTERN VALUE _wrap_MinibatchTable_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::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__StreamInformation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MinibatchTable_erase__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t__iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MinibatchTable_erase__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t__iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t__iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MinibatchTable_erase__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MinibatchTable.erase", 
    "    std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::size_type MinibatchTable.erase(std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &x)\n"
    "    void MinibatchTable.erase(std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator position)\n"
    "    void MinibatchTable.erase(std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator first, std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator last)\n");
  
  return Qnil;
}

#find(*args) ⇒ Object

call-seq:

find(x) -> std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator

Find an element in the class.



17501
17502
17503
17504
17505
17506
17507
17508
17509
17510
17511
17512
17513
17514
17515
17516
17517
17518
17519
17520
17521
17522
17523
17524
17525
17526
17527
17528
17529
17530
17531
17532
17533
 
# File 'ext/cntk/cntk_wrap.cxx', line 17501

SWIGINTERN VALUE
_wrap_MinibatchTable_find(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_CNTK__StreamInformation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","find", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","find", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type * >(argp2);
  result = (arg1)->find((std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator(static_cast< const std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::iterator& >(result))), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t__iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#get_allocator(*args) ⇒ Object 



17237
17238
17239
17240
17241
17242
17243
17244
17245
17246
17247
17248
17249
17250
17251
17252
17253
17254
17255
17256
17257
17258
 
# File 'ext/cntk/cntk_wrap.cxx', line 17237

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

#has_key?(*args) ⇒ Boolean

Returns:

  • (Boolean) 


16367
16368
16369
16370
16371
16372
16373
16374
16375
16376
16377
16378
16379
16380
16381
16382
16383
16384
16385
16386
16387
16388
16389
16390
16391
16392
16393
16394
16395
16396
16397
16398
16399
 
# File 'ext/cntk/cntk_wrap.cxx', line 16367

SWIGINTERN VALUE
_wrap_MinibatchTable_has_keyq___(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const *","has_key", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_CNTK__StreamInformation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","has_key", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","has_key", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type * >(argp2);
  result = (bool)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__has_key((std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const *)arg1,(CNTK::StreamInformation const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#include?(*args) ⇒ Boolean

Returns:

  • (Boolean) 


16664
16665
16666
16667
16668
16669
16670
16671
16672
16673
16674
16675
16676
16677
16678
16679
16680
16681
16682
16683
16684
16685
16686
16687
16688
16689
16690
16691
16692
16693
16694
16695
16696
 
# File 'ext/cntk/cntk_wrap.cxx', line 16664

SWIGINTERN VALUE
_wrap_MinibatchTable_includeq___(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","__contains__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_CNTK__StreamInformation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","__contains__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type const &","__contains__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::key_type * >(argp2);
  result = (bool)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg____contains__(arg1,(CNTK::StreamInformation const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



16862
16863
16864
16865
16866
16867
16868
16869
16870
16871
16872
16873
16874
16875
16876
16877
16878
16879
16880
16881
16882
16883
 
# File 'ext/cntk/cntk_wrap.cxx', line 16862

SWIGINTERN VALUE
_wrap_MinibatchTable_inspect(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__inspect(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#key_iterator(*args) ⇒ Object 



16699
16700
16701
16702
16703
16704
16705
16706
16707
16708
16709
16710
16711
16712
16713
16714
16715
16716
16717
16718
16719
16720
16721
16722
 
# File 'ext/cntk/cntk_wrap.cxx', line 16699

SWIGINTERN VALUE
_wrap_MinibatchTable_key_iterator(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  VALUE *arg2 = (VALUE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::ConstIterator *result = 0 ;
  VALUE vresult = Qnil;
  
  arg2 = &self;
  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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","key_iterator", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (swig::ConstIterator *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__key_iterator(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#keys(*args) ⇒ Object

call-seq:

keys -> VALUE

Return an Array of key elements.



16411
16412
16413
16414
16415
16416
16417
16418
16419
16420
16421
16422
16423
16424
16425
16426
16427
16428
16429
16430
16431
16432
 
# File 'ext/cntk/cntk_wrap.cxx', line 16411

SWIGINTERN VALUE
_wrap_MinibatchTable_keys(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","keys", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__keys(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#select(*args) ⇒ Object

call-seq:

select -> MinibatchTable

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



16477
16478
16479
16480
16481
16482
16483
16484
16485
16486
16487
16488
16489
16490
16491
16492
16493
16494
16495
16496
16497
16498
 
# File 'ext/cntk/cntk_wrap.cxx', line 16477

SWIGINTERN VALUE
_wrap_MinibatchTable_select(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,CNTK::MinibatchData > > > *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#size(*args) ⇒ Object

call-seq:

size -> std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::size_type

Size or Length of the MinibatchTable.



17085
17086
17087
17088
17089
17090
17091
17092
17093
17094
17095
17096
17097
17098
17099
17100
17101
17102
17103
17104
17105
17106
 
# File 'ext/cntk/cntk_wrap.cxx', line 17085

SWIGINTERN VALUE
_wrap_MinibatchTable_size(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData >::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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = ((std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > const *)arg1)->size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#swap(*args) ⇒ Object 



17109
17110
17111
17112
17113
17114
17115
17116
17117
17118
17119
17120
17121
17122
17123
17124
17125
17126
17127
17128
17129
17130
17131
17132
17133
17134
17135
17136
17137
17138
 
# File 'ext/cntk/cntk_wrap.cxx', line 17109

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

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert MinibatchTable to an Array.



16895
16896
16897
16898
16899
16900
16901
16902
16903
16904
16905
16906
16907
16908
16909
16910
16911
16912
16913
16914
16915
16916
 
# File 'ext/cntk/cntk_wrap.cxx', line 16895

SWIGINTERN VALUE
_wrap_MinibatchTable_to_a(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","to_a", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_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.



16928
16929
16930
16931
16932
16933
16934
16935
16936
16937
16938
16939
16940
16941
16942
16943
16944
16945
16946
16947
16948
16949
 
# File 'ext/cntk/cntk_wrap.cxx', line 16928

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

#value_iterator(*args) ⇒ Object 



16725
16726
16727
16728
16729
16730
16731
16732
16733
16734
16735
16736
16737
16738
16739
16740
16741
16742
16743
16744
16745
16746
16747
16748
 
# File 'ext/cntk/cntk_wrap.cxx', line 16725

SWIGINTERN VALUE
_wrap_MinibatchTable_value_iterator(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  VALUE *arg2 = (VALUE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::ConstIterator *result = 0 ;
  VALUE vresult = Qnil;
  
  arg2 = &self;
  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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","value_iterator", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (swig::ConstIterator *)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__value_iterator(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#values(*args) ⇒ Object

call-seq:

values -> VALUE

Return an Array of value elements.



16583
16584
16585
16586
16587
16588
16589
16590
16591
16592
16593
16594
16595
16596
16597
16598
16599
16600
16601
16602
16603
16604
 
# File 'ext/cntk/cntk_wrap.cxx', line 16583

SWIGINTERN VALUE
_wrap_MinibatchTable_values(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","values", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__values(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#values_at(*args) ⇒ Object

call-seq:

values_at(argc) -> VALUE

Return an Array of value elements matching the conditions.



16510
16511
16512
16513
16514
16515
16516
16517
16518
16519
16520
16521
16522
16523
16524
16525
16526
16527
16528
16529
16530
16531
16532
16533
16534
16535
16536
16537
16538
 
# File 'ext/cntk/cntk_wrap.cxx', line 16510

SWIGINTERN VALUE
_wrap_MinibatchTable_values_at(int argc, VALUE *argv, VALUE self) {
  std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *arg1 = (std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *) 0 ;
  int arg2 ;
  VALUE *arg3 = (VALUE *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  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__unordered_mapT_CNTK__StreamInformation_CNTK__MinibatchData_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_CNTK__MinibatchData_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > *","values_at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::unordered_map< CNTK::StreamInformation,CNTK::MinibatchData > * >(argp1);
  {
    arg2 = argc;
    arg3 = argv;
  }
  result = (VALUE)std_unordered_map_Sl_CNTK_StreamInformation_Sc_CNTK_MinibatchData_Sg__values_at(arg1,arg2,arg3,arg4);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}