Class: Mykytea::KyteaWord

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



16867
16868
16869
16870
16871
16872
16873
16874
16875
16876
16877
16878
16879
16880
16881
16882
16883
16884
16885
16886
16887
16888
16889
16890
16891
16892
16893
16894
16895
16896
16897
16898
16899
16900
16901
16902
16903
16904
16905
16906
16907
16908
16909
 
# File 'ext/mykytea_wrap.cxx', line 16867

SWIGINTERN VALUE
_wrap_new_KyteaWord(int argc, VALUE *argv, VALUE self) {
  KyteaString *arg1 = 0 ;
  KyteaString *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  kytea::KyteaWord *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_KyteaString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "KyteaString const &","KyteaWord", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "KyteaString const &","KyteaWord", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< KyteaString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_KyteaString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "KyteaString const &","KyteaWord", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "KyteaString const &","KyteaWord", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< KyteaString * >(argp2);
  {
    try{
      result = (kytea::KyteaWord *)new kytea::KyteaWord((KyteaString const &)*arg1,(KyteaString const &)*arg2);
      DATA_PTR(self) = result;
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return self;
fail:
  return Qnil;
}

Instance Method Details

#addTag(*args) ⇒ Object 



17556
17557
17558
17559
17560
17561
17562
17563
17564
17565
17566
17567
17568
17569
17570
17571
17572
17573
17574
17575
17576
17577
17578
17579
17580
17581
17582
17583
17584
17585
17586
17587
17588
17589
17590
17591
17592
17593
17594
17595
17596
17597
17598
17599
17600
17601
 
# File 'ext/mykytea_wrap.cxx', line 17556

SWIGINTERN VALUE
_wrap_KyteaWord_addTag(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  kytea::KyteaTag *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","addTag", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","addTag", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_std__pairT_KyteaString_double_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kytea::KyteaTag const &","addTag", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kytea::KyteaTag const &","addTag", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< kytea::KyteaTag * >(argp3);
  {
    try{
      (arg1)->addTag(arg2,(kytea::KyteaTag const &)*arg3);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#clearTags(*args) ⇒ Object 



17519
17520
17521
17522
17523
17524
17525
17526
17527
17528
17529
17530
17531
17532
17533
17534
17535
17536
17537
17538
17539
17540
17541
17542
17543
17544
17545
17546
17547
17548
17549
17550
17551
17552
17553
 
# File 'ext/mykytea_wrap.cxx', line 17519

SWIGINTERN VALUE
_wrap_KyteaWord_clearTags(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","clearTags", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","clearTags", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try{
      (arg1)->clearTags(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#getNumTags(*args) ⇒ Object 



17234
17235
17236
17237
17238
17239
17240
17241
17242
17243
17244
17245
17246
17247
17248
17249
17250
17251
17252
17253
17254
17255
17256
17257
17258
17259
17260
17261
17262
17263
 
# File 'ext/mykytea_wrap.cxx', line 17234

SWIGINTERN VALUE
_wrap_KyteaWord_getNumTags(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","getNumTags", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  {
    try{
      result = (int)((kytea::KyteaWord const *)arg1)->getNumTags();
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}

#getTag(*args) ⇒ Object 



17266
17267
17268
17269
17270
17271
17272
17273
17274
17275
17276
17277
17278
17279
17280
17281
17282
17283
17284
17285
17286
17287
17288
17289
17290
17291
17292
17293
17294
17295
17296
17297
17298
17299
17300
17301
17302
17303
 
# File 'ext/mykytea_wrap.cxx', line 17266

SWIGINTERN VALUE
_wrap_KyteaWord_getTag(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  kytea::KyteaTag *result = 0 ;
  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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","getTag", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getTag", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try{
      result = (kytea::KyteaTag *)((kytea::KyteaWord const *)arg1)->getTag(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_KyteaString_double_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#getTagConf(*args) ⇒ Object 



17386
17387
17388
17389
17390
17391
17392
17393
17394
17395
17396
17397
17398
17399
17400
17401
17402
17403
17404
17405
17406
17407
17408
17409
17410
17411
17412
17413
17414
17415
17416
17417
17418
17419
17420
17421
17422
17423
 
# File 'ext/mykytea_wrap.cxx', line 17386

SWIGINTERN VALUE
_wrap_KyteaWord_getTagConf(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","getTagConf", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getTagConf", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try{
      result = (double)((kytea::KyteaWord const *)arg1)->getTagConf(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

#getTags(*args) ⇒ Object 



17306
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
17340
17341
17342
17343
 
# File 'ext/mykytea_wrap.cxx', line 17306

SWIGINTERN VALUE
_wrap_KyteaWord_getTags(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > *result = 0 ;
  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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","getTags", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getTags", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try{
      result = (std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > *) &((kytea::KyteaWord const *)arg1)->getTags(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_KyteaString_double_t_std__allocatorT_std__pairT_KyteaString_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#getTagSurf(*args) ⇒ Object 



17346
17347
17348
17349
17350
17351
17352
17353
17354
17355
17356
17357
17358
17359
17360
17361
17362
17363
17364
17365
17366
17367
17368
17369
17370
17371
17372
17373
17374
17375
17376
17377
17378
17379
17380
17381
17382
17383
 
# File 'ext/mykytea_wrap.cxx', line 17346

SWIGINTERN VALUE
_wrap_KyteaWord_getTagSurf(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  KyteaString *result = 0 ;
  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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","getTagSurf", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getTagSurf", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try{
      result = (KyteaString *) &((kytea::KyteaWord const *)arg1)->getTagSurf(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_KyteaString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#getUnknown(*args) ⇒ Object 



17641
17642
17643
17644
17645
17646
17647
17648
17649
17650
17651
17652
17653
17654
17655
17656
17657
17658
17659
17660
17661
17662
17663
17664
17665
17666
17667
17668
17669
17670
 
# File 'ext/mykytea_wrap.cxx', line 17641

SWIGINTERN VALUE
_wrap_KyteaWord_getUnknown(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","getUnknown", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  {
    try{
      result = (bool)((kytea::KyteaWord const *)arg1)->getUnknown();
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#hasTag(*args) ⇒ Object 



17673
17674
17675
17676
17677
17678
17679
17680
17681
17682
17683
17684
17685
17686
17687
17688
17689
17690
17691
17692
17693
17694
17695
17696
17697
17698
17699
17700
17701
17702
17703
17704
17705
17706
17707
17708
17709
17710
 
# File 'ext/mykytea_wrap.cxx', line 17673

SWIGINTERN VALUE
_wrap_KyteaWord_hasTag(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord const *","hasTag", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","hasTag", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try{
      result = (bool)((kytea::KyteaWord const *)arg1)->hasTag(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#isCertain(*args) ⇒ Object 



17112
17113
17114
17115
17116
17117
17118
17119
17120
17121
17122
17123
17124
17125
17126
17127
17128
17129
17130
17131
17132
17133
 
# File 'ext/mykytea_wrap.cxx', line 17112

SWIGINTERN VALUE
_wrap_KyteaWord_isCertain_get(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","isCertain", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  result = (bool) ((arg1)->isCertain);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#isCertain=(*args) ⇒ Object 



17083
17084
17085
17086
17087
17088
17089
17090
17091
17092
17093
17094
17095
17096
17097
17098
17099
17100
17101
17102
17103
17104
17105
17106
17107
17108
17109
 
# File 'ext/mykytea_wrap.cxx', line 17083

SWIGINTERN VALUE
_wrap_KyteaWord_isCertain_set(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","isCertain", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isCertain", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isCertain = arg2;
  return Qnil;
fail:
  return Qnil;
}

#limitTags(*args) ⇒ Object 



17189
17190
17191
17192
17193
17194
17195
17196
17197
17198
17199
17200
17201
17202
17203
17204
17205
17206
17207
17208
17209
17210
17211
17212
17213
17214
17215
17216
17217
17218
17219
17220
17221
17222
17223
17224
17225
17226
17227
17228
17229
17230
17231
 
# File 'ext/mykytea_wrap.cxx', line 17189

SWIGINTERN VALUE
_wrap_KyteaWord_limitTags(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","limitTags", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","limitTags", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","limitTags", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try{
      (arg1)->limitTags(arg2,arg3);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#norm(*args) ⇒ Object 



17006
17007
17008
17009
17010
17011
17012
17013
17014
17015
17016
17017
17018
17019
17020
17021
17022
17023
17024
17025
17026
17027
 
# File 'ext/mykytea_wrap.cxx', line 17006

SWIGINTERN VALUE
_wrap_KyteaWord_norm_get(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  KyteaString 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","norm", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  result =  ((arg1)->norm);
  vresult = SWIG_NewPointerObj((new KyteaString(static_cast< const KyteaString& >(result))), SWIGTYPE_p_KyteaString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#norm=(*args) ⇒ Object 



16971
16972
16973
16974
16975
16976
16977
16978
16979
16980
16981
16982
16983
16984
16985
16986
16987
16988
16989
16990
16991
16992
16993
16994
16995
16996
16997
16998
16999
17000
17001
17002
17003
 
# File 'ext/mykytea_wrap.cxx', line 16971

SWIGINTERN VALUE
_wrap_KyteaWord_norm_set(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  KyteaString arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","norm", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_KyteaString,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "KyteaString","norm", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "KyteaString","norm", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< KyteaString * >(argp2));
    }
  }
  if (arg1) (arg1)->norm = arg2;
  return Qnil;
fail:
  return Qnil;
}

#setTag(*args) ⇒ Object 



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
 
# File 'ext/mykytea_wrap.cxx', line 17426

SWIGINTERN VALUE
_wrap_KyteaWord_setTag(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  kytea::KyteaTag *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","setTag", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setTag", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_std__pairT_KyteaString_double_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kytea::KyteaTag const &","setTag", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kytea::KyteaTag const &","setTag", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< kytea::KyteaTag * >(argp3);
  {
    try{
      (arg1)->setTag(arg2,(kytea::KyteaTag const &)*arg3);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#setTagConf(*args) ⇒ Object 



17474
17475
17476
17477
17478
17479
17480
17481
17482
17483
17484
17485
17486
17487
17488
17489
17490
17491
17492
17493
17494
17495
17496
17497
17498
17499
17500
17501
17502
17503
17504
17505
17506
17507
17508
17509
17510
17511
17512
17513
17514
17515
17516
 
# File 'ext/mykytea_wrap.cxx', line 17474

SWIGINTERN VALUE
_wrap_KyteaWord_setTagConf(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","setTagConf", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setTagConf", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","setTagConf", 3, argv[1] ));
  } 
  arg3 = static_cast< double >(val3);
  {
    try{
      (arg1)->setTagConf(arg2,arg3);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#setUnknown(*args) ⇒ Object 



17604
17605
17606
17607
17608
17609
17610
17611
17612
17613
17614
17615
17616
17617
17618
17619
17620
17621
17622
17623
17624
17625
17626
17627
17628
17629
17630
17631
17632
17633
17634
17635
17636
17637
17638
 
# File 'ext/mykytea_wrap.cxx', line 17604

SWIGINTERN VALUE
_wrap_KyteaWord_setUnknown(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","setUnknown", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUnknown", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try{
      (arg1)->setUnknown(arg2);
    } catch (const std::exception &e){
      SWIG_exception(SWIG_RuntimeError, e.what() );
    } catch (...) {
      SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#surface(*args) ⇒ Object 



16947
16948
16949
16950
16951
16952
16953
16954
16955
16956
16957
16958
16959
16960
16961
16962
16963
16964
16965
16966
16967
16968
 
# File 'ext/mykytea_wrap.cxx', line 16947

SWIGINTERN VALUE
_wrap_KyteaWord_surface_get(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  KyteaString 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","surface", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  result =  ((arg1)->surface);
  vresult = SWIG_NewPointerObj((new KyteaString(static_cast< const KyteaString& >(result))), SWIGTYPE_p_KyteaString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#surface=(*args) ⇒ Object 



16912
16913
16914
16915
16916
16917
16918
16919
16920
16921
16922
16923
16924
16925
16926
16927
16928
16929
16930
16931
16932
16933
16934
16935
16936
16937
16938
16939
16940
16941
16942
16943
16944
 
# File 'ext/mykytea_wrap.cxx', line 16912

SWIGINTERN VALUE
_wrap_KyteaWord_surface_set(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  KyteaString arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","surface", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_KyteaString,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "KyteaString","surface", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "KyteaString","surface", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< KyteaString * >(argp2));
    }
  }
  if (arg1) (arg1)->surface = arg2;
  return Qnil;
fail:
  return Qnil;
}

#tags(*args) ⇒ Object 



17059
17060
17061
17062
17063
17064
17065
17066
17067
17068
17069
17070
17071
17072
17073
17074
17075
17076
17077
17078
17079
17080
 
# File 'ext/mykytea_wrap.cxx', line 17059

SWIGINTERN VALUE
_wrap_KyteaWord_tags_get(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > >,std::allocator< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > > > *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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","tags", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  result = (std::vector< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > >,std::allocator< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > > > *)& ((arg1)->tags);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_KyteaString_double_t_std__allocatorT_std__pairT_KyteaString_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_KyteaString_double_t_std__allocatorT_std__pairT_KyteaString_double_t_t_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#tags=(*args) ⇒ Object 



17030
17031
17032
17033
17034
17035
17036
17037
17038
17039
17040
17041
17042
17043
17044
17045
17046
17047
17048
17049
17050
17051
17052
17053
17054
17055
17056
 
# File 'ext/mykytea_wrap.cxx', line 17030

SWIGINTERN VALUE
_wrap_KyteaWord_tags_set(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  std::vector< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > >,std::allocator< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > > > *arg2 = (std::vector< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > >,std::allocator< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > > > *) 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","tags", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_KyteaString_double_t_std__allocatorT_std__pairT_KyteaString_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_KyteaString_double_t_std__allocatorT_std__pairT_KyteaString_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > >,std::allocator< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > > > *","tags", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > >,std::allocator< std::vector< kytea::KyteaTag,std::allocator< kytea::KyteaTag > > > > * >(argp2);
  if (arg1) (arg1)->tags = *arg2;
  return Qnil;
fail:
  return Qnil;
}

#unknown(*args) ⇒ Object 



17165
17166
17167
17168
17169
17170
17171
17172
17173
17174
17175
17176
17177
17178
17179
17180
17181
17182
17183
17184
17185
17186
 
# File 'ext/mykytea_wrap.cxx', line 17165

SWIGINTERN VALUE
_wrap_KyteaWord_unknown_get(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","unknown", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  result = (bool) ((arg1)->unknown);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#unknown=(*args) ⇒ Object 



17136
17137
17138
17139
17140
17141
17142
17143
17144
17145
17146
17147
17148
17149
17150
17151
17152
17153
17154
17155
17156
17157
17158
17159
17160
17161
17162
 
# File 'ext/mykytea_wrap.cxx', line 17136

SWIGINTERN VALUE
_wrap_KyteaWord_unknown_set(int argc, VALUE *argv, VALUE self) {
  kytea::KyteaWord *arg1 = (kytea::KyteaWord *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_kytea__KyteaWord, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kytea::KyteaWord *","unknown", 1, self )); 
  }
  arg1 = reinterpret_cast< kytea::KyteaWord * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","unknown", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->unknown = arg2;
  return Qnil;
fail:
  return Qnil;
}