PPCODE results from the CPAN

PPCODE

Audio-TagLib

view release on metacpan or search on metacpan

	RETVAL

void 
_NAMESPACE_::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
_NAMESPACE_::data()
PPCODE:
!!!!USEPAIR
	/* iterator for Map */
	_T_ & data = (*THIS)->second;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_T_", (void *)&data);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);
!!!!USEWCHAR
	/* iterator for String */
	wchar_t & data = **THIS;

xs/TITERATOR.xs view on Meta::CPAN

!!!!USELIST
	/* iterator for List */
	_T_ * data = **THIS;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_T_", (void *)data);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
_NAMESPACE_::next()
PPCODE:
	_NAMESPACE_ & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_NAMESPACE_", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
_NAMESPACE_::last()
PPCODE:
	_NAMESPACE_ & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_NAMESPACE_", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
_NAMESPACE_::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::_NAMESPACE_", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
_NAMESPACE_::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::_NAMESPACE_", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/TITERATOR.xs view on Meta::CPAN

_NAMESPACE_::greatEqual(i)
	_NAMESPACE_ * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
_NAMESPACE_::copy(i)
	_NAMESPACE_ * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

xs/TLIST.xs view on Meta::CPAN

	RETVAL

void 
_NAMESPACE_::erase(it)
	_NAMESPACE_::Iterator * it
CODE:
	THIS->erase(*it);

void 
_NAMESPACE_::front()
PPCODE:
	_T_ * item = THIS->front();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_T_", (void *)item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
_NAMESPACE_::back()
PPCODE:
	_T_ * item = THIS->back();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_T_", (void *)item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & front() const
# const T & back() const

xs/TLIST.xs view on Meta::CPAN


void 
_NAMESPACE_::setAutoDelete(autoDelete)
	bool autoDelete
CODE:
	THIS->setAutoDelete(autoDelete);

void 
_NAMESPACE_::getItem(i)
	unsigned int i
PPCODE:
	_T_ * item = THIS->operator[](i);
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_T_", (void *)item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & operator[](uint i) const
# not exported
# 
################################################################

void  
_NAMESPACE_::copy(l)
	_NAMESPACE_ * l
PPCODE:
	(void)THIS->operator=(*l);
	XSRETURN(1);

bool 
_NAMESPACE_::equals(l)
	_NAMESPACE_ * l
CODE:
	RETVAL = THIS->operator==(*l);
OUTPUT:
	RETVAL

xs/TLIST.xs view on Meta::CPAN

# SPECIAL FUNCTIONS for TIE MAGIC
# 
################################################################

static void 
_NAMESPACE_::TIEARRAY(...)
PROTOTYPE: ;$
PREINIT:
	_NAMESPACE_ * l;
	_NAMESPACE_ * list;
PPCODE:
	/*!
	 * tie @a, "_NAMESPACE_"
	 * tie @a, "_NAMESPACE_", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::_NAMESPACE_")) {
			if(SvREADONLY(SvRV(ST(1)))){
				/* READONLY on, create a new SV */

xs/TLIST.xs view on Meta::CPAN

		/* items == 1 */
		list = new _NAMESPACE_();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::_NAMESPACE_", (void *)list);
	}
	XSRETURN(1);

void 
_NAMESPACE_::FETCH(index)
	unsigned int index
PPCODE:
	if(0 <= index && index < THIS->size()) {
		ST(0) = sv_newmortal();
		_T_ * item = THIS->operator[](index);
		sv_setref_pv(ST(0), "Audio::_T_", (void *)item);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void

xs/TLIST.xs view on Meta::CPAN

		THIS->erase(it);
	}

void 
_NAMESPACE_::CLEAR()
CODE:
	THIS->clear();

void 
_NAMESPACE_::PUSH(...)
PPCODE:
	if(items > 1) {
		/* ensure all items are of type _T_/_NAMESPACE_ before pushing */
		for(int i = 1; i < items; i++) {
			if(!(sv_isobject(ST(i)) && sv_derived_from(ST(i), "Audio::_T_") || 
				sv_derived_from(ST(i), "Audio::_NAMESPACE_")))
				croak("ST(i) is not of type Audio::_T_/_NAMESPACE_");
		}
		for(int i = 1; i < items; i++) {
			if(sv_derived_from(ST(i), "Audio::_T_"))
				(void)THIS->append(INT2PTR(_T_ *, SvIV(SvRV(ST(i)))));

xs/TLIST.xs view on Meta::CPAN

# 
# POPed & SHIFTed item will ALWAYS be marks as READONLY
# which means it is only a reference
# NEVER takes charge of performing delete action
# 
################################################################
void 
_NAMESPACE_::POP()
PREINIT:
	_NAMESPACE_::Iterator it;
PPCODE:
	if(!THIS->isEmpty()) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::_T_", (void *)THIS->back());
		SvREADONLY_on(SvRV(ST(0)));
		it = THIS->end();
		THIS->erase(--it);
		XSRETURN(1);
	} else
		XSRETURN_UNDEF; 

void 
_NAMESPACE_::SHIFT()
PPCODE:
	if(!THIS->isEmpty()) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::_T_", (void *)THIS->front());
		SvREADONLY_on(SvRV(ST(0)));
		THIS->erase(THIS->begin());
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
_NAMESPACE_::UNSHIFT(...)
PPCODE:
	if(items > 1) {
		/* ensure all items are of type _T_/_NAMESPACE_ firstly */
		for(int i = 1; i < items; i++) {
			if(!(sv_isobject(ST(i)) && sv_derived_from(ST(i), "Audio::_T_") || 
				sv_derived_from(ST(i), "Audio::_NAMESPACE_")))
				croak("ST(i) is not of type _T_/_NAMESPACE_");
		}
		for(int i = items - 1; i > 0; i--) {
			if(sv_derived_from(ST(i), "Audio::_T_"))
				(void)THIS->append(INT2PTR(_T_ *, SvIV(SvRV(ST(i)))));

xs/TLIST.xs view on Meta::CPAN


void 
_NAMESPACE_::SPLICE(...)
PROTOTYPE: $;$@
PREINIT:
	unsigned int offset;
	unsigned int length;
	_NAMESPACE_::Iterator it, it_next;
	_NAMESPACE_ * obj;
	_T_ * item;
PPCODE:
	switch(items) {
	case 2:
		/* splice(offset, length=$#this-offset+1) */
		if(SvIOK(ST(1)) || SvUOK(ST(1)))
			offset = SvUV(ST(1));
		else
			croak("ST(1) is not of type uint");
		length = THIS->size() - offset;
		break;
	case 3:

xs/TMAP.xs view on Meta::CPAN

	_KEY_ * key
CODE:
	if(THIS->contains(*key))
		THIS->erase(THIS->find(*key));

void 
_NAMESPACE_::getItem(key)
	_KEY_ * key
INIT:
	_T_ & item = THIS->operator[](*key);
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_T_", (void *)&item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & operator[](const Key &key) const
# not exported
#

xs/TMAP.xs view on Meta::CPAN

################################################################
# 
# Map<Key, T> & operator=(const Map<Key, T> &m)
# not exported
# 
################################################################

void 
_NAMESPACE_::copy(m)
	_NAMESPACE_ * m
PPCODE:
	(void)THIS->operator=(*m);
	/* return ST(0) */
	XSRETURN(1);

################################################################
# 
# PROTECTED MEMBER FUNCTIONS
# 
# void detach()
# not exported

xs/TMAP.xs view on Meta::CPAN

# 
# SPECIAL FUNCTIONS FOR TIE MAGIC
# 
################################################################

static void  
_NAMESPACE_::TIEHASH(...)
PROTOTYPE: ;$
PREINIT:
	_NAMESPACE_ * map;
PPCODE:
	/*! 
	 * tie %h, "_NAMESPACE_"
	 * tie %h, "_NAMESPACE_", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::_NAMESPACE_")) {
			if(SvREADONLY(SvRV(ST(1)))){
				ST(0) = sv_newmortal();

xs/TMAP.xs view on Meta::CPAN

		/* items == 1 */
		map = new _NAMESPACE_();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::_NAMESPACE_", (void *)map);
	}
	XSRETURN(1);

void 
_NAMESPACE_::FETCH(key)
	_KEY_ * key
PPCODE:
	/*!
	 * this will NOT copy the value
	 * just return the reference
	 */
	if(THIS->contains(*key)) {
		_T_ & value = THIS->operator[](*key);
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::_T_", (void *)&value);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);

xs/TMAP.xs view on Meta::CPAN

	_KEY_ * key
CODE:
	RETVAL = THIS->contains(*key);
OUTPUT:
	RETVAL

void 
_NAMESPACE_::FIRSTKEY()
PREINIT:
	_NAMESPACE_::Iterator it;
PPCODE:
	if(THIS->isEmpty())
		XSRETURN_UNDEF;
	it = THIS->begin();
	/* (**it) is a std::pair<const _KEY_, _T_> */
	const _KEY_ & key = it->first;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::_KEY_", (void *)&key);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

xs/apeitem.xs view on Meta::CPAN


################################################################
# 
# implement
# Item & operator=(const Item &item)
# 
################################################################
void 
TagLib::APE::Item::copy(item)
	TagLib::APE::Item * item
PPCODE:
	(void)THIS->operator=(*item);
	XSRETURN(1);

TagLib::String * 
TagLib::APE::Item::key()
CODE:
	RETVAL = new TagLib::String(THIS->key());
OUTPUT:
	RETVAL

xs/apeitemlistmap.xs view on Meta::CPAN

	TagLib::String * key
CODE:
	if(THIS->contains(*key))
		THIS->erase(THIS->find(*key));

void 
TagLib::APE::ItemListMap::getItem(key)
	TagLib::String * key
INIT:
	TagLib::APE::Item & item = THIS->operator[](*key);
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::APE::Item", (void *)&item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & operator[](const Key &key) const
# not exported
#

xs/apeitemlistmap.xs view on Meta::CPAN

################################################################
# 
# Map<Key, T> & operator=(const Map<Key, T> &m)
# not exported
# 
################################################################

void 
TagLib::APE::ItemListMap::copy(m)
	TagLib::APE::ItemListMap * m
PPCODE:
	(void)THIS->operator=(*m);
	/* return ST(0) */
	XSRETURN(1);

################################################################
# 
# PROTECTED MEMBER FUNCTIONS
# 
# void detach()
# not exported

xs/apeitemlistmap.xs view on Meta::CPAN

# 
# SPECIAL FUNCTIONS FOR TIE MAGIC
# 
################################################################

static void  
TagLib::APE::ItemListMap::TIEHASH(...)
PROTOTYPE: ;$
PREINIT:
	TagLib::APE::ItemListMap * map;
PPCODE:
	/*! 
	 * tie %h, "TagLib::APE::ItemListMap"
	 * tie %h, "TagLib::APE::ItemListMap", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::TagLib::APE::ItemListMap")) {
			if(SvREADONLY(SvRV(ST(1)))){
				ST(0) = sv_newmortal();

xs/apeitemlistmap.xs view on Meta::CPAN

		/* items == 1 */
		map = new TagLib::APE::ItemListMap();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::APE::ItemListMap", (void *)map);
	}
	XSRETURN(1);

void 
TagLib::APE::ItemListMap::FETCH(key)
	TagLib::String * key
PPCODE:
	/*!
	 * this will NOT copy the value
	 * just return the reference
	 */
	if(THIS->contains(*key)) {
		TagLib::APE::Item & value = THIS->operator[](*key);
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::APE::Item", (void *)&value);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);

xs/apeitemlistmap.xs view on Meta::CPAN

	TagLib::String * key
CODE:
	RETVAL = THIS->contains(*key);
OUTPUT:
	RETVAL

void 
TagLib::APE::ItemListMap::FIRSTKEY()
PREINIT:
	TagLib::APE::ItemListMap::Iterator it;
PPCODE:
	if(THIS->isEmpty())
		XSRETURN_UNDEF;
	it = THIS->begin();
	/* (**it) is a std::pair<const TagLib::String, TagLib::APE::Item> */
	const TagLib::String & key = it->first;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::String", (void *)&key);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

xs/apeitemlistmapiterator.xs view on Meta::CPAN

	RETVAL

void 
TagLib::APE::ItemListMap::Iterator::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::APE::ItemListMap::Iterator::data()
PPCODE:
//USEPAIR
	/* iterator for Map */
	TagLib::APE::Item & data = (*THIS)->second;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::APE::Item", (void *)&data);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::APE::ItemListMap::Iterator::next()
PPCODE:
	TagLib::APE::ItemListMap::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::APE::ItemListMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::APE::ItemListMap::Iterator::last()
PPCODE:
	TagLib::APE::ItemListMap::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::APE::ItemListMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::APE::ItemListMap::Iterator::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::APE::ItemListMap::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::APE::ItemListMap::Iterator::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::APE::ItemListMap::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/apeitemlistmapiterator.xs view on Meta::CPAN

TagLib::APE::ItemListMap::Iterator::greatEqual(i)
	TagLib::APE::ItemListMap::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::APE::ItemListMap::Iterator::copy(i)
	TagLib::APE::ItemListMap::Iterator * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

xs/apetag.xs view on Meta::CPAN

void 
TagLib::APE::Tag::setTrack(i)
	unsigned int i
CODE:
	THIS->setTrack(i);

void 
TagLib::APE::Tag::footer()
PREINIT:
	TagLib::APE::Footer * f;
PPCODE:
	f = THIS->footer();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::APE::Footer", (void *)f);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::APE::Tag::itemListMap()
PREINIT:
	SV * refobj, * refhash;
	HV * hash;
INIT:
	const TagLib::APE::ItemListMap & map = THIS->itemListMap();
PPCODE:
    /*
	refobj = sv_newmortal();
	sv_setref_pv(refobj, "Audio::TagLib::APE::ItemListMap", (void *)&map);
	SvREADONLY_on(SvRV(refobj));
	hash = newHV();
	hv_magic(hash, (GV *)refobj, PERL_MAGIC_tied);
	refhash = newRV_noinc((SV *)hash);
	ST(0) = sv_2mortal(refhash);
	XSRETURN(1);
	*/

xs/bytevectoriterator.xs view on Meta::CPAN

	RETVAL

void 
TagLib::ByteVector::Iterator::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::ByteVector::Iterator::data()
PPCODE:
//USECHAR
	/* iterator for ByteVector */
	char data = **THIS;
	ST(0) = sv_2mortal(newSVpvn(&data, 1));
	XSRETURN(1);

void 
TagLib::ByteVector::Iterator::next()
PPCODE:
	TagLib::ByteVector::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ByteVector::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::ByteVector::Iterator::last()
PPCODE:
	TagLib::ByteVector::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ByteVector::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::ByteVector::Iterator::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::ByteVector::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ByteVector::Iterator::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::ByteVector::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/bytevectoriterator.xs view on Meta::CPAN

TagLib::ByteVector::Iterator::greatEqual(i)
	TagLib::ByteVector::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::ByteVector::Iterator::copy(i)
	TagLib::ByteVector::Iterator * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

#undef LONGMOVEMENT

xs/fileref.xs view on Meta::CPAN

void 
TagLib::FileRef::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

SV * 
TagLib::FileRef::tag()
PREINIT:
	TagLib::Tag * t;
PPCODE:
	/*! 
	 * the returned Tag object is owned by THIS object
	 * thus set READONLY on to skip the destructor
	 * refer to TagLib::Tag::DESTROY for detail 
	 */
	t = THIS->tag();
	if(t != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Tag", (void*)t);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

SV * 
TagLib::FileRef::audioProperties()
PREINIT:
	TagLib::AudioProperties * p;
PPCODE:
	/*!
	 * the returned AudioProperties object is owned by THIS object 
	 * thus set READONLY on to skip the destructor
	 * refer to TagLib::AudioProperties::DESTROY for detail  
	 */
	p = THIS->audioProperties();
	if(p != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::AudioProperties", (void*)p);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

SV * 
TagLib::FileRef::file()
PREINIT:
	TagLib::File * f;
PPCODE:
	/*!
	 * the returned File object is owned by THIS object 
	 * thus set READONLY on to skip the destructor 
	 * refer to TagLib::File::DESTROY for detail 
	 */
	f = THIS->file();
	if(f != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::File", (void*)f);
		SvREADONLY_on(SvRV(ST(0)));

xs/fileref.xs view on Meta::CPAN

bool 
TagLib::FileRef::isNull()
CODE:
	RETVAL = THIS->isNull();
OUTPUT:
	RETVAL

void 
TagLib::FileRef::copy(ref)
	TagLib::FileRef * ref
PPCODE:
	(void)THIS->operator=(*ref);
	XSRETURN(1);

bool 
TagLib::FileRef::_equal(ref, swap=NULL)
	TagLib::FileRef * ref
	char * swap
CODE:
	RETVAL = THIS->operator==(*ref);
OUTPUT:

xs/fileref.xs view on Meta::CPAN

# 
################################################################

void 
TagLib::FileRef::FileTypeResolver::createFile(fileName, readAudioProperties=true, style=TagLib::AudioProperties::Average)
	const char * fileName
	bool readAudioProperties
	TagLib::AudioProperties::ReadStyle style
PREINIT:
	TagLib::File * file;
PPCODE:
	file = THIS->createFile(fileName, readAudioProperties, style);
	if(file != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::File", (void *)file);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

xs/flacfile.xs view on Meta::CPAN

void 
TagLib::FLAC::File::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::FLAC::File::tag()
INIT:
	TagLib::Tag * tag = THIS->tag();
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::FLAC::File::audioProperties()
INIT:
	TagLib::AudioProperties * p = THIS->audioProperties();
PPCODE:
	if(p != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::FLAC::Properties", (void *)p);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

bool 
TagLib::FLAC::File::save()
CODE:
	RETVAL = THIS->save();
OUTPUT:
	RETVAL

void 
TagLib::FLAC::File::ID3v2Tag(create=false)
	bool create
INIT:
	TagLib::ID3v2::Tag * tag = THIS->ID3v2Tag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::FLAC::File::ID3v1Tag(create=false)
	bool create
INIT:
	TagLib::ID3v1::Tag * tag = THIS->ID3v1Tag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::FLAC::File::xiphComment(create=false)
	bool create
INIT:
	TagLib::Ogg::XiphComment * xc = THIS->xiphComment(create);
PPCODE:
	if(xc != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Ogg::XiphComment", (void *)xc);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::FLAC::File::setID3v2FrameFactory(factory)

xs/id3v1genremap.xs view on Meta::CPAN

################################################################
# 
# Map<Key, T> & operator=(const Map<Key, T> &m)
# not exported
# 
################################################################

void 
TagLib::ID3v1::GenreMap::copy(m)
	TagLib::ID3v1::GenreMap * m
PPCODE:
	(void)THIS->operator=(*m);
	XSRETURN(1);

################################################################
# 
# PROTECTED MEMBER FUNCTIONS
# 
# void detach()
# not exported
#

xs/id3v1genremap.xs view on Meta::CPAN

# SPECIAL FUNCTIONS FOR TIE MAGIC
# 
################################################################

static void  
TagLib::ID3v1::GenreMap::TIEHASH(...)
PROTOTYPE: ;$
PREINIT:
	SV * refobj;
	TagLib::ID3v1::GenreMap * map;
PPCODE:
	/*! 
	 * tie %h, "Audio::TagLib::ID3v1::GenreMap"
	 * tie %h, "Audio::TagLib::ID3v1::GenreMap", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::TagLib::ID3v1::GenreMap")) {
			refobj = newRV_inc(SvRV(ST(1)));
		} else

xs/id3v1genremap.xs view on Meta::CPAN

	}
	sv_bless(refobj, gv_stashpv("Audio::TagLib::ID3v1::GenreMap", TRUE));
	ST(0) = refobj;
	XSRETURN(1);

void 
TagLib::ID3v1::GenreMap::FETCH(key)
	TagLib::String * key
PREINIT:
	int value;
PPCODE:
	if(THIS->contains(*key)) {
		value = THIS->operator[](*key);
		ST(0) = sv_2mortal(newSViv(value));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::ID3v1::GenreMap::STORE(key, value)
	TagLib::String * key

xs/id3v1genremap.xs view on Meta::CPAN

	TagLib::String * key
CODE:
	RETVAL = THIS->contains(*key);
OUTPUT:
	RETVAL

void 
TagLib::ID3v1::GenreMap::FIRSTKEY()
PREINIT:
	TagLib::ID3v1::GenreMap::Iterator it;
PPCODE:
	if(THIS->isEmpty())
		XSRETURN_UNDEF;
	it = THIS->begin();
	/* (**it) is a std::pair<const TagLib::String, int> */
	const TagLib::String & key = it->first;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::String", (void *)&key);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

xs/id3v1genremapiterator.xs view on Meta::CPAN

int 
TagLib::ID3v1::GenreMap::Iterator::data()
CODE:
	/* iterator for Map & List */
	RETVAL = (*THIS)->second;
OUTPUT:
	RETVAL

void 
TagLib::ID3v1::GenreMap::Iterator::next()
PPCODE:
	TagLib::ID3v1::GenreMap::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::GenreMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::ID3v1::GenreMap::Iterator::last()
PPCODE:
	TagLib::ID3v1::GenreMap::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::GenreMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::ID3v1::GenreMap::Iterator::forward(n)
	int n
PPCODE:
	TagLib::ID3v1::GenreMap::Iterator & i = THIS->operator+=(n);
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::GenreMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v1::GenreMap::Iterator::backward(n)
	int n
PPCODE:
	TagLib::ID3v1::GenreMap::Iterator & i = THIS->operator-=(n);
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::GenreMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#undef MOREMETHODS
#ifdef MOREMETHODS

xs/id3v1genremapiterator.xs view on Meta::CPAN

TagLib::ID3v1::GenreMap::Iterator::greatEqual(i)
	TagLib::ID3v1::GenreMap::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::ID3v1::GenreMap::Iterator::_copy(it)
	TagLib::ID3v1::GenreMap::Iterator * it
PPCODE:
	(void)THIS->operator=(*it);
	XSRETURN(1);

#endif /* MOREMETHODS */

xs/id3v2relativevolumeframe.xs view on Meta::CPAN

	RETVAL = new TagLib::String(THIS->toString());
OUTPUT:
	RETVAL

# List< ChannelType > 	channels () const 
void 
TagLib::ID3v2::RelativeVolumeFrame::channels()
INIT:
	TagLib::List<TagLib::ID3v2::RelativeVolumeFrame::ChannelType> 
		l = THIS->channels();
PPCODE:
	switch(GIMME_V) {
	case G_SCALAR:
		ST(0) = sv_2mortal(newSVuv(l.size()));
		XSRETURN(1);
	case G_ARRAY:
		if(l.size() != 0) {
            /* Make room on the stack */
			EXTEND(SP, l.size());
			for(int i = 0; i < l.size(); i++) {
				switch(l[i]) {

xs/id3v2relativevolumeframe.xs view on Meta::CPAN

void 
TagLib::ID3v2::RelativeVolumeFrame::PeakVolume::setBitsRepresentingPeak(c)
	unsigned char c
CODE:
	THIS->bitsRepresentingPeak = c;

void 
TagLib::ID3v2::RelativeVolumeFrame::PeakVolume::peakVolume()
INIT:
	TagLib::ByteVector & pv = THIS->peakVolume;
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ByteVector", (void *)&pv);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# new member function
# exported for setting peakVolume
#

xs/id3v2tag.xs view on Meta::CPAN

TagLib::ID3v2::Tag::isEmpty()
CODE:
	RETVAL = THIS->isEmpty();
OUTPUT:
	RETVAL

void 
TagLib::ID3v2::Tag::header()
PREINIT:
	TagLib::ID3v2::Header * h;
PPCODE:
	h = THIS->header();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Header", (void *)h);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::Tag::extendedHeader()
PREINIT:
	TagLib::ID3v2::ExtendedHeader * eh;
PPCODE:
	eh = THIS->extendedHeader();
	if(eh != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::ExtendedHeader", 
			(void *)eh);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::ID3v2::Tag::footer()
PREINIT:
TagLib::ID3v2::Footer * f;
PPCODE:
	f = THIS->footer();
	if(f != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Footer", (void *)f);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::ID3v2::Tag::frameListMap()
PPCODE:
	const TagLib::ID3v2::FrameListMap & map = THIS->frameListMap();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameListMap", (void *)&map);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::Tag::frameList(...)
PROTOTYPE: ;$
PPCODE:
	switch(items) {
	case 2:
		/* const FrameList & frameList(const ByteVector &frameID) 
		 * const 
		 */
		if(sv_isobject(ST(1)) && sv_derived_from(ST(1), 
			"Audio::TagLib::ByteVector")) {
		const TagLib::ID3v2::FrameList & list = THIS->frameList(
			*INT2PTR(TagLib::ByteVector *, SvIV(SvRV(ST(1)))));
		ST(0) = sv_newmortal();

xs/id3v2tag.xs view on Meta::CPAN

		const TagLib::ID3v2::FrameList & list2 = THIS->frameList();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList", (void *)&list2);
	}
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::Tag::addFrame(frame)
	TagLib::ID3v2::Frame * frame
PPCODE:
	THIS->addFrame(frame);
	SvREADONLY_on(SvRV(ST(1)));
    XSRETURN_UNDEF;

void 
TagLib::ID3v2::Tag::removeFrame(frame, del=true)
	TagLib::ID3v2::Frame * frame
	bool del
CODE:
	THIS->removeFrame(frame, del);

xs/id3v2tagframelist.xs view on Meta::CPAN

	RETVAL

void 
TagLib::ID3v2::FrameList::erase(it)
	TagLib::ID3v2::FrameList::Iterator * it
CODE:
	THIS->erase(*it);

void 
TagLib::ID3v2::FrameList::front()
PPCODE:
	TagLib::ID3v2::Frame * item = THIS->front();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::FrameList::back()
PPCODE:
	TagLib::ID3v2::Frame * item = THIS->back();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & front() const
# const T & back() const

xs/id3v2tagframelist.xs view on Meta::CPAN


void 
TagLib::ID3v2::FrameList::setAutoDelete(autoDelete)
	bool autoDelete
CODE:
	THIS->setAutoDelete(autoDelete);

void 
TagLib::ID3v2::FrameList::getItem(i)
	unsigned int i
PPCODE:
	TagLib::ID3v2::Frame * item = THIS->operator[](i);
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & operator[](uint i) const
# not exported
# 
################################################################

void  
TagLib::ID3v2::FrameList::copy(l)
	TagLib::ID3v2::FrameList * l
PPCODE:
	(void)THIS->operator=(*l);
	XSRETURN(1);

bool 
TagLib::ID3v2::FrameList::equals(l)
	TagLib::ID3v2::FrameList * l
CODE:
	RETVAL = THIS->operator==(*l);
OUTPUT:
	RETVAL

xs/id3v2tagframelist.xs view on Meta::CPAN

# SPECIAL FUNCTIONS for TIE MAGIC
# 
################################################################

static void 
TagLib::ID3v2::FrameList::TIEARRAY(...)
PROTOTYPE: ;$
PREINIT:
	TagLib::ID3v2::FrameList * l;
	TagLib::ID3v2::FrameList * list;
PPCODE:
	/*!
	 * tie @a, "TagLib::ID3v2::FrameList"
	 * tie @a, "TagLib::ID3v2::FrameList", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::TagLib::ID3v2::FrameList")) {
			if(SvREADONLY(SvRV(ST(1)))){
				/* READONLY on, create a new SV */

xs/id3v2tagframelist.xs view on Meta::CPAN

		/* items == 1 */
		list = new TagLib::ID3v2::FrameList();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList", (void *)list);
	}
	XSRETURN(1);

void 
TagLib::ID3v2::FrameList::FETCH(index)
	unsigned int index
PPCODE:
	if(0 <= index && index < THIS->size()) {
		ST(0) = sv_newmortal();
		TagLib::ID3v2::Frame * item = THIS->operator[](index);
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)item);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void

xs/id3v2tagframelist.xs view on Meta::CPAN

		THIS->erase(it);
	}

void 
TagLib::ID3v2::FrameList::CLEAR()
CODE:
	THIS->clear();

void 
TagLib::ID3v2::FrameList::PUSH(...)
PPCODE:
	if(items > 1) {
		/* ensure all items are of type TagLib::ID3v2::Frame/TagLib::ID3v2::FrameList before pushing */
		for(int i = 1; i < items; i++) {
// GCL fixing gcc warning
//		if(!(sv_isobject(ST(i)) && sv_derived_from(ST(i), "Audio::TagLib::ID3v2::Frame") || 
//			sv_derived_from(ST(i), "Audio::TagLib::ID3v2::FrameList")))
			if(!((sv_isobject(ST(i)) && sv_derived_from(ST(i), "Audio::TagLib::ID3v2::Frame")) || 
				sv_derived_from(ST(i), "Audio::TagLib::ID3v2::FrameList")))
				croak("ST(i) is not of type Audio::TagLib::ID3v2::Frame/TagLib::ID3v2::FrameList");
		}

xs/id3v2tagframelist.xs view on Meta::CPAN

# 
# POPed & SHIFTed item will ALWAYS be marks as READONLY
# which means it is only a reference
# NEVER takes charge of performing delete action
# 
################################################################
void 
TagLib::ID3v2::FrameList::POP()
PREINIT:
	TagLib::ID3v2::FrameList::Iterator it;
PPCODE:
	if(!THIS->isEmpty()) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)THIS->back());
		SvREADONLY_on(SvRV(ST(0)));
		it = THIS->end();
		THIS->erase(--it);
		XSRETURN(1);
	} else
		XSRETURN_UNDEF; 

void 
TagLib::ID3v2::FrameList::SHIFT()
PPCODE:
	if(!THIS->isEmpty()) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)THIS->front());
		SvREADONLY_on(SvRV(ST(0)));
		THIS->erase(THIS->begin());
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::ID3v2::FrameList::UNSHIFT(...)
PPCODE:
	if(items > 1) {
		/* ensure all items are of type TagLib::ID3v2::Frame/TagLib::ID3v2::FrameList firstly */
		for(int i = 1; i < items; i++) {
// GCL fixing gcc warning
//		    if(!(sv_isobject(ST(i)) && sv_derived_from(ST(i), "Audio::TagLib::ID3v2::Frame")) || 
//			    sv_derived_from(ST(i), "Audio::TagLib::ID3v2::FrameList"))
			if((!((sv_isobject(ST(i)) &&
                sv_derived_from(ST(i), "Audio::TagLib::ID3v2::Frame"))) || 
				sv_derived_from(ST(i), "Audio::TagLib::ID3v2::FrameList")))
            croak("ST(i) is not of type TagLib::ID3v2::Frame/TagLib::ID3v2::FrameList");

xs/id3v2tagframelist.xs view on Meta::CPAN


void 
TagLib::ID3v2::FrameList::SPLICE(...)
PROTOTYPE: $;$@
PREINIT:
	unsigned int offset;
	unsigned int length;
	TagLib::ID3v2::FrameList::Iterator it, it_next;
	TagLib::ID3v2::FrameList * obj;
	TagLib::ID3v2::Frame * item;
PPCODE:
	switch(items) {
	case 2:
		/* splice(offset, length=$#this-offset+1) */
		if(SvIOK(ST(1)) || SvUOK(ST(1)))
			offset = SvUV(ST(1));
		else
			croak("ST(1) is not of type uint");
		length = THIS->size() - offset;
		break;
	case 3:

xs/id3v2tagframelistiterator.xs view on Meta::CPAN

	RETVAL

void 
TagLib::ID3v2::FrameList::Iterator::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::ID3v2::FrameList::Iterator::data()
PPCODE:
//USELIST
	/* iterator for List */
	TagLib::ID3v2::Frame * data = **THIS;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Frame", (void *)data);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);


void 
TagLib::ID3v2::FrameList::Iterator::next()
PPCODE:
	TagLib::ID3v2::FrameList::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::ID3v2::FrameList::Iterator::last()
PPCODE:
	TagLib::ID3v2::FrameList::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::ID3v2::FrameList::Iterator::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::FrameList::Iterator::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/id3v2tagframelistiterator.xs view on Meta::CPAN

TagLib::ID3v2::FrameList::Iterator::greatEqual(i)
	TagLib::ID3v2::FrameList::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::ID3v2::FrameList::Iterator::copy(i)
	TagLib::ID3v2::FrameList::Iterator * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

xs/id3v2tagframelistmap.xs view on Meta::CPAN

	TagLib::ByteVector * key
CODE:
	if(THIS->contains(*key))
		THIS->erase(THIS->find(*key));

void 
TagLib::ID3v2::FrameListMap::getItem(key)
	TagLib::ByteVector * key
INIT:
	TagLib::ID3v2::FrameList & item = THIS->operator[](*key);
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList", (void *)&item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & operator[](const Key &key) const
# not exported
#

xs/id3v2tagframelistmap.xs view on Meta::CPAN

################################################################
# 
# Map<Key, T> & operator=(const Map<Key, T> &m)
# not exported
# 
################################################################

void 
TagLib::ID3v2::FrameListMap::copy(m)
	TagLib::ID3v2::FrameListMap * m
PPCODE:
	(void)THIS->operator=(*m);
	/* return ST(0) */
	XSRETURN(1);

################################################################
# 
# PROTECTED MEMBER FUNCTIONS
# 
# void detach()
# not exported

xs/id3v2tagframelistmap.xs view on Meta::CPAN

# 
# SPECIAL FUNCTIONS FOR TIE MAGIC
# 
################################################################

static void  
TagLib::ID3v2::FrameListMap::TIEHASH(...)
PROTOTYPE: ;$
PREINIT:
	TagLib::ID3v2::FrameListMap * map;
PPCODE:
	/*! 
	 * tie %h, "TagLib::ID3v2::FrameListMap"
	 * tie %h, "TagLib::ID3v2::FrameListMap", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::TagLib::ID3v2::FrameListMap")) {
			if(SvREADONLY(SvRV(ST(1)))){
				ST(0) = sv_newmortal();

xs/id3v2tagframelistmap.xs view on Meta::CPAN

		/* items == 1 */
		map = new TagLib::ID3v2::FrameListMap();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameListMap", (void *)map);
	}
	XSRETURN(1);

void 
TagLib::ID3v2::FrameListMap::FETCH(key)
	TagLib::ByteVector * key
PPCODE:
	/*!
	 * this will NOT copy the value
	 * just return the reference
	 */
	if(THIS->contains(*key)) {
		TagLib::ID3v2::FrameList & value = THIS->operator[](*key);
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList", (void *)&value);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);

xs/id3v2tagframelistmap.xs view on Meta::CPAN

	TagLib::ByteVector * key
CODE:
	RETVAL = THIS->contains(*key);
OUTPUT:
	RETVAL

void 
TagLib::ID3v2::FrameListMap::FIRSTKEY()
PREINIT:
	TagLib::ID3v2::FrameListMap::Iterator it;
PPCODE:
	if(THIS->isEmpty())
		XSRETURN_UNDEF;
	it = THIS->begin();
	/* (**it) is a std::pair<const TagLib::ByteVector, TagLib::ID3v2::FrameList> */
	const TagLib::ByteVector & key = it->first;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ByteVector", (void *)&key);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

xs/id3v2tagframelistmapiterator.xs view on Meta::CPAN

	RETVAL

void 
TagLib::ID3v2::FrameListMap::Iterator::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::ID3v2::FrameListMap::Iterator::data()
PPCODE:
//USEPAIR
	/* iterator for Map */
	TagLib::ID3v2::FrameList & data = (*THIS)->second;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameList", (void *)&data);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::FrameListMap::Iterator::next()
PPCODE:
	TagLib::ID3v2::FrameListMap::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameListMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::ID3v2::FrameListMap::Iterator::last()
PPCODE:
	TagLib::ID3v2::FrameListMap::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameListMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::ID3v2::FrameListMap::Iterator::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameListMap::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::ID3v2::FrameListMap::Iterator::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::FrameListMap::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/id3v2tagframelistmapiterator.xs view on Meta::CPAN

TagLib::ID3v2::FrameListMap::Iterator::greatEqual(i)
	TagLib::ID3v2::FrameListMap::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::ID3v2::FrameListMap::Iterator::copy(i)
	TagLib::ID3v2::FrameListMap::Iterator * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

xs/mpcfile.xs view on Meta::CPAN

void 
TagLib::MPC::File::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::MPC::File::tag()
INIT:
	TagLib::Tag * tag = THIS->tag();
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::MPC::File::audioProperties()
INIT:
	TagLib::MPC::Properties * p = THIS->audioProperties();
PPCODE:
	if(p != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::MPC::Properties", (void *)p);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

bool 
TagLib::MPC::File::save()
CODE:
	RETVAL = THIS->save();
OUTPUT:
	RETVAL

void 
TagLib::MPC::File::ID3v1Tag(create=false)
	bool create
INIT:
	TagLib::ID3v1::Tag * tag = THIS->ID3v1Tag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::MPC::File::APETag(create=false)
	bool create
INIT:
	TagLib::APE::Tag * tag = THIS->APETag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::APE::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::MPC::File::remove(tags=TagLib::MPC::File::AllTags)

xs/mpegfile.xs view on Meta::CPAN

void 
TagLib::MPEG::File::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::MPEG::File::tag()
INIT:
	TagLib::Tag * tag = THIS->tag();
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::MPEG::File::audioProperties()
INIT:
	TagLib::MPEG::Properties * p = THIS->audioProperties();
PPCODE:
	if(p != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::MPEG::Properties", (void *)p);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

bool 
TagLib::MPEG::File::save(...)

xs/mpegfile.xs view on Meta::CPAN

		RETVAL = THIS->save();
	}
OUTPUT:
	RETVAL

void 
TagLib::MPEG::File::ID3v2Tag(create=false)
	bool create
INIT:
	TagLib::ID3v2::Tag * tag = THIS->ID3v2Tag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v2::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::MPEG::File::ID3v1Tag(create=false)
	bool create
INIT:
	TagLib::ID3v1::Tag * tag = THIS->ID3v1Tag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::ID3v1::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::MPEG::File::APETag(create=false)
	bool create
INIT:
	TagLib::APE::Tag * tag = THIS->APETag(create);
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::APE::Tag", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

bool 
TagLib::MPEG::File::strip(...)

xs/mpegheader.xs view on Meta::CPAN

int 
TagLib::MPEG::Header::frameLength()
CODE:
	RETVAL = THIS->frameLength();
OUTPUT:
	RETVAL

void  
TagLib::MPEG::Header::copy(h)
	TagLib::MPEG::Header * h
PPCODE:
	(void)THIS->operator=(*h);
	XSRETURN(1);

xs/oggfieldlistmap.xs view on Meta::CPAN

	TagLib::String * key
CODE:
	if(THIS->contains(*key))
		THIS->erase(THIS->find(*key));

void 
TagLib::Ogg::FieldListMap::getItem(key)
	TagLib::String * key
INIT:
	TagLib::StringList & item = THIS->operator[](*key);
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::StringList", (void *)&item);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# const T & operator[](const Key &key) const
# not exported
#

xs/oggfieldlistmap.xs view on Meta::CPAN

################################################################
# 
# Map<Key, T> & operator=(const Map<Key, T> &m)
# not exported
# 
################################################################

void 
TagLib::Ogg::FieldListMap::copy(m)
	TagLib::Ogg::FieldListMap * m
PPCODE:
	(void)THIS->operator=(*m);
	/* return ST(0) */
	XSRETURN(1);

################################################################
# 
# PROTECTED MEMBER FUNCTIONS
# 
# void detach()
# not exported

xs/oggfieldlistmap.xs view on Meta::CPAN

# 
# SPECIAL FUNCTIONS FOR TIE MAGIC
# 
################################################################

static void  
TagLib::Ogg::FieldListMap::TIEHASH(...)
PROTOTYPE: ;$
PREINIT:
	TagLib::Ogg::FieldListMap * map;
PPCODE:
	/*! 
	 * tie %h, "TagLib::Ogg::FieldListMap"
	 * tie %h, "TagLib::Ogg::FieldListMap", $obj_to_tie
	 */
	switch(items) {
	case 2:
		if(sv_isobject(ST(1)) && 
			sv_derived_from(ST(1), "Audio::TagLib::Ogg::FieldListMap")) {
			if(SvREADONLY(SvRV(ST(1)))){
				ST(0) = sv_newmortal();

xs/oggfieldlistmap.xs view on Meta::CPAN

		/* items == 1 */
		map = new TagLib::Ogg::FieldListMap();
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Ogg::FieldListMap", (void *)map);
	}
	XSRETURN(1);

void 
TagLib::Ogg::FieldListMap::FETCH(key)
	TagLib::String * key
PPCODE:
	/*!
	 * this will NOT copy the value
	 * just return the reference
	 */
	if(THIS->contains(*key)) {
		TagLib::StringList & value = THIS->operator[](*key);
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::StringList", (void *)&value);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);

xs/oggfieldlistmap.xs view on Meta::CPAN

	TagLib::String * key
CODE:
	RETVAL = THIS->contains(*key);
OUTPUT:
	RETVAL

void 
TagLib::Ogg::FieldListMap::FIRSTKEY()
PREINIT:
	TagLib::Ogg::FieldListMap::Iterator it;
PPCODE:
	if(THIS->isEmpty())
		XSRETURN_UNDEF;
	it = THIS->begin();
	/* (**it) is a std::pair<const TagLib::String, TagLib::StringList> */
	const TagLib::String & key = it->first;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::String", (void *)&key);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

xs/oggfieldlistmapiterator.xs view on Meta::CPAN

	RETVAL

void 
TagLib::Ogg::FieldListMap::Iterator::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::Ogg::FieldListMap::Iterator::data()
PPCODE:
//USEPAIR
	/* iterator for Map */
	TagLib::StringList & data = (*THIS)->second;
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::StringList", (void *)&data);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::Ogg::FieldListMap::Iterator::next()
PPCODE:
	TagLib::Ogg::FieldListMap::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::Ogg::FieldListMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::Ogg::FieldListMap::Iterator::last()
PPCODE:
	TagLib::Ogg::FieldListMap::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::Ogg::FieldListMap::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::Ogg::FieldListMap::Iterator::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::Ogg::FieldListMap::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::Ogg::FieldListMap::Iterator::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::Ogg::FieldListMap::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/oggfieldlistmapiterator.xs view on Meta::CPAN

TagLib::Ogg::FieldListMap::Iterator::greatEqual(i)
	TagLib::Ogg::FieldListMap::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::Ogg::FieldListMap::Iterator::copy(i)
	TagLib::Ogg::FieldListMap::Iterator * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

xs/oggfile.xs view on Meta::CPAN

TagLib::Ogg::File::setPacket(i, p)
	unsigned int i
	TagLib::ByteVector * p
CODE:
	THIS->setPacket(i, *p);

void 
TagLib::Ogg::File::firstPageHeader()
INIT:
	const TagLib::Ogg::PageHeader * h = THIS->firstPageHeader();
PPCODE:
	if(h != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Ogg::PageHeader", (void *)h);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::Ogg::File::lastPageHeader()
INIT:
	const TagLib::Ogg::PageHeader * h = THIS->lastPageHeader();
PPCODE:
	if(h != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Ogg::PageHeader", (void *)h);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

bool 
TagLib::Ogg::File::save()

xs/oggflacfile.xs view on Meta::CPAN

void 
TagLib::Ogg::FLAC::File::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::Ogg::FLAC::File::tag()
INIT:
	TagLib::Ogg::XiphComment * tag = THIS->tag();
PPCODE:
	if(tag != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::Ogg::XiphComment", (void *)tag);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

void 
TagLib::Ogg::FLAC::File::audioProperties()
INIT:
	TagLib::FLAC::Properties * p = THIS->audioProperties();
PPCODE:
	if(p != NULL) {
		ST(0) = sv_newmortal();
		sv_setref_pv(ST(0), "Audio::TagLib::FLAC::Properties", (void *)p);
		SvREADONLY_on(SvRV(ST(0)));
		XSRETURN(1);
	} else
		XSRETURN_UNDEF;

bool
TagLib::Ogg::FLAC::File::hasXiphComment()

xs/oggpage.xs view on Meta::CPAN

TagLib::Ogg::Page::fileOffset()
CODE:
	RETVAL = THIS->fileOffset();
OUTPUT:
	RETVAL

void 
TagLib::Ogg::Page::header()
INIT:
	const TagLib::Ogg::PageHeader * h = THIS->header();
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::Ogg::PageHeader", (void *)h);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

int 
TagLib::Ogg::Page::firstPacketIndex()
CODE:
	RETVAL = THIS->firstPacketIndex();
OUTPUT:

xs/oggpage.xs view on Meta::CPAN

	bool firstPacketContinued
	bool lastPacketCompleted
	bool containsLastPacket
PREINIT:
	SV * sv;
INIT:
	TagLib::List<TagLib::Ogg::Page *> l = TagLib::Ogg::Page::paginate(
		*packets, strategy, streamSerialNumber, firstPage, 
		firstPacketContinued, lastPacketCompleted, 
		containsLastPacket);
PPCODE:
	switch(GIMME_V) {
	case G_SCALAR:
		ST(0) = sv_2mortal(newSVuv(l.size()));
		XSRETURN(1);
	case G_ARRAY:
		if(0 < l.size()) {
			EXTEND(SP, l.size());
			for(int i = 0; i < l.size(); i++) {
				sv = sv_newmortal();
				sv_setref_pv(sv, "Audio::TagLib::Ogg::Page",

xs/oggpageheader.xs view on Meta::CPAN

TagLib::Ogg::PageHeader::isValid()
CODE:
	RETVAL = THIS->isValid();
OUTPUT:
	RETVAL

void 
TagLib::Ogg::PageHeader::packetSizes()
INIT:
	TagLib::List<int> l = THIS->packetSizes();
PPCODE:
	switch(GIMME_V) {
	case G_SCALAR:
		ST(0) = sv_2mortal(newSVuv(l.size()));
		XSRETURN(1);
	case G_ARRAY:
		EXTEND(SP, l.size());
		if(0 < l.size()) {
			for(int i = 0; i < l.size(); i++)
				PUSHs(sv_2mortal(newSViv(l[i])));
			//XSRETURN(l.size());

xs/relativevolumeframe.xs view on Meta::CPAN

CODE:
	RETVAL = new TagLib::String(THIS->toString());
OUTPUT:
	RETVAL

void 
TagLib::ID3v2::RelativeVolumeFrame::channels()
INIT:
	TagLib::List<TagLib::ID3v2::RelativeVolumeFrame::ChannelType> 
		l = THIS->channels();
PPCODE:
	switch(GIMME_V) {
	case G_SCALAR:
		ST(0) = sv_2mortal(newSVuv(l.size()));
		XSRETURN(1);
	case G_ARRAY:
		if(l.size() != 0) {
			EXTEND(SP, l.size());
			for(int i = 0; i < l.size(); i++) {
				switch(l[i]) {
				case TagLib::ID3v2::RelativeVolumeFrame::Other:

xs/relativevolumeframe.xs view on Meta::CPAN

void 
TagLib::ID3v2::RelativeVolumeFrame::PeakVolume::setBitsRepresentingPeak(c)
	unsigned char c
CODE:
	THIS->bitsRepresentingPeak = c;

void 
TagLib::ID3v2::RelativeVolumeFrame::PeakVolume::peakVolume()
INIT:
	TagLib::ByteVector & pv = THIS->peakVolume;
PPCODE:
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::ByteVector", (void *)&pv);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

################################################################
# 
# new member function
# exported for setting peakVolume
#

xs/stringiterator.xs view on Meta::CPAN

	RETVAL

void 
TagLib::String::Iterator::DESTROY()
CODE:
	if(!SvREADONLY(SvRV(ST(0))))
		delete THIS;

void 
TagLib::String::Iterator::data()
PPCODE:
//USEWCHAR
	/* iterator for String */
	wchar_t & data = **THIS;
    /* Festus Hagen 1.62.fh8 - [rt.cpan.org #82529] # */
    iconv_t codec = iconv_open("UTF-8", "UTF-16LE");
	if(codec == (iconv_t)(-1))
		croak("iconv_open failed");
	char *inbuf, *outbuf;
	char utf8[1024];
	size_t inlen, outlen;

xs/stringiterator.xs view on Meta::CPAN

	if(iconv_wrap(codec, &inbuf, &inlen, &outbuf, &outlen) == -1)
		croak("iconv failed");
	utf8[1024-outlen] = '\0';
	iconv_close(codec);
	ST(0) = sv_2mortal(newSVpvn(utf8, strlen(utf8)));
	SvUTF8_on(ST(0));
	XSRETURN(1);

void 
TagLib::String::Iterator::next()
PPCODE:
	TagLib::String::Iterator & i = THIS->operator++();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::String::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void  
TagLib::String::Iterator::last()
PPCODE:
	TagLib::String::Iterator & i = THIS->operator--();
	ST(0) = sv_newmortal();
	sv_setref_pv(ST(0), "Audio::TagLib::String::Iterator", (void *)&i);
	SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#ifdef LONGMOVEMENT

void 
TagLib::String::Iterator::forward(n)
	int n
PPCODE:
	(void)THIS->operator+=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::String::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

void 
TagLib::String::Iterator::backward(n)
	int n
PPCODE:
	(void)THIS->operator-=(n);
	/* leave ST(0) untouched and return */
	//ST(0) = sv_newmortal();
	//sv_setref_pv(ST(0), "Audio::TagLib::String::Iterator", (void *)THIS);
	//SvREADONLY_on(SvRV(ST(0)));
	XSRETURN(1);

#endif

#ifdef MOREMETHODS

xs/stringiterator.xs view on Meta::CPAN

TagLib::String::Iterator::greatEqual(i)
	TagLib::String::Iterator * i
CODE:
	RETVAL = THIS->operator>=(*i);
OUTPUT:
	RETVAL

void 
TagLib::String::Iterator::copy(i)
	TagLib::String::Iterator * i
PPCODE:
	(void)THIS->operator=(*i);
	XSRETURN(1);

#endif /* MOREMETHODS */

#undef LONGMOVEMENT

xs/tbytevector.xs view on Meta::CPAN

TagLib::ByteVector::size()
CODE:
	RETVAL = THIS->size();
OUTPUT:
	RETVAL

void 
TagLib::ByteVector::resize(size, padding = 0)
	unsigned int size
	char padding
PPCODE:
	(void)THIS->resize(size, padding);
	XSRETURN(1);

TagLib::ByteVector::Iterator * 
TagLib::ByteVector::begin() 
CODE:
	RETVAL = new TagLib::ByteVector::Iterator(THIS->begin());
OUTPUT:
	RETVAL

xs/tbytevector.xs view on Meta::CPAN

################################################################
# 
# THIS IS A NEW ADDED PRIVATE SYMBOL
# which implements
# ByteVector & operator=(const ByteVector &v)
# 
################################################################
void  
TagLib::ByteVector::copy(v)
	TagLib::ByteVector * v
PPCODE:
	(void)THIS->operator=(*THIS);
	XSRETURN(1);

################################################################
# 
# STATIC PUBLIC MEMBER FUNCTIONS
# 
################################################################
static TagLib::ByteVector * 
TagLib::ByteVector::fromUInt(value, mostSignificantByteFirst=true)

xs/tbytevector.xs view on Meta::CPAN


################################################################
# 
# return the memory address of instance 
# 
################################################################
void 
TagLib::ByteVector::_memoAddress()
PREINIT:
	char strAddress[512];
PPCODE:
	sprintf(strAddress, "%#u", THIS);
	ST(0) = newSVpv(strAddress, 0);
	sv_2mortal(ST(0));
	XSRETURN(1);

( run in 2.525 seconds using v1.01-cache-2.11-cpan-71847e10f99 )