Пример #1
0
int main(int argc, const char *argv[])
{
	Mb5Query Query;

	argc=argc;
	argv=argv;

	Query=mb5_query_new("searchcexample-1.0",NULL,0);
	if (Query)
	{
		char **ParamNames;
		char **ParamValues;
		Mb5Metadata Metadata;
		char ErrorMessage[256];
		tQueryResult Result;
		int HTTPCode;

		ParamNames=malloc(2*sizeof(char *));
		ParamNames[0]=malloc(256);
		ParamNames[1]=malloc(256);
		ParamValues=malloc(2*sizeof(char *));
		ParamValues[0]=malloc(256);
		ParamValues[1]=malloc(256);

		strcpy(ParamNames[0],"query");
		strcpy(ParamValues[0],"artist:john");

		strcpy(ParamNames[1],"limit");
		strcpy(ParamValues[1],"10");

		Metadata=mb5_query_query(Query,"artist","","",2,ParamNames,ParamValues);

		Result=mb5_query_get_lastresult(Query);
		HTTPCode=mb5_query_get_lasthttpcode(Query);

		mb5_query_get_lasterrormessage(Query,ErrorMessage,sizeof(ErrorMessage));
		printf("Result: %d\nHTTPCode: %d\nErrorMessage: '%s'\n",Result,HTTPCode,ErrorMessage);

		if (Metadata)
		{
			int ThisArtist;
			Mb5ArtistList ArtistList=mb5_metadata_get_artistlist(Metadata);

			printf("Found %d artist(s)\n",mb5_artist_list_size(ArtistList));

			for (ThisArtist=0;ThisArtist<mb5_artist_list_size(ArtistList);ThisArtist++)
			{
				Mb5Artist Artist=mb5_artist_list_item(ArtistList,ThisArtist);
				if (Artist)
				{
					int count;
					char Name[256];
					char Value[256];
					int NumExtAttrs=mb5_entity_ext_attributes_size(Artist);
					int NumExtElements=mb5_entity_ext_elements_size(Artist);

					printf("%d attrs, %d elements\n",NumExtAttrs,NumExtElements);

					for (count=0;count<NumExtAttrs;count++)
					{
						mb5_entity_ext_attribute_name(Artist,count,Name,sizeof(Name));
						mb5_entity_ext_attribute_value(Artist,count,Value,sizeof(Value));

						printf("Attr '%s' = '%s'\n",Name,Value);
					}

					for (count=0;count<NumExtElements;count++)
					{
						mb5_entity_ext_element_name(Artist,count,Name,sizeof(Name));
						mb5_entity_ext_element_value(Artist,count,Value,sizeof(Value));

						printf("Element '%s' = '%s'\n",Name,Value);
					}

					mb5_artist_get_name(Artist,Name,sizeof(Name));
					printf("Artist is '%s'\n",Name);

					mb5_artist_get_sortname(Artist,Name,sizeof(Name));
					printf("Artist sort is '%s'\n",Name);
				}
				else
				{
					printf("Couldn't get artist %d\n",ThisArtist);
				}
			}

			mb5_metadata_delete(Metadata);
		}

		free(ParamValues[1]);
		free(ParamValues[0]);
		free(ParamValues);
		free(ParamNames[1]);
		free(ParamNames[0]);
		free(ParamNames);

		mb5_query_delete(Query);
	}

	return 0;
}
static gboolean
fetch_uri_job (GIOSchedulerJob *sched_job,
               GCancellable *cancellable,
               gpointer user_data)
{
  FetchUriJob *job = user_data;
  Mb5Metadata metadata;
  Mb5Query query;
  Mb5Release release;
  Mb5ReleaseList release_list;
  gchar *retval = NULL;
  gchar **param_names = NULL;
  gchar **param_values = NULL;

  query = mb5_query_new ("sushi", NULL, 0);

  param_names = g_new (gchar*, 3);
  param_values = g_new (gchar*, 3);

  param_names[0] = g_strdup ("query");
  param_values[0] = g_strdup_printf ("artist:\"%s\" AND release:\"%s\"", job->artist, job->album);

  param_names[1] = g_strdup ("limit");
  param_values[1] = g_strdup ("10");

  param_names[2] = NULL;
  param_values[2] = NULL;

  metadata = mb5_query_query (query, "release", "", "",
                              2, param_names, param_values);

  mb5_query_delete (query);

  if (metadata) {
    release_list = mb5_metadata_get_releaselist (metadata);
    int i;
    int release_list_length = mb5_release_list_size (release_list);
    for (i = 0; i < release_list_length; i++) {
      gchar asin[255];

      release = mb5_release_list_item (release_list, i);
      mb5_release_get_asin (release, asin, 255);

      if (asin != NULL &&
        asin[0] != '\0') {
        retval = g_strdup (asin);
        break;
      }
    }
  }
  mb5_metadata_delete (metadata);

  if (retval == NULL) {
    /* FIXME: do we need a better error? */
    g_simple_async_result_set_error (job->result,
                                     G_IO_ERROR,
                                     0, "%s",
                                     "Error getting the ASIN from MusicBrainz");
  } else {
    g_simple_async_result_set_op_res_gpointer (job->result,
                                               retval, NULL);
  }

  g_io_scheduler_job_send_to_mainloop_async (sched_job,
                                             fetch_uri_job_callback,
                                             job, NULL);
  g_strfreev (param_names);
  g_strfreev (param_values);
  return FALSE;
}
Пример #3
0
void CompileTest()
{
	Mb5Alias Alias=0;
	Mb5AliasList AliasList=0;
	Mb5Annotation Annotation=0;
	Mb5AnnotationList AnnotationList=0;
	Mb5Artist Artist=0;
	Mb5ArtistCredit ArtistCredit=0;
	Mb5ArtistList ArtistList=0;
	Mb5Attribute Attribute=0;
	Mb5AttributeList AttributeList=0;
	Mb5CDStub CDStub=0;
	Mb5CDStubList CDStubList=0;
	Mb5Collection Collection=0;
	Mb5CollectionList CollectionList=0;
	Mb5Disc Disc=0;
	Mb5DiscList DiscList=0;
	Mb5FreeDBDisc FreeDBDisc=0;
	Mb5FreeDBDiscList FreeDBDiscList=0;
	Mb5IPI IPI=0;
	Mb5IPIList IPIList=0;
	Mb5ISRC ISRC=0;
	Mb5ISRCList ISRCList=0;
	Mb5ISWC ISWC=0;
	Mb5ISWCList ISWCList=0;
	Mb5Label Label=0;
	Mb5LabelInfo LabelInfo=0;
	Mb5LabelInfoList LabelInfoList=0;
	Mb5LabelList LabelList=0;
	Mb5Lifespan Lifespan=0;
	Mb5Medium Medium=0;
	Mb5MediumList MediumList=0;
	Mb5Message Message=0;
	Mb5Metadata Metadata=0;
	Mb5NameCredit NameCredit=0;
	Mb5NameCreditList NameCreditList=0;
	Mb5NonMBTrack NonMBTrack=0;
	Mb5NonMBTrackList NonMBTrackList=0;
	Mb5PUID PUID=0;
	Mb5PUIDList PUIDList=0;
	Mb5Query Query=0;
	Mb5Rating Rating=0;
	Mb5Recording Recording=0;
	Mb5RecordingList RecordingList=0;
	Mb5Relation Relation=0;
	Mb5RelationList RelationList=0;
	Mb5RelationListList RelationListList=0;
	Mb5Release Release=0;
	Mb5ReleaseGroup ReleaseGroup=0;
	Mb5ReleaseGroupList ReleaseGroupList=0;
	Mb5ReleaseList ReleaseList=0;
	Mb5SecondaryType SecondaryType=0;
	Mb5SecondaryTypeList SecondaryTypeList=0;
	Mb5Tag Tag=0;
	Mb5TagList TagList=0;
	Mb5TextRepresentation TextRepresentation=0;
	Mb5Track Track=0;
	Mb5TrackList TrackList=0;
	Mb5UserRating UserRating=0;
	Mb5UserTag UserTag=0;
	Mb5UserTagList UserTagList=0;
	Mb5Work Work=0;
	Mb5WorkList WorkList=0;
	char Str[256];
	int Size=sizeof(Str);
	int DummyInt=0;
	double DummyDouble=0;
	unsigned char DummyBool=0;
	tQueryResult DummyResult=eQuery_Success;

	DummyInt=mb5_entity_ext_attributes_size(Alias);
	DummyInt=mb5_entity_ext_attribute_name(Alias, 0, Str, Size);
	DummyInt=mb5_entity_ext_attribute_value(Alias, 0, Str, Size);

	DummyInt=mb5_entity_ext_elements_size(Alias);
	DummyInt=mb5_entity_ext_element_name(Alias, 0, Str, Size);
	DummyInt=mb5_entity_ext_element_value(Alias, 0, Str, Size);

	mb5_alias_get_locale(Alias,Str,Size);
	mb5_alias_get_text(Alias,Str,Size);
	mb5_alias_get_sortname(Alias,Str,Size);
	mb5_alias_get_type(Alias,Str,Size);
	mb5_alias_get_primary(Alias,Str,Size);
	mb5_alias_get_begindate(Alias,Str,Size);
	mb5_alias_get_enddate(Alias,Str,Size);
	Alias=mb5_alias_clone(Alias);
	mb5_alias_delete(Alias);

	mb5_annotation_get_type(Annotation,Str,Size);
	mb5_annotation_get_entity(Annotation,Str,Size);
	mb5_annotation_get_name(Annotation,Str,Size);
	mb5_annotation_get_text(Annotation,Str,Size);
	Annotation=mb5_annotation_clone(Annotation);
	mb5_annotation_delete(Annotation);

	mb5_artist_get_id(Artist,Str,Size);
	mb5_artist_get_type(Artist,Str,Size);
	mb5_artist_get_name(Artist,Str,Size);
	mb5_artist_get_sortname(Artist,Str,Size);
	mb5_artist_get_gender(Artist,Str,Size);
	mb5_artist_get_country(Artist,Str,Size);
	mb5_artist_get_disambiguation(Artist,Str,Size);
	IPIList=mb5_artist_get_ipilist(Artist);
	Lifespan=mb5_artist_get_lifespan(Artist);
	AliasList=mb5_artist_get_aliaslist(Artist);
	RecordingList=mb5_artist_get_recordinglist(Artist);
	ReleaseList=mb5_artist_get_releaselist(Artist);
	ReleaseGroupList=mb5_artist_get_releasegrouplist(Artist);
	LabelList=mb5_artist_get_labellist(Artist);
	WorkList=mb5_artist_get_worklist(Artist);
	RelationListList=mb5_artist_get_relationlistlist(Artist);
	TagList=mb5_artist_get_taglist(Artist);
	UserTagList=mb5_artist_get_usertaglist(Artist);
	Rating=mb5_artist_get_rating(Artist);
	UserRating=mb5_artist_get_userrating(Artist);
	Artist=mb5_artist_clone(Artist);
	mb5_artist_delete(Artist);

	NameCreditList=mb5_artistcredit_get_namecreditlist(ArtistCredit);
	ArtistCredit=mb5_artistcredit_clone(ArtistCredit);
	mb5_artistcredit_delete(ArtistCredit);

	mb5_attribute_get_text(Attribute,Str,Size);
	Attribute=mb5_attribute_clone(Attribute);
	mb5_attribute_delete(Attribute);

	mb5_cdstub_get_id(CDStub,Str,Size);
	mb5_cdstub_get_title(CDStub,Str,Size);
	mb5_cdstub_get_artist(CDStub,Str,Size);
	mb5_cdstub_get_barcode(CDStub,Str,Size);
	mb5_cdstub_get_comment(CDStub,Str,Size);
	NonMBTrackList=mb5_cdstub_get_nonmbtracklist(CDStub);
	CDStub=mb5_cdstub_clone(CDStub);
	mb5_cdstub_delete(CDStub);

	mb5_disc_get_id(Disc,Str,Size);
	DummyInt=mb5_disc_get_sectors(Disc);
	ReleaseList=mb5_disc_get_releaselist(Disc);
	Disc=mb5_disc_clone(Disc);
	mb5_disc_delete(Disc);

	mb5_collection_get_id(Collection,Str,Size);
	mb5_collection_get_name(Collection,Str,Size);
	mb5_collection_get_editor(Collection,Str,Size);
	ReleaseList=mb5_collection_get_releaselist(Collection);
	Collection=mb5_collection_clone(Collection);
	mb5_collection_delete(Collection);

	mb5_freedbdisc_get_id(FreeDBDisc,Str,Size);
	mb5_freedbdisc_get_title(FreeDBDisc,Str,Size);
	mb5_freedbdisc_get_artist(FreeDBDisc,Str,Size);
	mb5_freedbdisc_get_category(FreeDBDisc,Str,Size);
	mb5_freedbdisc_get_year(FreeDBDisc,Str,Size);
	NonMBTrackList=mb5_freedbdisc_get_nonmbtracklist(FreeDBDisc);
	FreeDBDisc=mb5_freedbdisc_clone(FreeDBDisc);
	mb5_freedbdisc_delete(FreeDBDisc);

	mb5_ipi_get_ipi(IPI,Str,Size);
	IPI=mb5_ipi_clone(IPI);
	mb5_ipi_delete(IPI);

	mb5_isrc_get_id(ISRC,Str,Size);
	RecordingList=mb5_isrc_get_recordinglist(ISRC);
	ISRC=mb5_isrc_clone(ISRC);
	mb5_isrc_delete(ISRC);

	mb5_iswc_get_iswc(ISWC,Str,Size);
	ISWC=mb5_iswc_clone(ISWC);
	mb5_iswc_delete(ISWC);

	mb5_label_get_id(Label,Str,Size);
	mb5_label_get_type(Label,Str,Size);
	mb5_label_get_name(Label,Str,Size);
	mb5_label_get_sortname(Label,Str,Size);
	DummyInt=mb5_label_get_labelcode(Label);
	IPIList=mb5_label_get_ipilist(Label);
	mb5_label_get_disambiguation(Label,Str,Size);
	mb5_label_get_country(Label,Str,Size);
	Lifespan=mb5_label_get_lifespan(Label);
	AliasList=mb5_label_get_aliaslist(Label);
	ReleaseList=mb5_label_get_releaselist(Label);
	RelationListList=mb5_label_get_relationlistlist(Label);
	TagList=mb5_label_get_taglist(Label);
	UserTagList=mb5_label_get_usertaglist(Label);
	Rating=mb5_label_get_rating(Label);
	UserRating=mb5_label_get_userrating(Label);
	Label=mb5_label_clone(Label);
	mb5_label_delete(Label);

	mb5_labelinfo_get_catalognumber(LabelInfo,Str,Size);
	Label=mb5_labelinfo_get_label(LabelInfo);
	LabelInfo=mb5_labelinfo_clone(LabelInfo);
	mb5_labelinfo_delete(LabelInfo);

	mb5_lifespan_get_begin(Lifespan,Str,Size);
	mb5_lifespan_get_end(Lifespan,Str,Size);
	mb5_lifespan_get_ended(Lifespan,Str,Size);
	Lifespan=mb5_lifespan_clone(Lifespan);
	mb5_lifespan_delete(Lifespan);

	mb5_medium_get_title(Medium,Str,Size);
	DummyInt=mb5_medium_get_position(Medium);
	mb5_medium_get_format(Medium,Str,Size);
	DiscList=mb5_medium_get_disclist(Medium);
	TrackList=mb5_medium_get_tracklist(Medium);
	DummyBool=mb5_medium_contains_discid(Medium,"1234");
	Medium=mb5_medium_clone(Medium);
	mb5_medium_delete(Medium);

	mb5_message_get_text(Message,Str,Size);
	Message=mb5_message_clone(Message);
	mb5_message_delete(Message);

	mb5_metadata_get_xmlns(Metadata,Str,Size);
	mb5_metadata_get_xmlnsext(Metadata,Str,Size);
	mb5_metadata_get_generator(Metadata,Str,Size);
	mb5_metadata_get_created(Metadata,Str,Size);
	Artist=mb5_metadata_get_artist(Metadata);
	Release=mb5_metadata_get_release(Metadata);
	ReleaseGroup=mb5_metadata_get_releasegroup(Metadata);
	Recording=mb5_metadata_get_recording(Metadata);
	Label=mb5_metadata_get_label(Metadata);
	Work=mb5_metadata_get_work(Metadata);
	PUID=mb5_metadata_get_puid(Metadata);
	ISRC=mb5_metadata_get_isrc(Metadata);
	Disc=mb5_metadata_get_disc(Metadata);
	LabelInfoList=mb5_metadata_get_labelinfolist(Metadata);
	Rating=mb5_metadata_get_rating(Metadata);
	UserRating=mb5_metadata_get_userrating(Metadata);
	Collection=mb5_metadata_get_collection(Metadata);
	ArtistList=mb5_metadata_get_artistlist(Metadata);
	ReleaseList=mb5_metadata_get_releaselist(Metadata);
	ReleaseGroupList=mb5_metadata_get_releasegrouplist(Metadata);
	RecordingList=mb5_metadata_get_recordinglist(Metadata);
	LabelList=mb5_metadata_get_labellist(Metadata);
	WorkList=mb5_metadata_get_worklist(Metadata);
	ISRCList=mb5_metadata_get_isrclist(Metadata);
	AnnotationList=mb5_metadata_get_annotationlist(Metadata);
	CDStubList=mb5_metadata_get_cdstublist(Metadata);
	FreeDBDiscList=mb5_metadata_get_freedbdisclist(Metadata);
	TagList=mb5_metadata_get_taglist(Metadata);
	UserTagList=mb5_metadata_get_usertaglist(Metadata);
	CollectionList=mb5_metadata_get_collectionlist(Metadata);
	CDStub=mb5_metadata_get_cdstub(Metadata);
	Message=mb5_metadata_get_message(Metadata);
	Metadata=mb5_metadata_clone(Metadata);
	mb5_metadata_delete(Metadata);

	mb5_nonmbtrack_get_title(NonMBTrack,Str,Size);
	mb5_nonmbtrack_get_artist(NonMBTrack,Str,Size);
	DummyInt=mb5_nonmbtrack_get_length(NonMBTrack);
	NonMBTrack=mb5_nonmbtrack_clone(NonMBTrack);
	mb5_nonmbtrack_delete(NonMBTrack);

	mb5_namecredit_get_joinphrase(NameCredit,Str,Size);
	mb5_namecredit_get_name(NameCredit,Str,Size);
	Artist=mb5_namecredit_get_artist(NameCredit);
	NameCredit=mb5_namecredit_clone(NameCredit);
	mb5_namecredit_delete(NameCredit);

	mb5_puid_get_id(PUID,Str,Size);
	RecordingList=mb5_puid_get_recordinglist(PUID);
	PUID=mb5_puid_clone(PUID);
	mb5_puid_delete(PUID);

	Query=mb5_query_new("useragent", "server",0);
	mb5_query_set_username(Query,"");
	mb5_query_set_password(Query,"");
	mb5_query_set_proxyhost(Query,"");
	mb5_query_set_proxyport(Query,0);
	mb5_query_set_proxyusername(Query,"");
	mb5_query_set_proxypassword(Query,"");
	ReleaseList=mb5_query_lookup_discid(Query,"discid");
	Release=mb5_query_lookup_release(Query,"release");
	Metadata=mb5_query_query(Query,"entity","id","resource",0,0,0);
	DummyBool=mb5_query_add_collection_entries(Query,Collection,0,0);
	DummyBool=mb5_query_delete_collection_entries(Query,Collection,0,0);
	DummyResult=mb5_query_get_lastresult(Query);
	DummyInt=mb5_query_get_lasthttpcode(Query);
	mb5_query_get_lasterrormessage(Query,Str,Size);
	mb5_query_get_version(Query,Str,Size);
	mb5_query_delete(Query);

	DummyInt=mb5_rating_get_votescount(Rating);
	DummyDouble=mb5_rating_get_rating(Rating);
	Rating=mb5_rating_clone(Rating);
	mb5_rating_delete(Rating);

	mb5_recording_get_id(Recording,Str,Size);
	mb5_recording_get_title(Recording,Str,Size);
	DummyInt=mb5_recording_get_length(Recording);
	mb5_recording_get_disambiguation(Recording,Str,Size);
	ArtistCredit=mb5_recording_get_artistcredit(Recording);
	ReleaseList=mb5_recording_get_releaselist(Recording);
	PUIDList=mb5_recording_get_puidlist(Recording);
	ISRCList=mb5_recording_get_isrclist(Recording);
	RelationListList=mb5_recording_get_relationlistlist(Recording);
	TagList=mb5_recording_get_taglist(Recording);
	UserTagList=mb5_recording_get_usertaglist(Recording);
	Rating=mb5_recording_get_rating(Recording);
	UserRating=mb5_recording_get_userrating(Recording);
	Recording=mb5_recording_clone(Recording);
	mb5_recording_delete(Recording);

	mb5_relation_get_type(Relation,Str,Size);
	mb5_relation_get_target(Relation,Str,Size);
	mb5_relation_get_direction(Relation,Str,Size);
	AttributeList=mb5_relation_get_attributelist(Relation);
	mb5_relation_get_begin(Relation,Str,Size);
	mb5_relation_get_end(Relation,Str,Size);
	mb5_relation_get_ended(Relation,Str,Size);
	Artist=mb5_relation_get_artist(Relation);
	Release=mb5_relation_get_release(Relation);
	ReleaseGroup=mb5_relation_get_releasegroup(Relation);
	Recording=mb5_relation_get_recording(Relation);
	Label=mb5_relation_get_label(Relation);
	Work=mb5_relation_get_work(Relation);
	Relation=mb5_relation_clone(Relation);
	mb5_relation_delete(Relation);

	mb5_release_get_id(Release,Str,Size);
	mb5_release_get_title(Release,Str,Size);
	mb5_release_get_status(Release,Str,Size);
	mb5_release_get_quality(Release,Str,Size);
	mb5_release_get_disambiguation(Release,Str,Size);
	mb5_release_get_packaging(Release,Str,Size);
	TextRepresentation=mb5_release_get_textrepresentation(Release);
	ArtistCredit=mb5_release_get_artistcredit(Release);
	ReleaseGroup=mb5_release_get_releasegroup(Release);
	mb5_release_get_date(Release,Str,Size);
	mb5_release_get_country(Release,Str,Size);
	mb5_release_get_barcode(Release,Str,Size);
	mb5_release_get_asin(Release,Str,Size);
	LabelInfoList=mb5_release_get_labelinfolist(Release);
	MediumList=mb5_release_get_mediumlist(Release);
	RelationListList=mb5_release_get_relationlistlist(Release);
	CollectionList=mb5_release_get_collectionlist(Release);
	MediumList=mb5_release_media_matching_discid(Release,"discid");
	Release=mb5_release_clone(Release);
	mb5_release_delete(Release);

	mb5_releasegroup_get_id(ReleaseGroup,Str,Size);
	mb5_releasegroup_get_primarytype(ReleaseGroup,Str,Size);
	mb5_releasegroup_get_firstreleasedate(ReleaseGroup,Str,Size);
	mb5_releasegroup_get_title(ReleaseGroup,Str,Size);
	mb5_releasegroup_get_disambiguation(ReleaseGroup,Str,Size);
	ArtistCredit=mb5_releasegroup_get_artistcredit(ReleaseGroup);
	ReleaseList=mb5_releasegroup_get_releaselist(ReleaseGroup);
	RelationListList=mb5_releasegroup_get_relationlistlist(ReleaseGroup);
	TagList=mb5_releasegroup_get_taglist(ReleaseGroup);
	UserTagList=mb5_releasegroup_get_usertaglist(ReleaseGroup);
	Rating=mb5_releasegroup_get_rating(ReleaseGroup);
	UserRating=mb5_releasegroup_get_userrating(ReleaseGroup);
	SecondaryTypeList=mb5_releasegroup_get_secondarytypelist(ReleaseGroup);
	ReleaseGroup=mb5_releasegroup_clone(ReleaseGroup);
	mb5_releasegroup_delete(ReleaseGroup);

	DummyInt=mb5_tag_get_count(Tag);
	mb5_tag_get_name(Tag,Str,Size);
	Tag=mb5_tag_clone(Tag);
	mb5_tag_delete(Tag);

	mb5_textrepresentation_get_language(TextRepresentation,Str,Size);
	mb5_textrepresentation_get_script(TextRepresentation,Str,Size);
	TextRepresentation=mb5_textrepresentation_clone(TextRepresentation);
	mb5_textrepresentation_delete(TextRepresentation);

	DummyInt=mb5_track_get_position(Track);
	mb5_track_get_title(Track,Str,Size);
	Recording=mb5_track_get_recording(Track);
	DummyInt=mb5_track_get_length(Track);
	ArtistCredit=mb5_track_get_artistcredit(Track);
	mb5_track_get_number(Track,Str,Size);
	Track=mb5_track_clone(Track);
	mb5_track_delete(Track);

	DummyInt=mb5_userrating_get_userrating(UserRating);
	UserRating=mb5_userrating_clone(UserRating);
	mb5_userrating_delete(UserRating);

	mb5_usertag_get_name(UserTag,Str,Size);
	UserTag=mb5_usertag_clone(UserTag);
	mb5_usertag_delete(UserTag);

	mb5_work_get_id(Work,Str,Size);
	mb5_work_get_type(Work,Str,Size);
	mb5_work_get_title(Work,Str,Size);
	ArtistCredit=mb5_work_get_artistcredit(Work);
	ISWCList=mb5_work_get_iswclist(Work);
	mb5_work_get_disambiguation(Work,Str,Size);
	AliasList=mb5_work_get_aliaslist(Work);
	RelationListList=mb5_work_get_relationlistlist(Work);
	TagList=mb5_work_get_taglist(Work);
	UserTagList=mb5_work_get_usertaglist(Work);
	Rating=mb5_work_get_rating(Work);
	UserRating=mb5_work_get_userrating(Work);
	mb5_work_get_language(Work,Str,Size);

	mb5_alias_list_size(AliasList);
	Alias=mb5_alias_list_item(AliasList,0);
	AliasList=mb5_alias_clone(AliasList);
	DummyInt=mb5_alias_list_get_count(AliasList);
	DummyInt=mb5_alias_list_get_offset(AliasList);
	mb5_alias_list_delete(AliasList);

	mb5_annotation_list_size(AnnotationList);
	Annotation=mb5_annotation_list_item(AnnotationList,0);
	AnnotationList=mb5_annotation_list_clone(AnnotationList);
	DummyInt=mb5_annotation_list_get_count(AnnotationList);
	DummyInt=mb5_annotation_list_get_offset(AnnotationList);
	mb5_annotation_list_delete(AnnotationList);

	DummyInt=mb5_artist_list_size(ArtistList);
	Artist=mb5_artist_list_item(ArtistList,0);
	ArtistList=mb5_artist_list_clone(ArtistList);
	DummyInt=mb5_artist_list_get_count(ArtistList);
	DummyInt=mb5_artist_list_get_offset(ArtistList);
	mb5_artist_list_delete(ArtistList);

	DummyInt=mb5_attribute_list_size(AttributeList);
	Attribute=mb5_attribute_list_item(AttributeList,0);
	AttributeList=mb5_attribute_list_clone(AttributeList);
	DummyInt=mb5_attribute_list_get_count(AttributeList);
	DummyInt=mb5_attribute_list_get_offset(AttributeList);
	mb5_attribute_list_delete(AttributeList);

	DummyInt=mb5_cdstub_list_size(CDStubList);
	CDStub=mb5_cdstub_list_item(CDStubList,0);
	CDStubList=mb5_cdstub_list_clone(CDStubList);
	DummyInt=mb5_cdstub_list_get_count(CDStubList);
	DummyInt=mb5_cdstub_list_get_offset(CDStubList);
	mb5_cdstub_list_delete(CDStubList);

	DummyInt=mb5_collection_list_size(CollectionList);
	Collection=mb5_collection_list_item(CollectionList,0);
	CollectionList=mb5_collection_list_clone(CollectionList);
	DummyInt=mb5_collection_list_get_count(CollectionList);
	DummyInt=mb5_collection_list_get_offset(CollectionList);
	mb5_collection_list_delete(CollectionList);

	DummyInt=mb5_disc_list_size(DiscList);
	Disc=mb5_disc_list_item(DiscList,0);
	DiscList=mb5_disc_list_clone(DiscList);
	DummyInt=mb5_disc_list_get_count(DiscList);
	DummyInt=mb5_disc_list_get_offset(DiscList);
	mb5_disc_list_delete(DiscList);

	DummyInt=mb5_freedbdisc_list_size(FreeDBDiscList);
	FreeDBDisc=mb5_freedbdisc_list_item(FreeDBDiscList,0);
	FreeDBDiscList=mb5_freedbdisc_list_clone(FreeDBDiscList);
	DummyInt=mb5_freedbdisc_list_get_count(FreeDBDiscList);
	DummyInt=mb5_freedbdisc_list_get_offset(FreeDBDiscList);
	mb5_freedbdisc_list_delete(FreeDBDiscList);

	DummyInt=mb5_ipi_list_size(IPIList);
	ISRC=mb5_ipi_list_item(IPIList,0);
	ISRCList=mb5_ipi_list_clone(IPIList);
	DummyInt=mb5_ipi_list_get_count(IPIList);
	DummyInt=mb5_ipi_list_get_offset(IPIList);
	mb5_ipi_list_delete(IPIList);

	DummyInt=mb5_isrc_list_size(ISRCList);
	ISRC=mb5_isrc_list_item(ISRCList,0);
	ISRCList=mb5_isrc_list_clone(ISRCList);
	DummyInt=mb5_isrc_list_get_count(ISRCList);
	DummyInt=mb5_isrc_list_get_offset(ISRCList);
	mb5_isrc_list_delete(ISRCList);

	DummyInt=mb5_iswc_list_size(ISWCList);
	ISWC=mb5_iswc_list_item(ISWCList,0);
	ISWCList=mb5_iswc_list_clone(ISWCList);
	DummyInt=mb5_iswc_list_get_count(ISWCList);
	DummyInt=mb5_iswc_list_get_offset(ISWCList);
	mb5_iswc_list_delete(ISWCList);

	DummyInt=mb5_label_list_size(LabelList);
	Label=mb5_label_list_item(LabelList,0);
	LabelList=mb5_label_list_clone(LabelList);
	DummyInt=mb5_label_list_get_count(LabelList);
	DummyInt=mb5_label_list_get_offset(LabelList);
	mb5_label_list_delete(LabelList);

	DummyInt=mb5_labelinfo_list_size(LabelInfoList);
	LabelInfo=mb5_labelinfo_list_item(LabelInfoList,0);
	LabelInfoList=mb5_labelinfo_list_clone(LabelInfoList);
	DummyInt=mb5_labelinfo_list_get_count(LabelInfoList);
	DummyInt=mb5_labelinfo_list_get_offset(LabelInfoList);
	mb5_labelinfo_list_delete(LabelInfoList);

	DummyInt=mb5_medium_list_size(MediumList);
	Medium=mb5_medium_list_item(MediumList,0);
	DummyInt=mb5_medium_list_get_trackcount(MediumList);
	MediumList=mb5_medium_list_clone(MediumList);
	DummyInt=mb5_medium_list_get_count(MediumList);
	DummyInt=mb5_medium_list_get_offset(MediumList);
	mb5_medium_list_delete(MediumList);

	DummyInt=mb5_namecredit_list_size(NameCreditList);
	NameCredit=mb5_namecredit_list_item(NameCreditList,0);
	NameCreditList=mb5_namecredit_list_clone(NameCreditList);
	DummyInt=mb5_namecredit_list_get_count(NameCreditList);
	DummyInt=mb5_namecredit_list_get_offset(NameCreditList);
	mb5_namecredit_list_delete(NameCreditList);

	DummyInt=mb5_nonmbtrack_list_size(NonMBTrackList);
	NonMBTrack=mb5_nonmbtrack_list_item(NonMBTrackList,0);
	NonMBTrackList=mb5_nonmbtrack_list_clone(NonMBTrackList);
	DummyInt=mb5_nonmbtrack_list_get_count(NonMBTrackList);
	DummyInt=mb5_nonmbtrack_list_get_offset(NonMBTrackList);
	mb5_nonmbtrack_list_delete(NonMBTrackList);

	DummyInt=mb5_puid_list_size(PUIDList);
	PUID=mb5_puid_list_item(PUIDList,0);
	PUIDList=mb5_puid_list_clone(PUIDList);
	DummyInt=mb5_puid_list_get_count(PUIDList);
	DummyInt=mb5_puid_list_get_offset(PUIDList);
	mb5_puid_list_delete(PUIDList);

	DummyInt=mb5_recording_list_size(RecordingList);
	Recording=mb5_recording_list_item(RecordingList,0);
	RecordingList=mb5_recording_list_clone(RecordingList);
	DummyInt=mb5_recording_list_get_count(RecordingList);
	DummyInt=mb5_recording_list_get_offset(RecordingList);
	mb5_recording_list_delete(RecordingList);

	DummyInt=mb5_relation_list_size(RelationList);
	Relation=mb5_relation_list_item(RelationList,0);
	DummyInt=mb5_relation_list_get_targettype(RelationList,Str,Size);
	RelationList=mb5_relation_list_clone(RelationList);
	DummyInt=mb5_relation_list_get_count(RelationList);
	DummyInt=mb5_relation_list_get_offset(RelationList);
	mb5_relation_list_delete(RelationList);

	DummyInt=mb5_relationlist_list_size(RelationListList);
	Relation=mb5_relationlist_list_item(RelationListList,0);
	RelationList=mb5_relationlist_list_clone(RelationListList);
	DummyInt=mb5_relationlist_list_get_count(RelationListList);
	DummyInt=mb5_relationlist_list_get_offset(RelationListList);
	mb5_relationlist_list_delete(RelationListList);

	DummyInt=mb5_release_list_size(ReleaseList);
	Release=mb5_release_list_item(ReleaseList,0);
	ReleaseList=mb5_release_list_clone(ReleaseList);
	DummyInt=mb5_release_list_get_count(ReleaseList);
	DummyInt=mb5_release_list_get_offset(ReleaseList);
	mb5_release_list_delete(ReleaseList);

	DummyInt=mb5_releasegroup_list_size(ReleaseGroupList);
	ReleaseGroup=mb5_releasegroup_list_item(ReleaseGroupList,0);
	ReleaseGroupList=mb5_releasegroup_list_clone(ReleaseGroupList);
	DummyInt=mb5_releasegroup_list_get_count(ReleaseGroupList);
	DummyInt=mb5_releasegroup_list_get_offset(ReleaseGroupList);
	mb5_releasegroup_list_delete(ReleaseGroupList);

	DummyInt=mb5_secondarytype_list_size(SecondaryTypeList);
	SecondaryType=mb5_secondarytype_list_item(SecondaryTypeList,0);
	ReleaseGroupList=mb5_secondarytype_list_clone(SecondaryTypeList);
	DummyInt=mb5_secondarytype_list_get_count(SecondaryTypeList);
	DummyInt=mb5_secondarytype_list_get_offset(SecondaryTypeList);
	mb5_secondarytype_list_delete(SecondaryTypeList);

	DummyInt=mb5_tag_list_size(TagList);
	Tag=mb5_tag_list_item(TagList,0);
	TagList=mb5_tag_list_clone(TagList);
	DummyInt=mb5_tag_list_get_count(TagList);
	DummyInt=mb5_tag_list_get_offset(TagList);
	mb5_tag_list_delete(TagList);

	DummyInt=mb5_track_list_size(TrackList);
	Track=mb5_track_list_item(TrackList,0);
	TrackList=mb5_track_list_clone(TrackList);
	DummyInt=mb5_track_list_get_count(TrackList);
	DummyInt=mb5_track_list_get_offset(TrackList);
	mb5_track_list_delete(TrackList);

	DummyInt=mb5_usertag_list_size(UserTagList);
	UserTag=mb5_usertag_list_item(UserTagList,0);
	UserTagList=mb5_usertag_list_clone(UserTagList);
	DummyInt=mb5_usertag_list_get_count(UserTagList);
	DummyInt=mb5_usertag_list_get_offset(UserTagList);
	mb5_usertag_list_delete(UserTagList);

	DummyInt=mb5_work_list_size(WorkList);
	Work=mb5_work_list_item(WorkList,0);
	WorkList=mb5_work_list_clone(WorkList);
	DummyInt=mb5_work_list_get_count(WorkList);
	DummyInt=mb5_work_list_get_offset(WorkList);
	mb5_work_list_delete(WorkList);

	DummyInt=DummyInt;
	DummyDouble=DummyDouble;
	DummyBool=DummyBool;
	DummyResult=DummyResult;
	SecondaryType=SecondaryType;
}
Пример #4
0
int main(int argc, const char *argv[])
{
	Mb5Query Query=0;
	char DiscID[256]="tLGBAiCflG8ZI6lFcOt87vXjEcI-";

	Query=mb5_query_new("ctest","test.musicbrainz.org",0);
	if (Query)
	{
		char Version[256];
		Mb5Metadata Metadata=0;

		mb5_query_get_version(Query,Version,sizeof(Version));
		printf("Version is '%s'\n",Version);

		Metadata=mb5_query_query(Query,"work","b0d17375-5593-390e-a936-1a65ce74c630","",0,NULL,NULL);
		if (Metadata)
		{
			Mb5Work Work=0;

			Work=mb5_metadata_get_work(Metadata);
			if (Work)
			{
				Mb5ISWCList ISWCList=0;

				ISWCList=mb5_work_get_iswclist(Work);
				if (ISWCList)
				{
					int ISWCNum;

					printf("Got ISWC list, size %d\n",mb5_iswc_list_size(ISWCList));

					for (ISWCNum=0;ISWCNum<mb5_iswc_list_size(ISWCList);ISWCNum++)
					{
						Mb5ISWC ISWC=mb5_iswc_list_item(ISWCList,ISWCNum);

						if (ISWC)
						{
							char ISWCStr[256];

							mb5_iswc_get_iswc(ISWC,ISWCStr,sizeof(ISWCStr));

							printf("Got ISWC %d - '%s'\n",ISWCNum,ISWCStr);
						}
					}
				}
			}
		}

		mb5_query_delete(Query);
	}

	return 0;

	if (argc==2)
	{
		strncpy(DiscID,argv[1],sizeof(DiscID));
		DiscID[sizeof(DiscID)-1]='\0';
	}

	Query=mb5_query_new("ctest",0,0);
	if (Query)
	{
		Mb5Metadata Metadata=NULL;
		char **ParamNames;
		char **ParamValues;

		printf("Got query\n");

		mb5_query_set_username(Query,"username");
		mb5_query_set_password(Query,"password");

		ParamNames=malloc(sizeof(char *));
		ParamNames[0]=malloc(256);
		ParamValues=malloc(sizeof(char *));
		ParamValues[0]=malloc(256);

		strcpy(ParamNames[0],"inc");
		strcpy(ParamValues[0],"artists release-groups url-rels work-level-rels work-rels artist-rels");

		Metadata=mb5_query_query(Query,"recording","3631f569-520d-40ff-a1ee-076604723275","",1,ParamNames,ParamValues);
		if (Metadata)
		{
			Mb5Recording Recording=mb5_metadata_get_recording(Metadata);
			printf("Got metadata\n");

			if (Recording)
			{
				Mb5RelationListList RelationListList=mb5_recording_get_relationlistlist(Recording);

				printf("Got recording\n");

				if (RelationListList)
				{
					int RelationListNum;

					printf("Got relation list list, size %d\n",mb5_relationlist_list_size(RelationListList));

					for (RelationListNum=0;RelationListNum<mb5_relationlist_list_size(RelationListList);RelationListNum++)
					{
						Mb5RelationList RelationList=mb5_relationlist_list_item(RelationListList,RelationListNum);

						if (RelationList)
						{
							printf("Got relation list %d\n",RelationListNum);

							PrintRelationList(RelationList);
						}
					}
				}
			}

			mb5_metadata_delete(Metadata);
		}

		Metadata=mb5_query_query(Query,"collection",0,0,0,NULL,NULL);
		if (Metadata)
		{
			printf("Got collections");
			mb5_metadata_delete(Metadata);
		}

		Metadata=mb5_query_query(Query,"discid",DiscID,0,0,NULL,NULL);
		if (Metadata)
		{
			Mb5Disc *Disc=mb5_metadata_get_disc(Metadata);
			printf("Got metadata\n");

			if (Disc)
			{
				int Len=0;
				char *Buff=0;
				Mb5ReleaseList ReleaseList=mb5_disc_get_releaselist(Disc);

				Len=mb5_disc_get_id(Disc,Buff,Len);
				printf("Len is %d\n",Len);
				Buff=malloc(Len+1);
				Len=mb5_disc_get_id(Disc,Buff,Len+1);
				printf("Len is %d (%s)\n",Len,Buff);
				free(Buff);

				printf("Got disc\n");

				if (ReleaseList)
				{
					int count;

					printf("Got release list\n");

					printf("%d items\n",mb5_release_list_size(ReleaseList));

					for (count=0;count<mb5_release_list_size(ReleaseList);count++)
					{
						char ID[256];
						Mb5Release Release=mb5_release_list_item(ReleaseList,count);

						printf("Got release %d\n",count);

						mb5_release_get_id(Release,ID,sizeof(ID));
						printf("ID is '%s'\n",ID);
					}
				}
			}

			mb5_metadata_delete(Metadata);
		}

		mb5_query_delete(Query);
	}

	return 0;
}
/*
 * Virtual methods
 */
static GList *
mb5_list_albums (SjMetadata *metadata, char **url, GError **error)
{
  SjMetadataMusicbrainz5Private *priv;
  GList *albums = NULL;
  Mb5ReleaseList releases;
  Mb5Release release;
  const char *discid = NULL;
  char buffer[1025];
  int i;
  g_return_val_if_fail (SJ_IS_METADATA_MUSICBRAINZ5 (metadata), NULL);

  priv = GET_PRIVATE (metadata);

  if (sj_metadata_helper_check_media (priv->cdrom, error) == FALSE) {
    return NULL;
  }

  priv->disc = discid_new ();
  if (priv->disc == NULL)
    return NULL;
  if (discid_read (priv->disc, priv->cdrom) == 0)
    return NULL;

  if (url != NULL)
    *url = g_strdup (discid_get_submission_url (priv->disc));

  if (g_getenv("MUSICBRAINZ_FORCE_DISC_ID")) {
    discid = g_getenv("MUSICBRAINZ_FORCE_DISC_ID");
  } else {
    discid = discid_get_id (priv->disc);
  }

  releases = mb5_query_lookup_discid(priv->mb, discid);

  if (releases == NULL) {
    return NULL;
  }

  if (mb5_release_list_size (releases) == 0) {
    return NULL;
  }

  for (i = 0; i < mb5_release_list_size (releases); i++) {
    AlbumDetails *album;

    release = mb5_release_list_item (releases, i);
    if (release) {
      char *releaseid = NULL;
      Mb5Release full_release;

      releaseid = NULL;
      GET(releaseid, mb5_release_get_id, release);

      full_release = mb5_query_lookup_release (priv->mb, releaseid);
      g_free (releaseid);
      if (full_release) {
        Mb5MediumList media;
        Mb5Metadata metadata = NULL;
        Mb5ReleaseGroup group;
        unsigned int j;

        group = mb5_release_get_releasegroup (full_release);
        if (group) {
          /* The release-group information we can extract from the
           * lookup_release query doesn't have the url relations for the
           * release-group, so run a separate query to get these urls
           */
          char *releasegroupid = NULL;
          char *params_names[] = { "inc" };
          char *params_values[] = { "artists url-rels" };

          GET (releasegroupid, mb5_releasegroup_get_id, group);
          metadata = mb5_query_query (priv->mb, "release-group", releasegroupid, "",
                                      1, params_names, params_values);
          g_free (releasegroupid);
        }

        if (metadata && mb5_metadata_get_releasegroup (metadata))
          group = mb5_metadata_get_releasegroup (metadata);

        media = mb5_release_media_matching_discid (full_release, discid);
        for (j = 0; j < mb5_medium_list_size (media); j++) {
          Mb5Medium medium;
          medium = mb5_medium_list_item (media, j);
          if (medium) {
            album = make_album_from_release (group, full_release, medium);
            album->metadata_source = SOURCE_MUSICBRAINZ;
            albums = g_list_append (albums, album);
          }
        }
        mb5_metadata_delete (metadata);
        mb5_medium_list_delete (media);
        mb5_release_delete (full_release);
      }
    }
  }
  mb5_release_list_delete (releases);
  return albums;
}