taglib-ruby 1.0.1 → 1.1.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: ecceaec5949a978d7197944553e81b279f29eac9b3cb896285d31feaf8eb62c1
4
- data.tar.gz: cd7c8acdfb435435b20af23c82490987b94f44ef45366902d0c2fd55f45c4f3d
3
+ metadata.gz: 5a05d3733b4a04a791f619b399e24070ddc184ee2282d61d5b7f377726e3f2cd
4
+ data.tar.gz: cc92fc66ba1a8643a8a5b4ea1ff6398ba1277b756697dfbd3450007954103b48
5
5
  SHA512:
6
- metadata.gz: 288cbdd0cba616f093e9a6332f85f61d6ae17b1026694d32813105a8c22c1b70c26fa224f669fb2bdab965212608e68e210474b2e8b9fab19aab82420f6e9a94
7
- data.tar.gz: 927524f682dcda566219cb60895043d2c07c308122f162fbb6d140549e179ebaed08a3aa011f606f0a17bfa62ba4b4dcb47491de0efe3d3a4ab6122982c9d413
6
+ metadata.gz: 6350877ea0c574bc92c4a09cd501f15648f13b464cbce35aab4b38722fe4357f224a2b802dc15efe6aa17f6ee3e7d78ae837e54b3fbf061f61bf9a355a12f1d4
7
+ data.tar.gz: 23c439bbc1aabf7d4bf1b2b434de929fac6c1738468028054ca83f1001ae36f0bbabedb22db2db2da66fd701b328db2f2aceb4962dd661ec1983140963d11bbc
data/.yardopts CHANGED
@@ -5,5 +5,5 @@
5
5
  docs/**/*.rb
6
6
  -
7
7
  README.md
8
- CHANGES.md
8
+ CHANGELOG.md
9
9
  LICENSE.txt
@@ -6,6 +6,10 @@ All notable changes to this project will be documented in this file.
6
6
  The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
7
7
  and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
8
8
 
9
+ ## 1.1.0 - 2021-01-20
10
+ ### Added
11
+ - Added support for CTOC and CHAP frames for ID3v2
12
+
9
13
  ## 1.0.1 - 2020-03-25
10
14
 
11
15
  ### Fixed
data/README.md CHANGED
@@ -19,7 +19,7 @@ taglib-ruby currently supports the following:
19
19
  Contributions for more coverage of the library are very welcome.
20
20
 
21
21
  [![Gem version][gem-img]][gem-link]
22
- [![Build status][travis-img]][travis-link]
22
+ [![ci](https://github.com/robinst/taglib-ruby/workflows/ci/badge.svg)](https://github.com/robinst/taglib-ruby/actions?query=workflow%3Aci)
23
23
 
24
24
  Installation
25
25
  ------------
@@ -114,7 +114,7 @@ To do everything in one command:
114
114
 
115
115
  ### Workflow
116
116
 
117
- * Check out the latest master to make sure the feature hasn't been
117
+ * Check out the latest main branch to make sure the feature hasn't been
118
118
  implemented or the bug hasn't been fixed yet
119
119
  * Check out the issue tracker to make sure someone already hasn't
120
120
  requested it and/or contributed it
@@ -143,5 +143,3 @@ version 2.1 (LGPL) and Mozilla Public License (MPL).
143
143
  [taglib]: http://taglib.github.io/
144
144
  [gem-img]: https://badge.fury.io/rb/taglib-ruby.svg
145
145
  [gem-link]: https://rubygems.org/gems/taglib-ruby
146
- [travis-img]: https://api.travis-ci.org/robinst/taglib-ruby.png
147
- [travis-link]: https://travis-ci.org/robinst/taglib-ruby
data/Rakefile CHANGED
@@ -33,6 +33,6 @@ import 'tasks/gemspec_check.rake'
33
33
  # by Swig. Since the ExtensionTasks depend on the *_wrap.cxx files,
34
34
  # compiling the extensions will trigger Swig, which is not desired as
35
35
  # those files have already been generated and there's no reason to make
36
- # Swig a variable of the CI. To prevent those dependencies, do not import
37
- # swig.rake when running in Travis.
38
- import 'tasks/swig.rake' unless ENV['TRAVIS'] == 'true'
36
+ # Swig a variable of the CI. The environment variable can be set to
37
+ # prevent running swig.
38
+ import 'tasks/swig.rake' unless ENV['SKIP_SWIG'] == 'true'
@@ -19,6 +19,8 @@
19
19
  %{
20
20
  #include <taglib/tstring.h>
21
21
  #include <taglib/tstringlist.h>
22
+ #include <taglib/tbytevector.h>
23
+ #include <taglib/tbytevectorlist.h>
22
24
  #include <taglib/tfile.h>
23
25
 
24
26
  #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
@@ -88,6 +90,28 @@ TagLib::StringList ruby_array_to_taglib_string_list(VALUE ary) {
88
90
  return result;
89
91
  }
90
92
 
93
+ VALUE taglib_bytevectorlist_to_ruby_array(const TagLib::ByteVectorList & list) {
94
+ VALUE ary = rb_ary_new2(list.size());
95
+ for (TagLib::ByteVectorList::ConstIterator it = list.begin(); it != list.end(); it++) {
96
+ VALUE s = taglib_bytevector_to_ruby_string(*it);
97
+ rb_ary_push(ary, s);
98
+ }
99
+ return ary;
100
+ }
101
+
102
+ TagLib::ByteVectorList ruby_array_to_taglib_bytevectorlist(VALUE ary) {
103
+ TagLib::ByteVectorList result = TagLib::ByteVectorList();
104
+ if (NIL_P(ary)) {
105
+ return result;
106
+ }
107
+ for (long i = 0; i < RARRAY_LEN(ary); i++) {
108
+ VALUE e = rb_ary_entry(ary, i);
109
+ TagLib::ByteVector s = ruby_string_to_taglib_bytevector(e);
110
+ result.append(s);
111
+ }
112
+ return result;
113
+ }
114
+
91
115
  VALUE taglib_filename_to_ruby_string(TagLib::FileName filename) {
92
116
  VALUE result;
93
117
  #ifdef _WIN32
@@ -2,6 +2,7 @@
2
2
  %{
3
3
  #include <taglib/taglib.h>
4
4
  #include <taglib/tbytevector.h>
5
+ #include <taglib/tbytevectorlist.h>
5
6
  #include <taglib/tlist.h>
6
7
  #include <taglib/fileref.h>
7
8
  #include <taglib/tag.h>
@@ -12,6 +13,7 @@
12
13
  namespace TagLib {
13
14
  class StringList;
14
15
  class ByteVector;
16
+ class ByteVectorList;
15
17
 
16
18
  class String {
17
19
  public:
@@ -57,6 +59,22 @@ namespace TagLib {
57
59
  }
58
60
  %typemap(typecheck) const TagLib::ByteVector & = char *;
59
61
 
62
+ // ByteVectorList
63
+ %typemap(out) TagLib::ByteVectorList {
64
+ $result = taglib_bytevectorlist_to_ruby_array($1);
65
+ }
66
+ %typemap(out) TagLib::ByteVectorList * {
67
+ $result = taglib_bytevectorlist_to_ruby_array(*($1));
68
+ }
69
+ %typemap(in) TagLib::ByteVectorList & (TagLib::ByteVectorList tmp) {
70
+ tmp = ruby_array_to_taglib_bytevectorlist($input);
71
+ $1 = &tmp;
72
+ }
73
+ %typemap(in) TagLib::ByteVectorList * (TagLib::ByteVectorList tmp) {
74
+ tmp = ruby_array_to_taglib_bytevectorlist($input);
75
+ $1 = &tmp;
76
+ }
77
+
60
78
  // String
61
79
  %typemap(out) TagLib::String {
62
80
  $result = taglib_string_to_ruby_string($1);
@@ -5,12 +5,16 @@
5
5
  #include <taglib/id3v2tag.h>
6
6
  #include <taglib/id3v2header.h>
7
7
 
8
+ #include <taglib/tbytevectorlist.h>
9
+
8
10
  #include <taglib/attachedpictureframe.h>
11
+ #include <taglib/chapterframe.h>
9
12
  #include <taglib/commentsframe.h>
10
13
  #include <taglib/generalencapsulatedobjectframe.h>
11
14
  #include <taglib/popularimeterframe.h>
12
15
  #include <taglib/privateframe.h>
13
16
  #include <taglib/relativevolumeframe.h>
17
+ #include <taglib/tableofcontentsframe.h>
14
18
  #include <taglib/textidentificationframe.h>
15
19
  #include <taglib/uniquefileidentifierframe.h>
16
20
  #include <taglib/unknownframe.h>
@@ -36,8 +40,12 @@ VALUE taglib_id3v2_frame_to_ruby_object(const TagLib::ID3v2::Frame *frame) {
36
40
  ti = SWIGTYPE_p_TagLib__ID3v2__UnknownFrame;
37
41
  else if (id == "APIC")
38
42
  ti = SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame;
43
+ else if (id == "CHAP")
44
+ ti = SWIGTYPE_p_TagLib__ID3v2__ChapterFrame;
39
45
  else if (id == "COMM")
40
46
  ti = SWIGTYPE_p_TagLib__ID3v2__CommentsFrame;
47
+ else if (id == "CTOC")
48
+ ti = SWIGTYPE_p_TagLib__ID3v2__TableOfContentsFrame;
41
49
  else if (id == "GEOB")
42
50
  ti = SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame;
43
51
  else if (id == "POPM")
@@ -126,12 +134,21 @@ VALUE taglib_id3v2_framelist_to_ruby_array(TagLib::ID3v2::FrameList *list) {
126
134
  %include <taglib/attachedpictureframe.h>
127
135
 
128
136
  // Ignore the unified property interface.
137
+ %ignore TagLib::ID3v2::ChapterFrame::asProperties;
129
138
  %ignore TagLib::ID3v2::CommentsFrame::asProperties;
139
+ %ignore TagLib::ID3v2::TableOfContentsFrame::asProperties;
140
+
141
+ %rename("element_id=") TagLib::ID3v2::ChapterFrame::setElementID(const ByteVector &eID);
142
+ %include <taglib/chapterframe.h>
130
143
 
131
144
  %include <taglib/commentsframe.h>
132
145
  %include <taglib/generalencapsulatedobjectframe.h>
133
146
  %include <taglib/popularimeterframe.h>
134
147
  %include <taglib/privateframe.h>
148
+
149
+ %rename("element_id=") TagLib::ID3v2::TableOfContentsFrame::setElementID(const ByteVector &eID);
150
+ %include <taglib/tableofcontentsframe.h>
151
+
135
152
  %include <taglib/textidentificationframe.h>
136
153
 
137
154
  // Ignore the unified property interface.
@@ -1829,38 +1829,41 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
1829
1829
 
1830
1830
  #define SWIGTYPE_p_MapT_TagLib__ByteVector_TagLib__ListT_TagLib__ID3v2__Frame_p_t_t swig_types[0]
1831
1831
  #define SWIGTYPE_p_TagLib__ByteVector swig_types[1]
1832
- #define SWIGTYPE_p_TagLib__File swig_types[2]
1833
- #define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame swig_types[3]
1834
- #define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrameV22 swig_types[4]
1835
- #define SWIGTYPE_p_TagLib__ID3v2__CommentsFrame swig_types[5]
1836
- #define SWIGTYPE_p_TagLib__ID3v2__ExtendedHeader swig_types[6]
1837
- #define SWIGTYPE_p_TagLib__ID3v2__Footer swig_types[7]
1838
- #define SWIGTYPE_p_TagLib__ID3v2__Frame swig_types[8]
1839
- #define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[9]
1840
- #define SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame swig_types[10]
1841
- #define SWIGTYPE_p_TagLib__ID3v2__Header swig_types[11]
1842
- #define SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame swig_types[12]
1843
- #define SWIGTYPE_p_TagLib__ID3v2__PrivateFrame swig_types[13]
1844
- #define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame swig_types[14]
1845
- #define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame__PeakVolume swig_types[15]
1846
- #define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[16]
1847
- #define SWIGTYPE_p_TagLib__ID3v2__TextIdentificationFrame swig_types[17]
1848
- #define SWIGTYPE_p_TagLib__ID3v2__UniqueFileIdentifierFrame swig_types[18]
1849
- #define SWIGTYPE_p_TagLib__ID3v2__UnknownFrame swig_types[19]
1850
- #define SWIGTYPE_p_TagLib__ID3v2__UnsynchronizedLyricsFrame swig_types[20]
1851
- #define SWIGTYPE_p_TagLib__ID3v2__UrlLinkFrame swig_types[21]
1852
- #define SWIGTYPE_p_TagLib__ID3v2__UserTextIdentificationFrame swig_types[22]
1853
- #define SWIGTYPE_p_TagLib__ID3v2__UserUrlLinkFrame swig_types[23]
1854
- #define SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t swig_types[24]
1855
- #define SWIGTYPE_p_TagLib__StringList swig_types[25]
1856
- #define SWIGTYPE_p_TagLib__Tag swig_types[26]
1857
- #define SWIGTYPE_p_char swig_types[27]
1858
- #define SWIGTYPE_p_unsigned_char swig_types[28]
1859
- #define SWIGTYPE_p_unsigned_int swig_types[29]
1860
- #define SWIGTYPE_p_unsigned_long swig_types[30]
1861
- #define SWIGTYPE_p_wchar_t swig_types[31]
1862
- static swig_type_info *swig_types[33];
1863
- static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0};
1832
+ #define SWIGTYPE_p_TagLib__ByteVectorList swig_types[2]
1833
+ #define SWIGTYPE_p_TagLib__File swig_types[3]
1834
+ #define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame swig_types[4]
1835
+ #define SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrameV22 swig_types[5]
1836
+ #define SWIGTYPE_p_TagLib__ID3v2__ChapterFrame swig_types[6]
1837
+ #define SWIGTYPE_p_TagLib__ID3v2__CommentsFrame swig_types[7]
1838
+ #define SWIGTYPE_p_TagLib__ID3v2__ExtendedHeader swig_types[8]
1839
+ #define SWIGTYPE_p_TagLib__ID3v2__Footer swig_types[9]
1840
+ #define SWIGTYPE_p_TagLib__ID3v2__Frame swig_types[10]
1841
+ #define SWIGTYPE_p_TagLib__ID3v2__FrameFactory swig_types[11]
1842
+ #define SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame swig_types[12]
1843
+ #define SWIGTYPE_p_TagLib__ID3v2__Header swig_types[13]
1844
+ #define SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame swig_types[14]
1845
+ #define SWIGTYPE_p_TagLib__ID3v2__PrivateFrame swig_types[15]
1846
+ #define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame swig_types[16]
1847
+ #define SWIGTYPE_p_TagLib__ID3v2__RelativeVolumeFrame__PeakVolume swig_types[17]
1848
+ #define SWIGTYPE_p_TagLib__ID3v2__TableOfContentsFrame swig_types[18]
1849
+ #define SWIGTYPE_p_TagLib__ID3v2__Tag swig_types[19]
1850
+ #define SWIGTYPE_p_TagLib__ID3v2__TextIdentificationFrame swig_types[20]
1851
+ #define SWIGTYPE_p_TagLib__ID3v2__UniqueFileIdentifierFrame swig_types[21]
1852
+ #define SWIGTYPE_p_TagLib__ID3v2__UnknownFrame swig_types[22]
1853
+ #define SWIGTYPE_p_TagLib__ID3v2__UnsynchronizedLyricsFrame swig_types[23]
1854
+ #define SWIGTYPE_p_TagLib__ID3v2__UrlLinkFrame swig_types[24]
1855
+ #define SWIGTYPE_p_TagLib__ID3v2__UserTextIdentificationFrame swig_types[25]
1856
+ #define SWIGTYPE_p_TagLib__ID3v2__UserUrlLinkFrame swig_types[26]
1857
+ #define SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t swig_types[27]
1858
+ #define SWIGTYPE_p_TagLib__StringList swig_types[28]
1859
+ #define SWIGTYPE_p_TagLib__Tag swig_types[29]
1860
+ #define SWIGTYPE_p_char swig_types[30]
1861
+ #define SWIGTYPE_p_unsigned_char swig_types[31]
1862
+ #define SWIGTYPE_p_unsigned_int swig_types[32]
1863
+ #define SWIGTYPE_p_unsigned_long swig_types[33]
1864
+ #define SWIGTYPE_p_wchar_t swig_types[34]
1865
+ static swig_type_info *swig_types[36];
1866
+ static swig_module_info swig_module = {swig_types, 35, 0, 0, 0, 0};
1864
1867
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1865
1868
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1866
1869
 
@@ -1891,12 +1894,16 @@ static VALUE mID3v2;
1891
1894
  #include <taglib/id3v2tag.h>
1892
1895
  #include <taglib/id3v2header.h>
1893
1896
 
1897
+ #include <taglib/tbytevectorlist.h>
1898
+
1894
1899
  #include <taglib/attachedpictureframe.h>
1900
+ #include <taglib/chapterframe.h>
1895
1901
  #include <taglib/commentsframe.h>
1896
1902
  #include <taglib/generalencapsulatedobjectframe.h>
1897
1903
  #include <taglib/popularimeterframe.h>
1898
1904
  #include <taglib/privateframe.h>
1899
1905
  #include <taglib/relativevolumeframe.h>
1906
+ #include <taglib/tableofcontentsframe.h>
1900
1907
  #include <taglib/textidentificationframe.h>
1901
1908
  #include <taglib/uniquefileidentifierframe.h>
1902
1909
  #include <taglib/unknownframe.h>
@@ -1906,6 +1913,8 @@ static VALUE mID3v2;
1906
1913
 
1907
1914
  #include <taglib/tstring.h>
1908
1915
  #include <taglib/tstringlist.h>
1916
+ #include <taglib/tbytevector.h>
1917
+ #include <taglib/tbytevectorlist.h>
1909
1918
  #include <taglib/tfile.h>
1910
1919
 
1911
1920
  #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
@@ -1975,6 +1984,28 @@ TagLib::StringList ruby_array_to_taglib_string_list(VALUE ary) {
1975
1984
  return result;
1976
1985
  }
1977
1986
 
1987
+ VALUE taglib_bytevectorlist_to_ruby_array(const TagLib::ByteVectorList & list) {
1988
+ VALUE ary = rb_ary_new2(list.size());
1989
+ for (TagLib::ByteVectorList::ConstIterator it = list.begin(); it != list.end(); it++) {
1990
+ VALUE s = taglib_bytevector_to_ruby_string(*it);
1991
+ rb_ary_push(ary, s);
1992
+ }
1993
+ return ary;
1994
+ }
1995
+
1996
+ TagLib::ByteVectorList ruby_array_to_taglib_bytevectorlist(VALUE ary) {
1997
+ TagLib::ByteVectorList result = TagLib::ByteVectorList();
1998
+ if (NIL_P(ary)) {
1999
+ return result;
2000
+ }
2001
+ for (long i = 0; i < RARRAY_LEN(ary); i++) {
2002
+ VALUE e = rb_ary_entry(ary, i);
2003
+ TagLib::ByteVector s = ruby_string_to_taglib_bytevector(e);
2004
+ result.append(s);
2005
+ }
2006
+ return result;
2007
+ }
2008
+
1978
2009
  VALUE taglib_filename_to_ruby_string(TagLib::FileName filename) {
1979
2010
  VALUE result;
1980
2011
  #ifdef _WIN32
@@ -2024,8 +2055,12 @@ VALUE taglib_id3v2_frame_to_ruby_object(const TagLib::ID3v2::Frame *frame) {
2024
2055
  ti = SWIGTYPE_p_TagLib__ID3v2__UnknownFrame;
2025
2056
  else if (id == "APIC")
2026
2057
  ti = SWIGTYPE_p_TagLib__ID3v2__AttachedPictureFrame;
2058
+ else if (id == "CHAP")
2059
+ ti = SWIGTYPE_p_TagLib__ID3v2__ChapterFrame;
2027
2060
  else if (id == "COMM")
2028
2061
  ti = SWIGTYPE_p_TagLib__ID3v2__CommentsFrame;
2062
+ else if (id == "CTOC")
2063
+ ti = SWIGTYPE_p_TagLib__ID3v2__TableOfContentsFrame;
2029
2064
  else if (id == "GEOB")
2030
2065
  ti = SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame;
2031
2066
  else if (id == "POPM")
@@ -5665,24 +5700,30 @@ free_TagLib_ID3v2_AttachedPictureFrameV22(TagLib::ID3v2::AttachedPictureFrameV22
5665
5700
  delete arg1;
5666
5701
  }
5667
5702
 
5668
- static swig_class SwigClassCommentsFrame;
5703
+ static swig_class SwigClassChapterFrame;
5669
5704
 
5670
5705
  SWIGINTERN VALUE
5671
- _wrap_new_CommentsFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
5672
- TagLib::String::Type arg1 ;
5673
- int val1 ;
5674
- int ecode1 = 0 ;
5675
- TagLib::ID3v2::CommentsFrame *result = 0 ;
5706
+ _wrap_new_ChapterFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
5707
+ TagLib::ID3v2::Header *arg1 = (TagLib::ID3v2::Header *) 0 ;
5708
+ TagLib::ByteVector *arg2 = 0 ;
5709
+ void *argp1 = 0 ;
5710
+ int res1 = 0 ;
5711
+ TagLib::ByteVector tmp2 ;
5712
+ TagLib::ID3v2::ChapterFrame *result = 0 ;
5676
5713
 
5677
- if ((argc < 1) || (argc > 1)) {
5678
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5714
+ if ((argc < 2) || (argc > 2)) {
5715
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
5679
5716
  }
5680
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
5681
- if (!SWIG_IsOK(ecode1)) {
5682
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::String::Type","CommentsFrame", 1, argv[0] ));
5683
- }
5684
- arg1 = static_cast< TagLib::String::Type >(val1);
5685
- result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame(arg1);
5717
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Header, 0 | 0 );
5718
+ if (!SWIG_IsOK(res1)) {
5719
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Header const *","ChapterFrame", 1, argv[0] ));
5720
+ }
5721
+ arg1 = reinterpret_cast< TagLib::ID3v2::Header * >(argp1);
5722
+ {
5723
+ tmp2 = ruby_string_to_taglib_bytevector(argv[1]);
5724
+ arg2 = &tmp2;
5725
+ }
5726
+ result = (TagLib::ID3v2::ChapterFrame *)new TagLib::ID3v2::ChapterFrame((TagLib::ID3v2::Header const *)arg1,(TagLib::ByteVector const &)*arg2);
5686
5727
  DATA_PTR(self) = result;
5687
5728
  SWIG_RubyAddTracking(result, self);
5688
5729
  return self;
@@ -5692,13 +5733,62 @@ fail:
5692
5733
 
5693
5734
 
5694
5735
  SWIGINTERN VALUE
5695
- _wrap_new_CommentsFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
5696
- TagLib::ID3v2::CommentsFrame *result = 0 ;
5736
+ _wrap_new_ChapterFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
5737
+ TagLib::ByteVector *arg1 = 0 ;
5738
+ unsigned int arg2 ;
5739
+ unsigned int arg3 ;
5740
+ unsigned int arg4 ;
5741
+ unsigned int arg5 ;
5742
+ TagLib::ID3v2::FrameList *arg6 = 0 ;
5743
+ TagLib::ByteVector tmp1 ;
5744
+ unsigned int val2 ;
5745
+ int ecode2 = 0 ;
5746
+ unsigned int val3 ;
5747
+ int ecode3 = 0 ;
5748
+ unsigned int val4 ;
5749
+ int ecode4 = 0 ;
5750
+ unsigned int val5 ;
5751
+ int ecode5 = 0 ;
5752
+ void *argp6 ;
5753
+ int res6 = 0 ;
5754
+ TagLib::ID3v2::ChapterFrame *result = 0 ;
5697
5755
 
5698
- if ((argc < 0) || (argc > 0)) {
5699
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5756
+ if ((argc < 6) || (argc > 6)) {
5757
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
5700
5758
  }
5701
- result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame();
5759
+ {
5760
+ tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
5761
+ arg1 = &tmp1;
5762
+ }
5763
+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
5764
+ if (!SWIG_IsOK(ecode2)) {
5765
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 2, argv[1] ));
5766
+ }
5767
+ arg2 = static_cast< unsigned int >(val2);
5768
+ ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
5769
+ if (!SWIG_IsOK(ecode3)) {
5770
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 3, argv[2] ));
5771
+ }
5772
+ arg3 = static_cast< unsigned int >(val3);
5773
+ ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
5774
+ if (!SWIG_IsOK(ecode4)) {
5775
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 4, argv[3] ));
5776
+ }
5777
+ arg4 = static_cast< unsigned int >(val4);
5778
+ ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
5779
+ if (!SWIG_IsOK(ecode5)) {
5780
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 5, argv[4] ));
5781
+ }
5782
+ arg5 = static_cast< unsigned int >(val5);
5783
+ res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t, 0 );
5784
+ if (!SWIG_IsOK(res6)) {
5785
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "TagLib::ID3v2::FrameList const &","ChapterFrame", 6, argv[5] ));
5786
+ }
5787
+ if (!argp6) {
5788
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "TagLib::ID3v2::FrameList const &","ChapterFrame", 6, argv[5]));
5789
+ }
5790
+ arg6 = reinterpret_cast< TagLib::ID3v2::FrameList * >(argp6);
5791
+ result = (TagLib::ID3v2::ChapterFrame *)new TagLib::ID3v2::ChapterFrame((TagLib::ByteVector const &)*arg1,arg2,arg3,arg4,arg5,(TagLib::ID3v2::FrameList const &)*arg6);
5702
5792
  DATA_PTR(self) = result;
5703
5793
  SWIG_RubyAddTracking(result, self);
5704
5794
  return self;
@@ -5709,14 +5799,14 @@ fail:
5709
5799
 
5710
5800
  #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
5711
5801
  SWIGINTERN VALUE
5712
- _wrap_CommentsFrame_allocate(VALUE self) {
5802
+ _wrap_ChapterFrame_allocate(VALUE self) {
5713
5803
  #else
5714
5804
  SWIGINTERN VALUE
5715
- _wrap_CommentsFrame_allocate(int argc, VALUE *argv, VALUE self) {
5805
+ _wrap_ChapterFrame_allocate(int argc, VALUE *argv, VALUE self) {
5716
5806
  #endif
5717
5807
 
5718
5808
 
5719
- VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__CommentsFrame);
5809
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame);
5720
5810
  #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
5721
5811
  rb_obj_call_init(vresult, argc, argv);
5722
5812
  #endif
@@ -5725,19 +5815,51 @@ _wrap_CommentsFrame_allocate(VALUE self) {
5725
5815
 
5726
5816
 
5727
5817
  SWIGINTERN VALUE
5728
- _wrap_new_CommentsFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
5818
+ _wrap_new_ChapterFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
5729
5819
  TagLib::ByteVector *arg1 = 0 ;
5820
+ unsigned int arg2 ;
5821
+ unsigned int arg3 ;
5822
+ unsigned int arg4 ;
5823
+ unsigned int arg5 ;
5730
5824
  TagLib::ByteVector tmp1 ;
5731
- TagLib::ID3v2::CommentsFrame *result = 0 ;
5825
+ unsigned int val2 ;
5826
+ int ecode2 = 0 ;
5827
+ unsigned int val3 ;
5828
+ int ecode3 = 0 ;
5829
+ unsigned int val4 ;
5830
+ int ecode4 = 0 ;
5831
+ unsigned int val5 ;
5832
+ int ecode5 = 0 ;
5833
+ TagLib::ID3v2::ChapterFrame *result = 0 ;
5732
5834
 
5733
- if ((argc < 1) || (argc > 1)) {
5734
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5835
+ if ((argc < 5) || (argc > 5)) {
5836
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
5735
5837
  }
5736
5838
  {
5737
5839
  tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
5738
5840
  arg1 = &tmp1;
5739
5841
  }
5740
- result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame((TagLib::ByteVector const &)*arg1);
5842
+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
5843
+ if (!SWIG_IsOK(ecode2)) {
5844
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 2, argv[1] ));
5845
+ }
5846
+ arg2 = static_cast< unsigned int >(val2);
5847
+ ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
5848
+ if (!SWIG_IsOK(ecode3)) {
5849
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 3, argv[2] ));
5850
+ }
5851
+ arg3 = static_cast< unsigned int >(val3);
5852
+ ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
5853
+ if (!SWIG_IsOK(ecode4)) {
5854
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 4, argv[3] ));
5855
+ }
5856
+ arg4 = static_cast< unsigned int >(val4);
5857
+ ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
5858
+ if (!SWIG_IsOK(ecode5)) {
5859
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","ChapterFrame", 5, argv[4] ));
5860
+ }
5861
+ arg5 = static_cast< unsigned int >(val5);
5862
+ result = (TagLib::ID3v2::ChapterFrame *)new TagLib::ID3v2::ChapterFrame((TagLib::ByteVector const &)*arg1,arg2,arg3,arg4,arg5);
5741
5863
  DATA_PTR(self) = result;
5742
5864
  SWIG_RubyAddTracking(result, self);
5743
5865
  return self;
@@ -5746,73 +5868,134 @@ fail:
5746
5868
  }
5747
5869
 
5748
5870
 
5749
- SWIGINTERN VALUE _wrap_new_CommentsFrame(int nargs, VALUE *args, VALUE self) {
5871
+ SWIGINTERN VALUE _wrap_new_ChapterFrame(int nargs, VALUE *args, VALUE self) {
5750
5872
  int argc;
5751
- VALUE argv[1];
5873
+ VALUE argv[6];
5752
5874
  int ii;
5753
5875
 
5754
5876
  argc = nargs;
5755
- if (argc > 1) SWIG_fail;
5877
+ if (argc > 6) SWIG_fail;
5756
5878
  for (ii = 0; (ii < argc); ++ii) {
5757
5879
  argv[ii] = args[ii];
5758
5880
  }
5759
- if (argc == 0) {
5760
- return _wrap_new_CommentsFrame__SWIG_1(nargs, args, self);
5761
- }
5762
- if (argc == 1) {
5881
+ if (argc == 2) {
5763
5882
  int _v;
5764
- {
5765
- int res = SWIG_AsVal_int(argv[0], NULL);
5883
+ void *vptr = 0;
5884
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__Header, 0);
5885
+ _v = SWIG_CheckState(res);
5886
+ if (_v) {
5887
+ int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5766
5888
  _v = SWIG_CheckState(res);
5889
+ if (_v) {
5890
+ return _wrap_new_ChapterFrame__SWIG_0(nargs, args, self);
5891
+ }
5767
5892
  }
5893
+ }
5894
+ if (argc == 5) {
5895
+ int _v;
5896
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
5897
+ _v = SWIG_CheckState(res);
5768
5898
  if (_v) {
5769
- return _wrap_new_CommentsFrame__SWIG_0(nargs, args, self);
5899
+ {
5900
+ int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
5901
+ _v = SWIG_CheckState(res);
5902
+ }
5903
+ if (_v) {
5904
+ {
5905
+ int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
5906
+ _v = SWIG_CheckState(res);
5907
+ }
5908
+ if (_v) {
5909
+ {
5910
+ int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
5911
+ _v = SWIG_CheckState(res);
5912
+ }
5913
+ if (_v) {
5914
+ {
5915
+ int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
5916
+ _v = SWIG_CheckState(res);
5917
+ }
5918
+ if (_v) {
5919
+ return _wrap_new_ChapterFrame__SWIG_2(nargs, args, self);
5920
+ }
5921
+ }
5922
+ }
5923
+ }
5770
5924
  }
5771
5925
  }
5772
- if (argc == 1) {
5926
+ if (argc == 6) {
5773
5927
  int _v;
5774
5928
  int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
5775
5929
  _v = SWIG_CheckState(res);
5776
5930
  if (_v) {
5777
- return _wrap_new_CommentsFrame__SWIG_2(nargs, args, self);
5931
+ {
5932
+ int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
5933
+ _v = SWIG_CheckState(res);
5934
+ }
5935
+ if (_v) {
5936
+ {
5937
+ int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
5938
+ _v = SWIG_CheckState(res);
5939
+ }
5940
+ if (_v) {
5941
+ {
5942
+ int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
5943
+ _v = SWIG_CheckState(res);
5944
+ }
5945
+ if (_v) {
5946
+ {
5947
+ int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
5948
+ _v = SWIG_CheckState(res);
5949
+ }
5950
+ if (_v) {
5951
+ void *vptr = 0;
5952
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_TagLib__ListT_TagLib__ID3v2__Frame_p_t, 0);
5953
+ _v = SWIG_CheckState(res);
5954
+ if (_v) {
5955
+ return _wrap_new_ChapterFrame__SWIG_1(nargs, args, self);
5956
+ }
5957
+ }
5958
+ }
5959
+ }
5960
+ }
5778
5961
  }
5779
5962
  }
5780
5963
 
5781
5964
  fail:
5782
- Ruby_Format_OverloadedError( argc, 1, "CommentsFrame.new",
5783
- " CommentsFrame.new(TagLib::String::Type encoding)\n"
5784
- " CommentsFrame.new()\n"
5785
- " CommentsFrame.new(TagLib::ByteVector const &data)\n");
5965
+ Ruby_Format_OverloadedError( argc, 6, "ChapterFrame.new",
5966
+ " ChapterFrame.new(TagLib::ID3v2::Header const *tagHeader, TagLib::ByteVector const &data)\n"
5967
+ " ChapterFrame.new(TagLib::ByteVector const &elementID, unsigned int startTime, unsigned int endTime, unsigned int startOffset, unsigned int endOffset, TagLib::ID3v2::FrameList const &embeddedFrames)\n"
5968
+ " ChapterFrame.new(TagLib::ByteVector const &elementID, unsigned int startTime, unsigned int endTime, unsigned int startOffset, unsigned int endOffset)\n");
5786
5969
 
5787
5970
  return Qnil;
5788
5971
  }
5789
5972
 
5790
5973
 
5791
5974
  SWIGINTERN void
5792
- free_TagLib_ID3v2_CommentsFrame(TagLib::ID3v2::CommentsFrame *arg1) {
5975
+ free_TagLib_ID3v2_ChapterFrame(TagLib::ID3v2::ChapterFrame *arg1) {
5793
5976
  SWIG_RubyRemoveTracking(arg1);
5794
5977
  delete arg1;
5795
5978
  }
5796
5979
 
5797
5980
  SWIGINTERN VALUE
5798
- _wrap_CommentsFrame_to_string(int argc, VALUE *argv, VALUE self) {
5799
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
5981
+ _wrap_ChapterFrame_element_id(int argc, VALUE *argv, VALUE self) {
5982
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
5800
5983
  void *argp1 = 0 ;
5801
5984
  int res1 = 0 ;
5802
- TagLib::String result;
5985
+ TagLib::ByteVector result;
5803
5986
  VALUE vresult = Qnil;
5804
5987
 
5805
5988
  if ((argc < 0) || (argc > 0)) {
5806
5989
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5807
5990
  }
5808
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
5991
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5809
5992
  if (!SWIG_IsOK(res1)) {
5810
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","toString", 1, self ));
5993
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","elementID", 1, self ));
5811
5994
  }
5812
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5813
- result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->toString();
5995
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
5996
+ result = ((TagLib::ID3v2::ChapterFrame const *)arg1)->elementID();
5814
5997
  {
5815
- vresult = taglib_string_to_ruby_string(result);
5998
+ vresult = taglib_bytevector_to_ruby_string(result);
5816
5999
  }
5817
6000
  return vresult;
5818
6001
  fail:
@@ -5821,25 +6004,23 @@ fail:
5821
6004
 
5822
6005
 
5823
6006
  SWIGINTERN VALUE
5824
- _wrap_CommentsFrame_language(int argc, VALUE *argv, VALUE self) {
5825
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6007
+ _wrap_ChapterFrame_start_time(int argc, VALUE *argv, VALUE self) {
6008
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
5826
6009
  void *argp1 = 0 ;
5827
6010
  int res1 = 0 ;
5828
- TagLib::ByteVector result;
6011
+ unsigned int result;
5829
6012
  VALUE vresult = Qnil;
5830
6013
 
5831
6014
  if ((argc < 0) || (argc > 0)) {
5832
6015
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5833
6016
  }
5834
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6017
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5835
6018
  if (!SWIG_IsOK(res1)) {
5836
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","language", 1, self ));
5837
- }
5838
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5839
- result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->language();
5840
- {
5841
- vresult = taglib_bytevector_to_ruby_string(result);
6019
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","startTime", 1, self ));
5842
6020
  }
6021
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6022
+ result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->startTime();
6023
+ vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5843
6024
  return vresult;
5844
6025
  fail:
5845
6026
  return Qnil;
@@ -5847,25 +6028,23 @@ fail:
5847
6028
 
5848
6029
 
5849
6030
  SWIGINTERN VALUE
5850
- _wrap_CommentsFrame_description(int argc, VALUE *argv, VALUE self) {
5851
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6031
+ _wrap_ChapterFrame_end_time(int argc, VALUE *argv, VALUE self) {
6032
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
5852
6033
  void *argp1 = 0 ;
5853
6034
  int res1 = 0 ;
5854
- TagLib::String result;
6035
+ unsigned int result;
5855
6036
  VALUE vresult = Qnil;
5856
6037
 
5857
6038
  if ((argc < 0) || (argc > 0)) {
5858
6039
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5859
6040
  }
5860
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6041
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5861
6042
  if (!SWIG_IsOK(res1)) {
5862
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","description", 1, self ));
5863
- }
5864
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5865
- result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->description();
5866
- {
5867
- vresult = taglib_string_to_ruby_string(result);
6043
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","endTime", 1, self ));
5868
6044
  }
6045
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6046
+ result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->endTime();
6047
+ vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5869
6048
  return vresult;
5870
6049
  fail:
5871
6050
  return Qnil;
@@ -5873,25 +6052,47 @@ fail:
5873
6052
 
5874
6053
 
5875
6054
  SWIGINTERN VALUE
5876
- _wrap_CommentsFrame_text(int argc, VALUE *argv, VALUE self) {
5877
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6055
+ _wrap_ChapterFrame_start_offset(int argc, VALUE *argv, VALUE self) {
6056
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
5878
6057
  void *argp1 = 0 ;
5879
6058
  int res1 = 0 ;
5880
- TagLib::String result;
6059
+ unsigned int result;
5881
6060
  VALUE vresult = Qnil;
5882
6061
 
5883
6062
  if ((argc < 0) || (argc > 0)) {
5884
6063
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5885
6064
  }
5886
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6065
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5887
6066
  if (!SWIG_IsOK(res1)) {
5888
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","text", 1, self ));
6067
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","startOffset", 1, self ));
5889
6068
  }
5890
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5891
- result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->text();
5892
- {
5893
- vresult = taglib_string_to_ruby_string(result);
6069
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6070
+ result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->startOffset();
6071
+ vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
6072
+ return vresult;
6073
+ fail:
6074
+ return Qnil;
6075
+ }
6076
+
6077
+
6078
+ SWIGINTERN VALUE
6079
+ _wrap_ChapterFrame_end_offset(int argc, VALUE *argv, VALUE self) {
6080
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6081
+ void *argp1 = 0 ;
6082
+ int res1 = 0 ;
6083
+ unsigned int result;
6084
+ VALUE vresult = Qnil;
6085
+
6086
+ if ((argc < 0) || (argc > 0)) {
6087
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6088
+ }
6089
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6090
+ if (!SWIG_IsOK(res1)) {
6091
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","endOffset", 1, self ));
5894
6092
  }
6093
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6094
+ result = (unsigned int)((TagLib::ID3v2::ChapterFrame const *)arg1)->endOffset();
6095
+ vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5895
6096
  return vresult;
5896
6097
  fail:
5897
6098
  return Qnil;
@@ -5899,8 +6100,8 @@ fail:
5899
6100
 
5900
6101
 
5901
6102
  SWIGINTERN VALUE
5902
- _wrap_CommentsFrame_languagee___(int argc, VALUE *argv, VALUE self) {
5903
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6103
+ _wrap_ChapterFrame_element_ide___(int argc, VALUE *argv, VALUE self) {
6104
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
5904
6105
  TagLib::ByteVector *arg2 = 0 ;
5905
6106
  void *argp1 = 0 ;
5906
6107
  int res1 = 0 ;
@@ -5909,16 +6110,16 @@ _wrap_CommentsFrame_languagee___(int argc, VALUE *argv, VALUE self) {
5909
6110
  if ((argc < 1) || (argc > 1)) {
5910
6111
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5911
6112
  }
5912
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6113
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5913
6114
  if (!SWIG_IsOK(res1)) {
5914
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setLanguage", 1, self ));
6115
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setElementID", 1, self ));
5915
6116
  }
5916
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6117
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
5917
6118
  {
5918
6119
  tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
5919
6120
  arg2 = &tmp2;
5920
6121
  }
5921
- (arg1)->setLanguage((TagLib::ByteVector const &)*arg2);
6122
+ (arg1)->setElementID((TagLib::ByteVector const &)*arg2);
5922
6123
  return Qnil;
5923
6124
  fail:
5924
6125
  return Qnil;
@@ -5926,26 +6127,30 @@ fail:
5926
6127
 
5927
6128
 
5928
6129
  SWIGINTERN VALUE
5929
- _wrap_CommentsFrame_descriptione___(int argc, VALUE *argv, VALUE self) {
5930
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
5931
- TagLib::String *arg2 = 0 ;
6130
+ _wrap_ChapterFrame_start_timee___(int argc, VALUE *argv, VALUE self) {
6131
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6132
+ unsigned int *arg2 = 0 ;
5932
6133
  void *argp1 = 0 ;
5933
6134
  int res1 = 0 ;
5934
- TagLib::String tmp2 ;
6135
+ unsigned int temp2 ;
6136
+ unsigned int val2 ;
6137
+ int ecode2 = 0 ;
5935
6138
 
5936
6139
  if ((argc < 1) || (argc > 1)) {
5937
6140
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5938
6141
  }
5939
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6142
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5940
6143
  if (!SWIG_IsOK(res1)) {
5941
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setDescription", 1, self ));
6144
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setStartTime", 1, self ));
5942
6145
  }
5943
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5944
- {
5945
- tmp2 = ruby_string_to_taglib_string(argv[0]);
5946
- arg2 = &tmp2;
5947
- }
5948
- (arg1)->setDescription((TagLib::String const &)*arg2);
6146
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6147
+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
6148
+ if (!SWIG_IsOK(ecode2)) {
6149
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setStartTime", 2, argv[0] ));
6150
+ }
6151
+ temp2 = static_cast< unsigned int >(val2);
6152
+ arg2 = &temp2;
6153
+ (arg1)->setStartTime((unsigned int const &)*arg2);
5949
6154
  return Qnil;
5950
6155
  fail:
5951
6156
  return Qnil;
@@ -5953,26 +6158,30 @@ fail:
5953
6158
 
5954
6159
 
5955
6160
  SWIGINTERN VALUE
5956
- _wrap_CommentsFrame_texte___(int argc, VALUE *argv, VALUE self) {
5957
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
5958
- TagLib::String *arg2 = 0 ;
6161
+ _wrap_ChapterFrame_end_timee___(int argc, VALUE *argv, VALUE self) {
6162
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6163
+ unsigned int *arg2 = 0 ;
5959
6164
  void *argp1 = 0 ;
5960
6165
  int res1 = 0 ;
5961
- TagLib::String tmp2 ;
6166
+ unsigned int temp2 ;
6167
+ unsigned int val2 ;
6168
+ int ecode2 = 0 ;
5962
6169
 
5963
6170
  if ((argc < 1) || (argc > 1)) {
5964
6171
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5965
6172
  }
5966
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6173
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5967
6174
  if (!SWIG_IsOK(res1)) {
5968
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setText", 1, self ));
5969
- }
5970
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5971
- {
5972
- tmp2 = ruby_string_to_taglib_string(argv[0]);
5973
- arg2 = &tmp2;
6175
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setEndTime", 1, self ));
5974
6176
  }
5975
- (arg1)->setText((TagLib::String const &)*arg2);
6177
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6178
+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
6179
+ if (!SWIG_IsOK(ecode2)) {
6180
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setEndTime", 2, argv[0] ));
6181
+ }
6182
+ temp2 = static_cast< unsigned int >(val2);
6183
+ arg2 = &temp2;
6184
+ (arg1)->setEndTime((unsigned int const &)*arg2);
5976
6185
  return Qnil;
5977
6186
  fail:
5978
6187
  return Qnil;
@@ -5980,52 +6189,61 @@ fail:
5980
6189
 
5981
6190
 
5982
6191
  SWIGINTERN VALUE
5983
- _wrap_CommentsFrame_text_encoding(int argc, VALUE *argv, VALUE self) {
5984
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6192
+ _wrap_ChapterFrame_start_offsete___(int argc, VALUE *argv, VALUE self) {
6193
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6194
+ unsigned int *arg2 = 0 ;
5985
6195
  void *argp1 = 0 ;
5986
6196
  int res1 = 0 ;
5987
- TagLib::String::Type result;
5988
- VALUE vresult = Qnil;
6197
+ unsigned int temp2 ;
6198
+ unsigned int val2 ;
6199
+ int ecode2 = 0 ;
5989
6200
 
5990
- if ((argc < 0) || (argc > 0)) {
5991
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6201
+ if ((argc < 1) || (argc > 1)) {
6202
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5992
6203
  }
5993
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6204
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
5994
6205
  if (!SWIG_IsOK(res1)) {
5995
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","textEncoding", 1, self ));
6206
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setStartOffset", 1, self ));
5996
6207
  }
5997
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
5998
- result = (TagLib::String::Type)((TagLib::ID3v2::CommentsFrame const *)arg1)->textEncoding();
5999
- vresult = SWIG_From_int(static_cast< int >(result));
6000
- return vresult;
6208
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6209
+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
6210
+ if (!SWIG_IsOK(ecode2)) {
6211
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setStartOffset", 2, argv[0] ));
6212
+ }
6213
+ temp2 = static_cast< unsigned int >(val2);
6214
+ arg2 = &temp2;
6215
+ (arg1)->setStartOffset((unsigned int const &)*arg2);
6216
+ return Qnil;
6001
6217
  fail:
6002
6218
  return Qnil;
6003
6219
  }
6004
6220
 
6005
6221
 
6006
6222
  SWIGINTERN VALUE
6007
- _wrap_CommentsFrame_text_encodinge___(int argc, VALUE *argv, VALUE self) {
6008
- TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6009
- TagLib::String::Type arg2 ;
6223
+ _wrap_ChapterFrame_end_offsete___(int argc, VALUE *argv, VALUE self) {
6224
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6225
+ unsigned int *arg2 = 0 ;
6010
6226
  void *argp1 = 0 ;
6011
6227
  int res1 = 0 ;
6012
- int val2 ;
6228
+ unsigned int temp2 ;
6229
+ unsigned int val2 ;
6013
6230
  int ecode2 = 0 ;
6014
6231
 
6015
6232
  if ((argc < 1) || (argc > 1)) {
6016
6233
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6017
6234
  }
6018
- res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6235
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6019
6236
  if (!SWIG_IsOK(res1)) {
6020
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setTextEncoding", 1, self ));
6237
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","setEndOffset", 1, self ));
6021
6238
  }
6022
- arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6023
- ecode2 = SWIG_AsVal_int(argv[0], &val2);
6239
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6240
+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
6024
6241
  if (!SWIG_IsOK(ecode2)) {
6025
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
6242
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setEndOffset", 2, argv[0] ));
6026
6243
  }
6027
- arg2 = static_cast< TagLib::String::Type >(val2);
6028
- (arg1)->setTextEncoding(arg2);
6244
+ temp2 = static_cast< unsigned int >(val2);
6245
+ arg2 = &temp2;
6246
+ (arg1)->setEndOffset((unsigned int const &)*arg2);
6029
6247
  return Qnil;
6030
6248
  fail:
6031
6249
  return Qnil;
@@ -6033,45 +6251,1741 @@ fail:
6033
6251
 
6034
6252
 
6035
6253
  SWIGINTERN VALUE
6036
- _wrap_CommentsFrame_find_by_description(int argc, VALUE *argv, VALUE self) {
6037
- TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
6038
- TagLib::String *arg2 = 0 ;
6254
+ _wrap_ChapterFrame_embedded_frame_list_map(int argc, VALUE *argv, VALUE self) {
6255
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6039
6256
  void *argp1 = 0 ;
6040
6257
  int res1 = 0 ;
6041
- TagLib::String tmp2 ;
6042
- TagLib::ID3v2::CommentsFrame *result = 0 ;
6258
+ TagLib::ID3v2::FrameListMap *result = 0 ;
6259
+ VALUE vresult = Qnil;
6260
+
6261
+ if ((argc < 0) || (argc > 0)) {
6262
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6263
+ }
6264
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6265
+ if (!SWIG_IsOK(res1)) {
6266
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","embeddedFrameListMap", 1, self ));
6267
+ }
6268
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6269
+ result = (TagLib::ID3v2::FrameListMap *) &((TagLib::ID3v2::ChapterFrame const *)arg1)->embeddedFrameListMap();
6270
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MapT_TagLib__ByteVector_TagLib__ListT_TagLib__ID3v2__Frame_p_t_t, 0 | 0 );
6271
+ return vresult;
6272
+ fail:
6273
+ return Qnil;
6274
+ }
6275
+
6276
+
6277
+ SWIGINTERN VALUE
6278
+ _wrap_ChapterFrame_embedded_frame_list__SWIG_0(int argc, VALUE *argv, VALUE self) {
6279
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6280
+ void *argp1 = 0 ;
6281
+ int res1 = 0 ;
6282
+ TagLib::ID3v2::FrameList *result = 0 ;
6283
+ VALUE vresult = Qnil;
6284
+
6285
+ if ((argc < 0) || (argc > 0)) {
6286
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6287
+ }
6288
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6289
+ if (!SWIG_IsOK(res1)) {
6290
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","embeddedFrameList", 1, self ));
6291
+ }
6292
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6293
+ result = (TagLib::ID3v2::FrameList *) &((TagLib::ID3v2::ChapterFrame const *)arg1)->embeddedFrameList();
6294
+ {
6295
+ vresult = taglib_id3v2_framelist_to_ruby_array(result);
6296
+ }
6297
+ return vresult;
6298
+ fail:
6299
+ return Qnil;
6300
+ }
6301
+
6302
+
6303
+ SWIGINTERN VALUE
6304
+ _wrap_ChapterFrame_embedded_frame_list__SWIG_1(int argc, VALUE *argv, VALUE self) {
6305
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6306
+ TagLib::ByteVector *arg2 = 0 ;
6307
+ void *argp1 = 0 ;
6308
+ int res1 = 0 ;
6309
+ TagLib::ByteVector tmp2 ;
6310
+ TagLib::ID3v2::FrameList *result = 0 ;
6043
6311
  VALUE vresult = Qnil;
6044
6312
 
6313
+ if ((argc < 1) || (argc > 1)) {
6314
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6315
+ }
6316
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6317
+ if (!SWIG_IsOK(res1)) {
6318
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","embeddedFrameList", 1, self ));
6319
+ }
6320
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6321
+ {
6322
+ tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
6323
+ arg2 = &tmp2;
6324
+ }
6325
+ result = (TagLib::ID3v2::FrameList *) &((TagLib::ID3v2::ChapterFrame const *)arg1)->embeddedFrameList((TagLib::ByteVector const &)*arg2);
6326
+ {
6327
+ vresult = taglib_id3v2_framelist_to_ruby_array(result);
6328
+ }
6329
+ return vresult;
6330
+ fail:
6331
+ return Qnil;
6332
+ }
6333
+
6334
+
6335
+ SWIGINTERN VALUE _wrap_ChapterFrame_embedded_frame_list(int nargs, VALUE *args, VALUE self) {
6336
+ int argc;
6337
+ VALUE argv[3];
6338
+ int ii;
6339
+
6340
+ argc = nargs + 1;
6341
+ argv[0] = self;
6342
+ if (argc > 3) SWIG_fail;
6343
+ for (ii = 1; (ii < argc); ++ii) {
6344
+ argv[ii] = args[ii-1];
6345
+ }
6346
+ if (argc == 1) {
6347
+ int _v;
6348
+ void *vptr = 0;
6349
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
6350
+ _v = SWIG_CheckState(res);
6351
+ if (_v) {
6352
+ return _wrap_ChapterFrame_embedded_frame_list__SWIG_0(nargs, args, self);
6353
+ }
6354
+ }
6355
+ if (argc == 2) {
6356
+ int _v;
6357
+ void *vptr = 0;
6358
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
6359
+ _v = SWIG_CheckState(res);
6360
+ if (_v) {
6361
+ int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
6362
+ _v = SWIG_CheckState(res);
6363
+ if (_v) {
6364
+ return _wrap_ChapterFrame_embedded_frame_list__SWIG_1(nargs, args, self);
6365
+ }
6366
+ }
6367
+ }
6368
+
6369
+ fail:
6370
+ Ruby_Format_OverloadedError( argc, 3, "ChapterFrame.embedded_frame_list",
6371
+ " TagLib::ID3v2::FrameList const & ChapterFrame.embedded_frame_list()\n"
6372
+ " TagLib::ID3v2::FrameList const & ChapterFrame.embedded_frame_list(TagLib::ByteVector const &frameID)\n");
6373
+
6374
+ return Qnil;
6375
+ }
6376
+
6377
+
6378
+ SWIGINTERN VALUE
6379
+ _wrap_ChapterFrame_add_embedded_frame(int argc, VALUE *argv, VALUE self) {
6380
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6381
+ TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
6382
+ void *argp1 = 0 ;
6383
+ int res1 = 0 ;
6384
+ int res2 = 0 ;
6385
+
6386
+ if ((argc < 1) || (argc > 1)) {
6387
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6388
+ }
6389
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6390
+ if (!SWIG_IsOK(res1)) {
6391
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","addEmbeddedFrame", 1, self ));
6392
+ }
6393
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6394
+ res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN | 0 );
6395
+ if (!SWIG_IsOK(res2)) {
6396
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","addEmbeddedFrame", 2, argv[0] ));
6397
+ }
6398
+ SWIG_RubyUnlinkObjects(arg2);
6399
+ SWIG_RubyRemoveTracking(arg2);
6400
+ (arg1)->addEmbeddedFrame(arg2);
6401
+ return Qnil;
6402
+ fail:
6403
+ return Qnil;
6404
+ }
6405
+
6406
+
6407
+ SWIGINTERN VALUE
6408
+ _wrap_ChapterFrame_remove_embedded_frame__SWIG_0(int argc, VALUE *argv, VALUE self) {
6409
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6410
+ TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
6411
+ bool arg3 ;
6412
+ void *argp1 = 0 ;
6413
+ int res1 = 0 ;
6414
+ int res2 = 0 ;
6415
+ bool val3 ;
6416
+ int ecode3 = 0 ;
6417
+
6045
6418
  if ((argc < 2) || (argc > 2)) {
6046
6419
  rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
6047
6420
  }
6048
- res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
6421
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6049
6422
  if (!SWIG_IsOK(res1)) {
6050
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","TagLib::ID3v2::CommentsFrame::findByDescription", 1, argv[0] ));
6423
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","removeEmbeddedFrame", 1, self ));
6424
+ }
6425
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6426
+ res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN | 0 );
6427
+ if (!SWIG_IsOK(res2)) {
6428
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","removeEmbeddedFrame", 2, argv[0] ));
6429
+ }
6430
+ SWIG_RubyUnlinkObjects(arg2);
6431
+ SWIG_RubyRemoveTracking(arg2);
6432
+ ecode3 = SWIG_AsVal_bool(argv[1], &val3);
6433
+ if (!SWIG_IsOK(ecode3)) {
6434
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","removeEmbeddedFrame", 3, argv[1] ));
6435
+ }
6436
+ arg3 = static_cast< bool >(val3);
6437
+ (arg1)->removeEmbeddedFrame(arg2,arg3);
6438
+ return Qnil;
6439
+ fail:
6440
+ return Qnil;
6441
+ }
6442
+
6443
+
6444
+ SWIGINTERN VALUE
6445
+ _wrap_ChapterFrame_remove_embedded_frame__SWIG_1(int argc, VALUE *argv, VALUE self) {
6446
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6447
+ TagLib::ID3v2::Frame *arg2 = (TagLib::ID3v2::Frame *) 0 ;
6448
+ void *argp1 = 0 ;
6449
+ int res1 = 0 ;
6450
+ int res2 = 0 ;
6451
+
6452
+ if ((argc < 1) || (argc > 1)) {
6453
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6454
+ }
6455
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6456
+ if (!SWIG_IsOK(res1)) {
6457
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","removeEmbeddedFrame", 1, self ));
6458
+ }
6459
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6460
+ res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_TagLib__ID3v2__Frame, SWIG_POINTER_DISOWN | 0 );
6461
+ if (!SWIG_IsOK(res2)) {
6462
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "TagLib::ID3v2::Frame *","removeEmbeddedFrame", 2, argv[0] ));
6463
+ }
6464
+ SWIG_RubyUnlinkObjects(arg2);
6465
+ SWIG_RubyRemoveTracking(arg2);
6466
+ (arg1)->removeEmbeddedFrame(arg2);
6467
+ return Qnil;
6468
+ fail:
6469
+ return Qnil;
6470
+ }
6471
+
6472
+
6473
+ SWIGINTERN VALUE _wrap_ChapterFrame_remove_embedded_frame(int nargs, VALUE *args, VALUE self) {
6474
+ int argc;
6475
+ VALUE argv[4];
6476
+ int ii;
6477
+
6478
+ argc = nargs + 1;
6479
+ argv[0] = self;
6480
+ if (argc > 4) SWIG_fail;
6481
+ for (ii = 1; (ii < argc); ++ii) {
6482
+ argv[ii] = args[ii-1];
6483
+ }
6484
+ if (argc == 2) {
6485
+ int _v;
6486
+ void *vptr = 0;
6487
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
6488
+ _v = SWIG_CheckState(res);
6489
+ if (_v) {
6490
+ void *vptr = 0;
6491
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__ID3v2__Frame, 0);
6492
+ _v = SWIG_CheckState(res);
6493
+ if (_v) {
6494
+ return _wrap_ChapterFrame_remove_embedded_frame__SWIG_1(nargs, args, self);
6495
+ }
6496
+ }
6497
+ }
6498
+ if (argc == 3) {
6499
+ int _v;
6500
+ void *vptr = 0;
6501
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0);
6502
+ _v = SWIG_CheckState(res);
6503
+ if (_v) {
6504
+ void *vptr = 0;
6505
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__ID3v2__Frame, 0);
6506
+ _v = SWIG_CheckState(res);
6507
+ if (_v) {
6508
+ {
6509
+ int res = SWIG_AsVal_bool(argv[2], NULL);
6510
+ _v = SWIG_CheckState(res);
6511
+ }
6512
+ if (_v) {
6513
+ return _wrap_ChapterFrame_remove_embedded_frame__SWIG_0(nargs, args, self);
6514
+ }
6515
+ }
6516
+ }
6517
+ }
6518
+
6519
+ fail:
6520
+ Ruby_Format_OverloadedError( argc, 4, "ChapterFrame.remove_embedded_frame",
6521
+ " void ChapterFrame.remove_embedded_frame(TagLib::ID3v2::Frame *frame, bool del)\n"
6522
+ " void ChapterFrame.remove_embedded_frame(TagLib::ID3v2::Frame *frame)\n");
6523
+
6524
+ return Qnil;
6525
+ }
6526
+
6527
+
6528
+ SWIGINTERN VALUE
6529
+ _wrap_ChapterFrame_remove_embedded_frames(int argc, VALUE *argv, VALUE self) {
6530
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6531
+ TagLib::ByteVector *arg2 = 0 ;
6532
+ void *argp1 = 0 ;
6533
+ int res1 = 0 ;
6534
+ TagLib::ByteVector tmp2 ;
6535
+
6536
+ if ((argc < 1) || (argc > 1)) {
6537
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6538
+ }
6539
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6540
+ if (!SWIG_IsOK(res1)) {
6541
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame *","removeEmbeddedFrames", 1, self ));
6542
+ }
6543
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6544
+ {
6545
+ tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
6546
+ arg2 = &tmp2;
6547
+ }
6548
+ (arg1)->removeEmbeddedFrames((TagLib::ByteVector const &)*arg2);
6549
+ return Qnil;
6550
+ fail:
6551
+ return Qnil;
6552
+ }
6553
+
6554
+
6555
+ SWIGINTERN VALUE
6556
+ _wrap_ChapterFrame_to_string(int argc, VALUE *argv, VALUE self) {
6557
+ TagLib::ID3v2::ChapterFrame *arg1 = (TagLib::ID3v2::ChapterFrame *) 0 ;
6558
+ void *argp1 = 0 ;
6559
+ int res1 = 0 ;
6560
+ TagLib::String result;
6561
+ VALUE vresult = Qnil;
6562
+
6563
+ if ((argc < 0) || (argc > 0)) {
6564
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6565
+ }
6566
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6567
+ if (!SWIG_IsOK(res1)) {
6568
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::ChapterFrame const *","toString", 1, self ));
6569
+ }
6570
+ arg1 = reinterpret_cast< TagLib::ID3v2::ChapterFrame * >(argp1);
6571
+ result = ((TagLib::ID3v2::ChapterFrame const *)arg1)->toString();
6572
+ {
6573
+ vresult = taglib_string_to_ruby_string(result);
6574
+ }
6575
+ return vresult;
6576
+ fail:
6577
+ return Qnil;
6578
+ }
6579
+
6580
+
6581
+ SWIGINTERN VALUE
6582
+ _wrap_ChapterFrame_find_by_element_id(int argc, VALUE *argv, VALUE self) {
6583
+ TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
6584
+ TagLib::ByteVector *arg2 = 0 ;
6585
+ void *argp1 = 0 ;
6586
+ int res1 = 0 ;
6587
+ TagLib::ByteVector tmp2 ;
6588
+ TagLib::ID3v2::ChapterFrame *result = 0 ;
6589
+ VALUE vresult = Qnil;
6590
+
6591
+ if ((argc < 2) || (argc > 2)) {
6592
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
6593
+ }
6594
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
6595
+ if (!SWIG_IsOK(res1)) {
6596
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","TagLib::ID3v2::ChapterFrame::findByElementID", 1, argv[0] ));
6597
+ }
6598
+ arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
6599
+ {
6600
+ tmp2 = ruby_string_to_taglib_bytevector(argv[1]);
6601
+ arg2 = &tmp2;
6602
+ }
6603
+ result = (TagLib::ID3v2::ChapterFrame *)TagLib::ID3v2::ChapterFrame::findByElementID((TagLib::ID3v2::Tag const *)arg1,(TagLib::ByteVector const &)*arg2);
6604
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__ChapterFrame, 0 | 0 );
6605
+ return vresult;
6606
+ fail:
6607
+ return Qnil;
6608
+ }
6609
+
6610
+
6611
+ static swig_class SwigClassCommentsFrame;
6612
+
6613
+ SWIGINTERN VALUE
6614
+ _wrap_new_CommentsFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
6615
+ TagLib::String::Type arg1 ;
6616
+ int val1 ;
6617
+ int ecode1 = 0 ;
6618
+ TagLib::ID3v2::CommentsFrame *result = 0 ;
6619
+
6620
+ if ((argc < 1) || (argc > 1)) {
6621
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6622
+ }
6623
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
6624
+ if (!SWIG_IsOK(ecode1)) {
6625
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "TagLib::String::Type","CommentsFrame", 1, argv[0] ));
6626
+ }
6627
+ arg1 = static_cast< TagLib::String::Type >(val1);
6628
+ result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame(arg1);
6629
+ DATA_PTR(self) = result;
6630
+ SWIG_RubyAddTracking(result, self);
6631
+ return self;
6632
+ fail:
6633
+ return Qnil;
6634
+ }
6635
+
6636
+
6637
+ SWIGINTERN VALUE
6638
+ _wrap_new_CommentsFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
6639
+ TagLib::ID3v2::CommentsFrame *result = 0 ;
6640
+
6641
+ if ((argc < 0) || (argc > 0)) {
6642
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6643
+ }
6644
+ result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame();
6645
+ DATA_PTR(self) = result;
6646
+ SWIG_RubyAddTracking(result, self);
6647
+ return self;
6648
+ fail:
6649
+ return Qnil;
6650
+ }
6651
+
6652
+
6653
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
6654
+ SWIGINTERN VALUE
6655
+ _wrap_CommentsFrame_allocate(VALUE self) {
6656
+ #else
6657
+ SWIGINTERN VALUE
6658
+ _wrap_CommentsFrame_allocate(int argc, VALUE *argv, VALUE self) {
6659
+ #endif
6660
+
6661
+
6662
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__CommentsFrame);
6663
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
6664
+ rb_obj_call_init(vresult, argc, argv);
6665
+ #endif
6666
+ return vresult;
6667
+ }
6668
+
6669
+
6670
+ SWIGINTERN VALUE
6671
+ _wrap_new_CommentsFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
6672
+ TagLib::ByteVector *arg1 = 0 ;
6673
+ TagLib::ByteVector tmp1 ;
6674
+ TagLib::ID3v2::CommentsFrame *result = 0 ;
6675
+
6676
+ if ((argc < 1) || (argc > 1)) {
6677
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6678
+ }
6679
+ {
6680
+ tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
6681
+ arg1 = &tmp1;
6682
+ }
6683
+ result = (TagLib::ID3v2::CommentsFrame *)new TagLib::ID3v2::CommentsFrame((TagLib::ByteVector const &)*arg1);
6684
+ DATA_PTR(self) = result;
6685
+ SWIG_RubyAddTracking(result, self);
6686
+ return self;
6687
+ fail:
6688
+ return Qnil;
6689
+ }
6690
+
6691
+
6692
+ SWIGINTERN VALUE _wrap_new_CommentsFrame(int nargs, VALUE *args, VALUE self) {
6693
+ int argc;
6694
+ VALUE argv[1];
6695
+ int ii;
6696
+
6697
+ argc = nargs;
6698
+ if (argc > 1) SWIG_fail;
6699
+ for (ii = 0; (ii < argc); ++ii) {
6700
+ argv[ii] = args[ii];
6701
+ }
6702
+ if (argc == 0) {
6703
+ return _wrap_new_CommentsFrame__SWIG_1(nargs, args, self);
6704
+ }
6705
+ if (argc == 1) {
6706
+ int _v;
6707
+ {
6708
+ int res = SWIG_AsVal_int(argv[0], NULL);
6709
+ _v = SWIG_CheckState(res);
6710
+ }
6711
+ if (_v) {
6712
+ return _wrap_new_CommentsFrame__SWIG_0(nargs, args, self);
6713
+ }
6714
+ }
6715
+ if (argc == 1) {
6716
+ int _v;
6717
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
6718
+ _v = SWIG_CheckState(res);
6719
+ if (_v) {
6720
+ return _wrap_new_CommentsFrame__SWIG_2(nargs, args, self);
6721
+ }
6722
+ }
6723
+
6724
+ fail:
6725
+ Ruby_Format_OverloadedError( argc, 1, "CommentsFrame.new",
6726
+ " CommentsFrame.new(TagLib::String::Type encoding)\n"
6727
+ " CommentsFrame.new()\n"
6728
+ " CommentsFrame.new(TagLib::ByteVector const &data)\n");
6729
+
6730
+ return Qnil;
6731
+ }
6732
+
6733
+
6734
+ SWIGINTERN void
6735
+ free_TagLib_ID3v2_CommentsFrame(TagLib::ID3v2::CommentsFrame *arg1) {
6736
+ SWIG_RubyRemoveTracking(arg1);
6737
+ delete arg1;
6738
+ }
6739
+
6740
+ SWIGINTERN VALUE
6741
+ _wrap_CommentsFrame_to_string(int argc, VALUE *argv, VALUE self) {
6742
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6743
+ void *argp1 = 0 ;
6744
+ int res1 = 0 ;
6745
+ TagLib::String result;
6746
+ VALUE vresult = Qnil;
6747
+
6748
+ if ((argc < 0) || (argc > 0)) {
6749
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6750
+ }
6751
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6752
+ if (!SWIG_IsOK(res1)) {
6753
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","toString", 1, self ));
6754
+ }
6755
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6756
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->toString();
6757
+ {
6758
+ vresult = taglib_string_to_ruby_string(result);
6759
+ }
6760
+ return vresult;
6761
+ fail:
6762
+ return Qnil;
6763
+ }
6764
+
6765
+
6766
+ SWIGINTERN VALUE
6767
+ _wrap_CommentsFrame_language(int argc, VALUE *argv, VALUE self) {
6768
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6769
+ void *argp1 = 0 ;
6770
+ int res1 = 0 ;
6771
+ TagLib::ByteVector result;
6772
+ VALUE vresult = Qnil;
6773
+
6774
+ if ((argc < 0) || (argc > 0)) {
6775
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6776
+ }
6777
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6778
+ if (!SWIG_IsOK(res1)) {
6779
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","language", 1, self ));
6780
+ }
6781
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6782
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->language();
6783
+ {
6784
+ vresult = taglib_bytevector_to_ruby_string(result);
6785
+ }
6786
+ return vresult;
6787
+ fail:
6788
+ return Qnil;
6789
+ }
6790
+
6791
+
6792
+ SWIGINTERN VALUE
6793
+ _wrap_CommentsFrame_description(int argc, VALUE *argv, VALUE self) {
6794
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6795
+ void *argp1 = 0 ;
6796
+ int res1 = 0 ;
6797
+ TagLib::String result;
6798
+ VALUE vresult = Qnil;
6799
+
6800
+ if ((argc < 0) || (argc > 0)) {
6801
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6802
+ }
6803
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6804
+ if (!SWIG_IsOK(res1)) {
6805
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","description", 1, self ));
6806
+ }
6807
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6808
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->description();
6809
+ {
6810
+ vresult = taglib_string_to_ruby_string(result);
6811
+ }
6812
+ return vresult;
6813
+ fail:
6814
+ return Qnil;
6815
+ }
6816
+
6817
+
6818
+ SWIGINTERN VALUE
6819
+ _wrap_CommentsFrame_text(int argc, VALUE *argv, VALUE self) {
6820
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6821
+ void *argp1 = 0 ;
6822
+ int res1 = 0 ;
6823
+ TagLib::String result;
6824
+ VALUE vresult = Qnil;
6825
+
6826
+ if ((argc < 0) || (argc > 0)) {
6827
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6828
+ }
6829
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6830
+ if (!SWIG_IsOK(res1)) {
6831
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","text", 1, self ));
6832
+ }
6833
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6834
+ result = ((TagLib::ID3v2::CommentsFrame const *)arg1)->text();
6835
+ {
6836
+ vresult = taglib_string_to_ruby_string(result);
6837
+ }
6838
+ return vresult;
6839
+ fail:
6840
+ return Qnil;
6841
+ }
6842
+
6843
+
6844
+ SWIGINTERN VALUE
6845
+ _wrap_CommentsFrame_languagee___(int argc, VALUE *argv, VALUE self) {
6846
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6847
+ TagLib::ByteVector *arg2 = 0 ;
6848
+ void *argp1 = 0 ;
6849
+ int res1 = 0 ;
6850
+ TagLib::ByteVector tmp2 ;
6851
+
6852
+ if ((argc < 1) || (argc > 1)) {
6853
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6854
+ }
6855
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6856
+ if (!SWIG_IsOK(res1)) {
6857
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setLanguage", 1, self ));
6858
+ }
6859
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6860
+ {
6861
+ tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
6862
+ arg2 = &tmp2;
6863
+ }
6864
+ (arg1)->setLanguage((TagLib::ByteVector const &)*arg2);
6865
+ return Qnil;
6866
+ fail:
6867
+ return Qnil;
6868
+ }
6869
+
6870
+
6871
+ SWIGINTERN VALUE
6872
+ _wrap_CommentsFrame_descriptione___(int argc, VALUE *argv, VALUE self) {
6873
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6874
+ TagLib::String *arg2 = 0 ;
6875
+ void *argp1 = 0 ;
6876
+ int res1 = 0 ;
6877
+ TagLib::String tmp2 ;
6878
+
6879
+ if ((argc < 1) || (argc > 1)) {
6880
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6881
+ }
6882
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6883
+ if (!SWIG_IsOK(res1)) {
6884
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setDescription", 1, self ));
6885
+ }
6886
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6887
+ {
6888
+ tmp2 = ruby_string_to_taglib_string(argv[0]);
6889
+ arg2 = &tmp2;
6890
+ }
6891
+ (arg1)->setDescription((TagLib::String const &)*arg2);
6892
+ return Qnil;
6893
+ fail:
6894
+ return Qnil;
6895
+ }
6896
+
6897
+
6898
+ SWIGINTERN VALUE
6899
+ _wrap_CommentsFrame_texte___(int argc, VALUE *argv, VALUE self) {
6900
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6901
+ TagLib::String *arg2 = 0 ;
6902
+ void *argp1 = 0 ;
6903
+ int res1 = 0 ;
6904
+ TagLib::String tmp2 ;
6905
+
6906
+ if ((argc < 1) || (argc > 1)) {
6907
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6908
+ }
6909
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6910
+ if (!SWIG_IsOK(res1)) {
6911
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setText", 1, self ));
6912
+ }
6913
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6914
+ {
6915
+ tmp2 = ruby_string_to_taglib_string(argv[0]);
6916
+ arg2 = &tmp2;
6917
+ }
6918
+ (arg1)->setText((TagLib::String const &)*arg2);
6919
+ return Qnil;
6920
+ fail:
6921
+ return Qnil;
6922
+ }
6923
+
6924
+
6925
+ SWIGINTERN VALUE
6926
+ _wrap_CommentsFrame_text_encoding(int argc, VALUE *argv, VALUE self) {
6927
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6928
+ void *argp1 = 0 ;
6929
+ int res1 = 0 ;
6930
+ TagLib::String::Type result;
6931
+ VALUE vresult = Qnil;
6932
+
6933
+ if ((argc < 0) || (argc > 0)) {
6934
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6935
+ }
6936
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6937
+ if (!SWIG_IsOK(res1)) {
6938
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame const *","textEncoding", 1, self ));
6939
+ }
6940
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6941
+ result = (TagLib::String::Type)((TagLib::ID3v2::CommentsFrame const *)arg1)->textEncoding();
6942
+ vresult = SWIG_From_int(static_cast< int >(result));
6943
+ return vresult;
6944
+ fail:
6945
+ return Qnil;
6946
+ }
6947
+
6948
+
6949
+ SWIGINTERN VALUE
6950
+ _wrap_CommentsFrame_text_encodinge___(int argc, VALUE *argv, VALUE self) {
6951
+ TagLib::ID3v2::CommentsFrame *arg1 = (TagLib::ID3v2::CommentsFrame *) 0 ;
6952
+ TagLib::String::Type arg2 ;
6953
+ void *argp1 = 0 ;
6954
+ int res1 = 0 ;
6955
+ int val2 ;
6956
+ int ecode2 = 0 ;
6957
+
6958
+ if ((argc < 1) || (argc > 1)) {
6959
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6960
+ }
6961
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
6962
+ if (!SWIG_IsOK(res1)) {
6963
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::CommentsFrame *","setTextEncoding", 1, self ));
6964
+ }
6965
+ arg1 = reinterpret_cast< TagLib::ID3v2::CommentsFrame * >(argp1);
6966
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6967
+ if (!SWIG_IsOK(ecode2)) {
6968
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
6969
+ }
6970
+ arg2 = static_cast< TagLib::String::Type >(val2);
6971
+ (arg1)->setTextEncoding(arg2);
6972
+ return Qnil;
6973
+ fail:
6974
+ return Qnil;
6975
+ }
6976
+
6977
+
6978
+ SWIGINTERN VALUE
6979
+ _wrap_CommentsFrame_find_by_description(int argc, VALUE *argv, VALUE self) {
6980
+ TagLib::ID3v2::Tag *arg1 = (TagLib::ID3v2::Tag *) 0 ;
6981
+ TagLib::String *arg2 = 0 ;
6982
+ void *argp1 = 0 ;
6983
+ int res1 = 0 ;
6984
+ TagLib::String tmp2 ;
6985
+ TagLib::ID3v2::CommentsFrame *result = 0 ;
6986
+ VALUE vresult = Qnil;
6987
+
6988
+ if ((argc < 2) || (argc > 2)) {
6989
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
6990
+ }
6991
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_TagLib__ID3v2__Tag, 0 | 0 );
6992
+ if (!SWIG_IsOK(res1)) {
6993
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::Tag const *","TagLib::ID3v2::CommentsFrame::findByDescription", 1, argv[0] ));
6994
+ }
6995
+ arg1 = reinterpret_cast< TagLib::ID3v2::Tag * >(argp1);
6996
+ {
6997
+ tmp2 = ruby_string_to_taglib_string(argv[1]);
6998
+ arg2 = &tmp2;
6999
+ }
7000
+ result = (TagLib::ID3v2::CommentsFrame *)TagLib::ID3v2::CommentsFrame::findByDescription((TagLib::ID3v2::Tag const *)arg1,(TagLib::String const &)*arg2);
7001
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TagLib__ID3v2__CommentsFrame, 0 | 0 );
7002
+ return vresult;
7003
+ fail:
7004
+ return Qnil;
7005
+ }
7006
+
7007
+
7008
+ static swig_class SwigClassGeneralEncapsulatedObjectFrame;
7009
+
7010
+ SWIGINTERN VALUE
7011
+ _wrap_new_GeneralEncapsulatedObjectFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
7012
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *result = 0 ;
7013
+
7014
+ if ((argc < 0) || (argc > 0)) {
7015
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7016
+ }
7017
+ result = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *)new TagLib::ID3v2::GeneralEncapsulatedObjectFrame();
7018
+ DATA_PTR(self) = result;
7019
+ SWIG_RubyAddTracking(result, self);
7020
+ return self;
7021
+ fail:
7022
+ return Qnil;
7023
+ }
7024
+
7025
+
7026
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7027
+ SWIGINTERN VALUE
7028
+ _wrap_GeneralEncapsulatedObjectFrame_allocate(VALUE self) {
7029
+ #else
7030
+ SWIGINTERN VALUE
7031
+ _wrap_GeneralEncapsulatedObjectFrame_allocate(int argc, VALUE *argv, VALUE self) {
7032
+ #endif
7033
+
7034
+
7035
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame);
7036
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7037
+ rb_obj_call_init(vresult, argc, argv);
7038
+ #endif
7039
+ return vresult;
7040
+ }
7041
+
7042
+
7043
+ SWIGINTERN VALUE
7044
+ _wrap_new_GeneralEncapsulatedObjectFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
7045
+ TagLib::ByteVector *arg1 = 0 ;
7046
+ TagLib::ByteVector tmp1 ;
7047
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *result = 0 ;
7048
+
7049
+ if ((argc < 1) || (argc > 1)) {
7050
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7051
+ }
7052
+ {
7053
+ tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
7054
+ arg1 = &tmp1;
7055
+ }
7056
+ result = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *)new TagLib::ID3v2::GeneralEncapsulatedObjectFrame((TagLib::ByteVector const &)*arg1);
7057
+ DATA_PTR(self) = result;
7058
+ SWIG_RubyAddTracking(result, self);
7059
+ return self;
7060
+ fail:
7061
+ return Qnil;
7062
+ }
7063
+
7064
+
7065
+ SWIGINTERN VALUE _wrap_new_GeneralEncapsulatedObjectFrame(int nargs, VALUE *args, VALUE self) {
7066
+ int argc;
7067
+ VALUE argv[1];
7068
+ int ii;
7069
+
7070
+ argc = nargs;
7071
+ if (argc > 1) SWIG_fail;
7072
+ for (ii = 0; (ii < argc); ++ii) {
7073
+ argv[ii] = args[ii];
7074
+ }
7075
+ if (argc == 0) {
7076
+ return _wrap_new_GeneralEncapsulatedObjectFrame__SWIG_0(nargs, args, self);
7077
+ }
7078
+ if (argc == 1) {
7079
+ int _v;
7080
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
7081
+ _v = SWIG_CheckState(res);
7082
+ if (_v) {
7083
+ return _wrap_new_GeneralEncapsulatedObjectFrame__SWIG_1(nargs, args, self);
7084
+ }
7085
+ }
7086
+
7087
+ fail:
7088
+ Ruby_Format_OverloadedError( argc, 1, "GeneralEncapsulatedObjectFrame.new",
7089
+ " GeneralEncapsulatedObjectFrame.new()\n"
7090
+ " GeneralEncapsulatedObjectFrame.new(TagLib::ByteVector const &data)\n");
7091
+
7092
+ return Qnil;
7093
+ }
7094
+
7095
+
7096
+ SWIGINTERN void
7097
+ free_TagLib_ID3v2_GeneralEncapsulatedObjectFrame(TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1) {
7098
+ SWIG_RubyRemoveTracking(arg1);
7099
+ delete arg1;
7100
+ }
7101
+
7102
+ SWIGINTERN VALUE
7103
+ _wrap_GeneralEncapsulatedObjectFrame_to_string(int argc, VALUE *argv, VALUE self) {
7104
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7105
+ void *argp1 = 0 ;
7106
+ int res1 = 0 ;
7107
+ TagLib::String result;
7108
+ VALUE vresult = Qnil;
7109
+
7110
+ if ((argc < 0) || (argc > 0)) {
7111
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7112
+ }
7113
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7114
+ if (!SWIG_IsOK(res1)) {
7115
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","toString", 1, self ));
7116
+ }
7117
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7118
+ result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->toString();
7119
+ {
7120
+ vresult = taglib_string_to_ruby_string(result);
7121
+ }
7122
+ return vresult;
7123
+ fail:
7124
+ return Qnil;
7125
+ }
7126
+
7127
+
7128
+ SWIGINTERN VALUE
7129
+ _wrap_GeneralEncapsulatedObjectFrame_text_encoding(int argc, VALUE *argv, VALUE self) {
7130
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7131
+ void *argp1 = 0 ;
7132
+ int res1 = 0 ;
7133
+ TagLib::String::Type result;
7134
+ VALUE vresult = Qnil;
7135
+
7136
+ if ((argc < 0) || (argc > 0)) {
7137
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7138
+ }
7139
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7140
+ if (!SWIG_IsOK(res1)) {
7141
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","textEncoding", 1, self ));
7142
+ }
7143
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7144
+ result = (TagLib::String::Type)((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->textEncoding();
7145
+ vresult = SWIG_From_int(static_cast< int >(result));
7146
+ return vresult;
7147
+ fail:
7148
+ return Qnil;
7149
+ }
7150
+
7151
+
7152
+ SWIGINTERN VALUE
7153
+ _wrap_GeneralEncapsulatedObjectFrame_text_encodinge___(int argc, VALUE *argv, VALUE self) {
7154
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7155
+ TagLib::String::Type arg2 ;
7156
+ void *argp1 = 0 ;
7157
+ int res1 = 0 ;
7158
+ int val2 ;
7159
+ int ecode2 = 0 ;
7160
+
7161
+ if ((argc < 1) || (argc > 1)) {
7162
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7163
+ }
7164
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7165
+ if (!SWIG_IsOK(res1)) {
7166
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setTextEncoding", 1, self ));
7167
+ }
7168
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7169
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7170
+ if (!SWIG_IsOK(ecode2)) {
7171
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "TagLib::String::Type","setTextEncoding", 2, argv[0] ));
7172
+ }
7173
+ arg2 = static_cast< TagLib::String::Type >(val2);
7174
+ (arg1)->setTextEncoding(arg2);
7175
+ return Qnil;
7176
+ fail:
7177
+ return Qnil;
7178
+ }
7179
+
7180
+
7181
+ SWIGINTERN VALUE
7182
+ _wrap_GeneralEncapsulatedObjectFrame_mime_type(int argc, VALUE *argv, VALUE self) {
7183
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7184
+ void *argp1 = 0 ;
7185
+ int res1 = 0 ;
7186
+ TagLib::String result;
7187
+ VALUE vresult = Qnil;
7188
+
7189
+ if ((argc < 0) || (argc > 0)) {
7190
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7191
+ }
7192
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7193
+ if (!SWIG_IsOK(res1)) {
7194
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","mimeType", 1, self ));
7195
+ }
7196
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7197
+ result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->mimeType();
7198
+ {
7199
+ vresult = taglib_string_to_ruby_string(result);
7200
+ }
7201
+ return vresult;
7202
+ fail:
7203
+ return Qnil;
7204
+ }
7205
+
7206
+
7207
+ SWIGINTERN VALUE
7208
+ _wrap_GeneralEncapsulatedObjectFrame_mime_typee___(int argc, VALUE *argv, VALUE self) {
7209
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7210
+ TagLib::String *arg2 = 0 ;
7211
+ void *argp1 = 0 ;
7212
+ int res1 = 0 ;
7213
+ TagLib::String tmp2 ;
7214
+
7215
+ if ((argc < 1) || (argc > 1)) {
7216
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7217
+ }
7218
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7219
+ if (!SWIG_IsOK(res1)) {
7220
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setMimeType", 1, self ));
7221
+ }
7222
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7223
+ {
7224
+ tmp2 = ruby_string_to_taglib_string(argv[0]);
7225
+ arg2 = &tmp2;
7226
+ }
7227
+ (arg1)->setMimeType((TagLib::String const &)*arg2);
7228
+ return Qnil;
7229
+ fail:
7230
+ return Qnil;
7231
+ }
7232
+
7233
+
7234
+ SWIGINTERN VALUE
7235
+ _wrap_GeneralEncapsulatedObjectFrame_file_name(int argc, VALUE *argv, VALUE self) {
7236
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7237
+ void *argp1 = 0 ;
7238
+ int res1 = 0 ;
7239
+ TagLib::String result;
7240
+ VALUE vresult = Qnil;
7241
+
7242
+ if ((argc < 0) || (argc > 0)) {
7243
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7244
+ }
7245
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7246
+ if (!SWIG_IsOK(res1)) {
7247
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","fileName", 1, self ));
7248
+ }
7249
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7250
+ result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->fileName();
7251
+ {
7252
+ vresult = taglib_string_to_ruby_string(result);
7253
+ }
7254
+ return vresult;
7255
+ fail:
7256
+ return Qnil;
7257
+ }
7258
+
7259
+
7260
+ SWIGINTERN VALUE
7261
+ _wrap_GeneralEncapsulatedObjectFrame_file_namee___(int argc, VALUE *argv, VALUE self) {
7262
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7263
+ TagLib::String *arg2 = 0 ;
7264
+ void *argp1 = 0 ;
7265
+ int res1 = 0 ;
7266
+ TagLib::String tmp2 ;
7267
+
7268
+ if ((argc < 1) || (argc > 1)) {
7269
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7270
+ }
7271
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7272
+ if (!SWIG_IsOK(res1)) {
7273
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setFileName", 1, self ));
7274
+ }
7275
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7276
+ {
7277
+ tmp2 = ruby_string_to_taglib_string(argv[0]);
7278
+ arg2 = &tmp2;
7279
+ }
7280
+ (arg1)->setFileName((TagLib::String const &)*arg2);
7281
+ return Qnil;
7282
+ fail:
7283
+ return Qnil;
7284
+ }
7285
+
7286
+
7287
+ SWIGINTERN VALUE
7288
+ _wrap_GeneralEncapsulatedObjectFrame_description(int argc, VALUE *argv, VALUE self) {
7289
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7290
+ void *argp1 = 0 ;
7291
+ int res1 = 0 ;
7292
+ TagLib::String result;
7293
+ VALUE vresult = Qnil;
7294
+
7295
+ if ((argc < 0) || (argc > 0)) {
7296
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7297
+ }
7298
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7299
+ if (!SWIG_IsOK(res1)) {
7300
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","description", 1, self ));
7301
+ }
7302
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7303
+ result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->description();
7304
+ {
7305
+ vresult = taglib_string_to_ruby_string(result);
7306
+ }
7307
+ return vresult;
7308
+ fail:
7309
+ return Qnil;
7310
+ }
7311
+
7312
+
7313
+ SWIGINTERN VALUE
7314
+ _wrap_GeneralEncapsulatedObjectFrame_descriptione___(int argc, VALUE *argv, VALUE self) {
7315
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7316
+ TagLib::String *arg2 = 0 ;
7317
+ void *argp1 = 0 ;
7318
+ int res1 = 0 ;
7319
+ TagLib::String tmp2 ;
7320
+
7321
+ if ((argc < 1) || (argc > 1)) {
7322
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7323
+ }
7324
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7325
+ if (!SWIG_IsOK(res1)) {
7326
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setDescription", 1, self ));
7327
+ }
7328
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7329
+ {
7330
+ tmp2 = ruby_string_to_taglib_string(argv[0]);
7331
+ arg2 = &tmp2;
7332
+ }
7333
+ (arg1)->setDescription((TagLib::String const &)*arg2);
7334
+ return Qnil;
7335
+ fail:
7336
+ return Qnil;
7337
+ }
7338
+
7339
+
7340
+ SWIGINTERN VALUE
7341
+ _wrap_GeneralEncapsulatedObjectFrame_object(int argc, VALUE *argv, VALUE self) {
7342
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7343
+ void *argp1 = 0 ;
7344
+ int res1 = 0 ;
7345
+ TagLib::ByteVector result;
7346
+ VALUE vresult = Qnil;
7347
+
7348
+ if ((argc < 0) || (argc > 0)) {
7349
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7350
+ }
7351
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7352
+ if (!SWIG_IsOK(res1)) {
7353
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *","object", 1, self ));
7354
+ }
7355
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7356
+ result = ((TagLib::ID3v2::GeneralEncapsulatedObjectFrame const *)arg1)->object();
7357
+ {
7358
+ vresult = taglib_bytevector_to_ruby_string(result);
7359
+ }
7360
+ return vresult;
7361
+ fail:
7362
+ return Qnil;
7363
+ }
7364
+
7365
+
7366
+ SWIGINTERN VALUE
7367
+ _wrap_GeneralEncapsulatedObjectFrame_objecte___(int argc, VALUE *argv, VALUE self) {
7368
+ TagLib::ID3v2::GeneralEncapsulatedObjectFrame *arg1 = (TagLib::ID3v2::GeneralEncapsulatedObjectFrame *) 0 ;
7369
+ TagLib::ByteVector *arg2 = 0 ;
7370
+ void *argp1 = 0 ;
7371
+ int res1 = 0 ;
7372
+ TagLib::ByteVector tmp2 ;
7373
+
7374
+ if ((argc < 1) || (argc > 1)) {
7375
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7376
+ }
7377
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__GeneralEncapsulatedObjectFrame, 0 | 0 );
7378
+ if (!SWIG_IsOK(res1)) {
7379
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::GeneralEncapsulatedObjectFrame *","setObject", 1, self ));
7380
+ }
7381
+ arg1 = reinterpret_cast< TagLib::ID3v2::GeneralEncapsulatedObjectFrame * >(argp1);
7382
+ {
7383
+ tmp2 = ruby_string_to_taglib_bytevector(argv[0]);
7384
+ arg2 = &tmp2;
7385
+ }
7386
+ (arg1)->setObject((TagLib::ByteVector const &)*arg2);
7387
+ return Qnil;
7388
+ fail:
7389
+ return Qnil;
7390
+ }
7391
+
7392
+
7393
+ static swig_class SwigClassPopularimeterFrame;
7394
+
7395
+ SWIGINTERN VALUE
7396
+ _wrap_new_PopularimeterFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
7397
+ TagLib::ID3v2::PopularimeterFrame *result = 0 ;
7398
+
7399
+ if ((argc < 0) || (argc > 0)) {
7400
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7401
+ }
7402
+ result = (TagLib::ID3v2::PopularimeterFrame *)new TagLib::ID3v2::PopularimeterFrame();
7403
+ DATA_PTR(self) = result;
7404
+ SWIG_RubyAddTracking(result, self);
7405
+ return self;
7406
+ fail:
7407
+ return Qnil;
7408
+ }
7409
+
7410
+
7411
+ #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7412
+ SWIGINTERN VALUE
7413
+ _wrap_PopularimeterFrame_allocate(VALUE self) {
7414
+ #else
7415
+ SWIGINTERN VALUE
7416
+ _wrap_PopularimeterFrame_allocate(int argc, VALUE *argv, VALUE self) {
7417
+ #endif
7418
+
7419
+
7420
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame);
7421
+ #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7422
+ rb_obj_call_init(vresult, argc, argv);
7423
+ #endif
7424
+ return vresult;
7425
+ }
7426
+
7427
+
7428
+ SWIGINTERN VALUE
7429
+ _wrap_new_PopularimeterFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
7430
+ TagLib::ByteVector *arg1 = 0 ;
7431
+ TagLib::ByteVector tmp1 ;
7432
+ TagLib::ID3v2::PopularimeterFrame *result = 0 ;
7433
+
7434
+ if ((argc < 1) || (argc > 1)) {
7435
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7436
+ }
7437
+ {
7438
+ tmp1 = ruby_string_to_taglib_bytevector(argv[0]);
7439
+ arg1 = &tmp1;
7440
+ }
7441
+ result = (TagLib::ID3v2::PopularimeterFrame *)new TagLib::ID3v2::PopularimeterFrame((TagLib::ByteVector const &)*arg1);
7442
+ DATA_PTR(self) = result;
7443
+ SWIG_RubyAddTracking(result, self);
7444
+ return self;
7445
+ fail:
7446
+ return Qnil;
7447
+ }
7448
+
7449
+
7450
+ SWIGINTERN VALUE _wrap_new_PopularimeterFrame(int nargs, VALUE *args, VALUE self) {
7451
+ int argc;
7452
+ VALUE argv[1];
7453
+ int ii;
7454
+
7455
+ argc = nargs;
7456
+ if (argc > 1) SWIG_fail;
7457
+ for (ii = 0; (ii < argc); ++ii) {
7458
+ argv[ii] = args[ii];
7459
+ }
7460
+ if (argc == 0) {
7461
+ return _wrap_new_PopularimeterFrame__SWIG_0(nargs, args, self);
7462
+ }
7463
+ if (argc == 1) {
7464
+ int _v;
7465
+ int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
7466
+ _v = SWIG_CheckState(res);
7467
+ if (_v) {
7468
+ return _wrap_new_PopularimeterFrame__SWIG_1(nargs, args, self);
7469
+ }
7470
+ }
7471
+
7472
+ fail:
7473
+ Ruby_Format_OverloadedError( argc, 1, "PopularimeterFrame.new",
7474
+ " PopularimeterFrame.new()\n"
7475
+ " PopularimeterFrame.new(TagLib::ByteVector const &data)\n");
7476
+
7477
+ return Qnil;
7478
+ }
7479
+
7480
+
7481
+ SWIGINTERN void
7482
+ free_TagLib_ID3v2_PopularimeterFrame(TagLib::ID3v2::PopularimeterFrame *arg1) {
7483
+ SWIG_RubyRemoveTracking(arg1);
7484
+ delete arg1;
7485
+ }
7486
+
7487
+ SWIGINTERN VALUE
7488
+ _wrap_PopularimeterFrame_to_string(int argc, VALUE *argv, VALUE self) {
7489
+ TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
7490
+ void *argp1 = 0 ;
7491
+ int res1 = 0 ;
7492
+ TagLib::String result;
7493
+ VALUE vresult = Qnil;
7494
+
7495
+ if ((argc < 0) || (argc > 0)) {
7496
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7497
+ }
7498
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 | 0 );
7499
+ if (!SWIG_IsOK(res1)) {
7500
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame const *","toString", 1, self ));
7501
+ }
7502
+ arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
7503
+ result = ((TagLib::ID3v2::PopularimeterFrame const *)arg1)->toString();
7504
+ {
7505
+ vresult = taglib_string_to_ruby_string(result);
7506
+ }
7507
+ return vresult;
7508
+ fail:
7509
+ return Qnil;
7510
+ }
7511
+
7512
+
7513
+ SWIGINTERN VALUE
7514
+ _wrap_PopularimeterFrame_email(int argc, VALUE *argv, VALUE self) {
7515
+ TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
7516
+ void *argp1 = 0 ;
7517
+ int res1 = 0 ;
7518
+ TagLib::String result;
7519
+ VALUE vresult = Qnil;
7520
+
7521
+ if ((argc < 0) || (argc > 0)) {
7522
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7523
+ }
7524
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 | 0 );
7525
+ if (!SWIG_IsOK(res1)) {
7526
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame const *","email", 1, self ));
7527
+ }
7528
+ arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
7529
+ result = ((TagLib::ID3v2::PopularimeterFrame const *)arg1)->email();
7530
+ {
7531
+ vresult = taglib_string_to_ruby_string(result);
7532
+ }
7533
+ return vresult;
7534
+ fail:
7535
+ return Qnil;
7536
+ }
7537
+
7538
+
7539
+ SWIGINTERN VALUE
7540
+ _wrap_PopularimeterFrame_emaile___(int argc, VALUE *argv, VALUE self) {
7541
+ TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
7542
+ TagLib::String *arg2 = 0 ;
7543
+ void *argp1 = 0 ;
7544
+ int res1 = 0 ;
7545
+ TagLib::String tmp2 ;
7546
+
7547
+ if ((argc < 1) || (argc > 1)) {
7548
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7549
+ }
7550
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 | 0 );
7551
+ if (!SWIG_IsOK(res1)) {
7552
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame *","setEmail", 1, self ));
7553
+ }
7554
+ arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
7555
+ {
7556
+ tmp2 = ruby_string_to_taglib_string(argv[0]);
7557
+ arg2 = &tmp2;
7558
+ }
7559
+ (arg1)->setEmail((TagLib::String const &)*arg2);
7560
+ return Qnil;
7561
+ fail:
7562
+ return Qnil;
7563
+ }
7564
+
7565
+
7566
+ SWIGINTERN VALUE
7567
+ _wrap_PopularimeterFrame_rating(int argc, VALUE *argv, VALUE self) {
7568
+ TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
7569
+ void *argp1 = 0 ;
7570
+ int res1 = 0 ;
7571
+ int result;
7572
+ VALUE vresult = Qnil;
7573
+
7574
+ if ((argc < 0) || (argc > 0)) {
7575
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7576
+ }
7577
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 | 0 );
7578
+ if (!SWIG_IsOK(res1)) {
7579
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame const *","rating", 1, self ));
7580
+ }
7581
+ arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
7582
+ result = (int)((TagLib::ID3v2::PopularimeterFrame const *)arg1)->rating();
7583
+ vresult = SWIG_From_int(static_cast< int >(result));
7584
+ return vresult;
7585
+ fail:
7586
+ return Qnil;
7587
+ }
7588
+
7589
+
7590
+ SWIGINTERN VALUE
7591
+ _wrap_PopularimeterFrame_ratinge___(int argc, VALUE *argv, VALUE self) {
7592
+ TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
7593
+ int arg2 ;
7594
+ void *argp1 = 0 ;
7595
+ int res1 = 0 ;
7596
+ int val2 ;
7597
+ int ecode2 = 0 ;
7598
+
7599
+ if ((argc < 1) || (argc > 1)) {
7600
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7601
+ }
7602
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 | 0 );
7603
+ if (!SWIG_IsOK(res1)) {
7604
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TagLib::ID3v2::PopularimeterFrame *","setRating", 1, self ));
7605
+ }
7606
+ arg1 = reinterpret_cast< TagLib::ID3v2::PopularimeterFrame * >(argp1);
7607
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7608
+ if (!SWIG_IsOK(ecode2)) {
7609
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setRating", 2, argv[0] ));
7610
+ }
7611
+ arg2 = static_cast< int >(val2);
7612
+ (arg1)->setRating(arg2);
7613
+ return Qnil;
7614
+ fail:
7615
+ return Qnil;
7616
+ }
7617
+
7618
+
7619
+ SWIGINTERN VALUE
7620
+ _wrap_PopularimeterFrame_counter(int argc, VALUE *argv, VALUE self) {
7621
+ TagLib::ID3v2::PopularimeterFrame *arg1 = (TagLib::ID3v2::PopularimeterFrame *) 0 ;
7622
+ void *argp1 = 0 ;
7623
+ int res1 = 0 ;
7624
+ unsigned int result;
7625
+ VALUE vresult = Qnil;
7626
+
7627
+ if ((argc < 0) || (argc > 0)) {
7628
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7629
+ }
7630
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TagLib__ID3v2__PopularimeterFrame, 0 | 0 );
7631
+ if (!SWIG_IsOK(res1)) {
7632