Constructor for UserTextIdentificationFrame not working has expected

[jameswyper]

I'm trying to create id3v2 tags with UserTextIdentificationFrames. The documentation says that the constructor for this frame type is inherited from TextIdentificationFrame. However,

userframe = TagLib::ID3v2::UserTextIdentificationFrame.new("UserFrame",TagLib::String::UTF8)

results in

Uncaught exception: Wrong arguments for overloaded method 'UserTextIdentificationFrame.new'.
Possible C/C++ prototypes are:
    UserTextIdentificationFrame.new(TagLib::String::Type encoding)
    UserTextIdentificationFrame.new()
    UserTextIdentificationFrame.new(TagLib::ByteVector const &data)
    UserTextIdentificationFrame.new(TagLib::String const &description, TagLib::StringList const &values, TagLib::String::Type encoding)
    UserTextIdentificationFrame.new(TagLib::String const &description, TagLib::StringList const &values)

From the error message I'd expect a constructor of the form

userframe = TagLib::ID3v2::UserTextIdentificationFrame.new("UserFrame",["Some User Text"],TagLib::String::UTF8)

to work, but that gives the same error.

userframe = TagLib::ID3v2::UserTextIdentificationFrame.new(TagLib::String::UTF8)
userframe.description = "UserFrame"
userframe.text = "Some User Text"

appears to work.

Glancing at the taglib source code I think that the constructor for UserTextIdentificationFrame genuinely is different to TextIdentificationFrame (so I believe the documentation isn't correct) but I don't understand why at least one of the correct forms reported by the error message doesn't work. I'm not ruling out my own ignorance, so I'd appreciate any guidance. Thanks.

[jacobvosmaer]

It appears SWIG uses some heuristics to decide which C++ constructor to call. The best advice I can give is to try and understand how those heuristics work and adjust your Ruby call accordingly.

taglib-ruby/ext/taglib_id3v2/taglib_id3v2_wrap.cxx

Lines 9190 to 9263 in dc7858f

	SWIGINTERN VALUE _wrap_new_UserTextIdentificationFrame(int nargs, VALUE *args, VALUE self) {
	int argc;
	VALUE argv[3];
	int ii;
	argc = nargs;
	if (argc > 3) SWIG_fail;
	for (ii = 0; (ii < argc); ++ii) {
	argv[ii] = args[ii];
	}
	if (argc == 0) {
	return _wrap_new_UserTextIdentificationFrame__SWIG_1(nargs, args, self);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_UserTextIdentificationFrame__SWIG_0(nargs, args, self);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_UserTextIdentificationFrame__SWIG_2(nargs, args, self);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__StringList, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_UserTextIdentificationFrame__SWIG_4(nargs, args, self);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_TagLib__StringList, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_UserTextIdentificationFrame__SWIG_3(nargs, args, self);
	}
	}
	}
	}
	fail:
	Ruby_Format_OverloadedError( argc, 3, "UserTextIdentificationFrame.new",
	" UserTextIdentificationFrame.new(TagLib::String::Type encoding)\n"
	" UserTextIdentificationFrame.new()\n"
	" UserTextIdentificationFrame.new(TagLib::ByteVector const &data)\n"
	" UserTextIdentificationFrame.new(TagLib::String const &description, TagLib::StringList const &values, TagLib::String::Type encoding)\n"
	" UserTextIdentificationFrame.new(TagLib::String const &description, TagLib::StringList const &values)\n");
	return Qnil;
	}

But that error message already gives you an overview of the options.

As you can see in the link, SWIG looks at the number of Ruby arguments and their types in a fixed order and if anything matches, it calls the corresponding C++ constructor. If nothing matches you get the error.

First it looks if there is exactly one argument and if it can be coerced to an integer. If so it uses the first mentioned constructor. Then it checks if there are zero arguments, and if so it uses the second constructor. Etc. It starts from zero but the idea is the same.

[robinst]

Hey @jameswyper, I revisited this and found a fix, see here: #120

[robinst]

Released the fix with version 1.1.2 now.