enlightenment/empc
enlightenment
/
empc
6
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

don't require azy at all for app build

This commit is contained in:
Mike Blumenkrantz 2014-09-23 16:37:34 -04:00
parent 29ba62c5a1
commit befd161684
7 changed files with 1741 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.gitignore vendored
View File

@ -1,9 +1,5 @@
Makefile
Makefile.in
Empd_Common.c
Empd_Common.h
Empd_Common_Azy.c
Empd_Common_Azy.h
eldbus_empd_empdd.c
eldbus_empd_empdd.h
eldbus_empd_empc.c
@ -35,5 +31,5 @@ install-sh
libtool
ltmain.sh
stamp-h1
Lyricwiki*
org.empd.empc.service
Lyricwiki*

4
configure.ac
View File

@ -89,9 +89,7 @@ PKG_CHECK_MODULES([EFL], [eina >= 1.11.2 ecore >= 1.11.2 ecore-con >= 1.11.2 eld
PKG_CHECK_MODULES([ELM], [evas >= 1.11.2 elementary >= 1.11.2])
PKG_CHECK_MODULES([ESQL], [esskyuehl], [have_esql=yes], [have_esql=no])
AC_PATH_PROG([AZY_PARSER], [azy_parser], [no])
if test "x$AZY_PARSER" = "x" ; then
AC_MSG_ERROR([azy_parser from the maelstrom package is required])
fi
AM_CONDITIONAL([HAVE_AZY_PARSER], [test "x$AZY_PARSER" != "x"])
############# MODULES ###################
want_glyr_gmpc=maybe
AC_ARG_ENABLE([module-glyr-gmpc],

571
src/bin/Empd_Common.c Normal file
View File

@ -0,0 +1,571 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "Empd_Common.h"
#include <string.h>
#include <inttypes.h>
#include <errno.h>
Eina_Bool
azy_str_to_bool_(const char *d, Eina_Bool *ret)
{
*ret = EINA_FALSE;
if (d && (*d == '1')) *ret = EINA_TRUE;
return EINA_TRUE;
}
Eina_Bool
azy_str_to_str_(const char *d, const char **ret)
{
*ret = NULL;
if (!d) return EINA_TRUE;
*ret = eina_stringshare_add(d);
return EINA_TRUE;
}
Eina_Bool
azy_str_to_int_(const char *d, int *ret)
{
errno = 0;
*ret = 0;
if (!d) return EINA_TRUE;
*ret = strtol(d, NULL, 10);
if (errno)
{
#ifdef ERR
fprintf(stderr, "Error converting %s to int: '%s'", d, strerror(errno));
#endif
return EINA_FALSE;
}
return EINA_TRUE;
}
Eina_Bool
azy_str_to_double_(const char *d, double *ret)
{
errno = 0;
*ret = 0.0;
if (!d) return EINA_TRUE;
*ret = strtod(d, NULL);
if (errno)
{
#ifdef ERR
fprintf(stderr, "Error converting %s to double: '%s'", d, strerror(errno));
#endif
return EINA_FALSE;
}
return EINA_TRUE;
}
void Empd_Empdd_Song_free(Empd_Empdd_Song * val)
{
if (!val)
return;
eina_stringshare_del(val->uri);
eina_stringshare_del(val->artist);
eina_stringshare_del(val->title);
eina_stringshare_del(val->album);
eina_stringshare_del(val->name);
eina_stringshare_del(val->date);
eina_stringshare_del(val->disc);
free(val);
}
Empd_Empdd_Song * Empd_Empdd_Song_copy(Empd_Empdd_Song * orig)
{
Empd_Empdd_Song * copy;
if (!orig)
return NULL;
copy = Empd_Empdd_Song_new();
copy->uri = eina_stringshare_ref(orig->uri);
copy->last_modified = orig->last_modified;
copy->duration = orig->duration;
copy->artist = eina_stringshare_ref(orig->artist);
copy->title = eina_stringshare_ref(orig->title);
copy->album = eina_stringshare_ref(orig->album);
copy->track = orig->track;
copy->name = eina_stringshare_ref(orig->name);
copy->date = eina_stringshare_ref(orig->date);
copy->disc = eina_stringshare_ref(orig->disc);
copy->song_pos = orig->song_pos;
copy->songid = orig->songid;
return copy;
}
Eina_Bool Empd_Empdd_Song_eq(Empd_Empdd_Song * a, Empd_Empdd_Song * b)
{
if (a == b)
return EINA_TRUE;
if ((!a) || (!b))
return EINA_FALSE;
if (a->uri != b->uri)
return EINA_FALSE;
if (a->last_modified != b->last_modified)
return EINA_FALSE;
if (a->duration != b->duration)
return EINA_FALSE;
if (a->artist != b->artist)
return EINA_FALSE;
if (a->title != b->title)
return EINA_FALSE;
if (a->album != b->album)
return EINA_FALSE;
if (a->track != b->track)
return EINA_FALSE;
if (a->name != b->name)
return EINA_FALSE;
if (a->date != b->date)
return EINA_FALSE;
if (a->disc != b->disc)
return EINA_FALSE;
if (a->song_pos != b->song_pos)
return EINA_FALSE;
if (a->songid != b->songid)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_Song_print(const char *pre, int indent, const Empd_Empdd_Song *a)
{
int i;
if (!a)
return;
if (!pre) pre = "\t";
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("uri: %s\n", a->uri);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("last_modified: %ld\n", a->last_modified);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("duration: %ld\n", a->duration);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("artist: %s\n", a->artist);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("title: %s\n", a->title);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("album: %s\n", a->album);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("track: %i\n", a->track);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("name: %s\n", a->name);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("date: %s\n", a->date);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("disc: %s\n", a->disc);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("song_pos: %i\n", a->song_pos);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("songid: %i\n", a->songid);
}
Eina_Bool Empd_Empdd_Song_isnull(Empd_Empdd_Song * a)
{
if (!a)
return EINA_TRUE;
if (a->uri != NULL)
return EINA_FALSE;
if (a->last_modified != 0)
return EINA_FALSE;
if (a->duration != 0)
return EINA_FALSE;
if (a->artist != NULL)
return EINA_FALSE;
if (a->title != NULL)
return EINA_FALSE;
if (a->album != NULL)
return EINA_FALSE;
if (a->track != 0)
return EINA_FALSE;
if (a->name != NULL)
return EINA_FALSE;
if (a->date != NULL)
return EINA_FALSE;
if (a->disc != NULL)
return EINA_FALSE;
if (a->song_pos != 0)
return EINA_FALSE;
if (a->songid != 0)
return EINA_FALSE;
return EINA_TRUE;
}
void Array_Empd_Empdd_Song_free(Eina_List *val)
{
Empd_Empdd_Song * t;
if (!val) return;
EINA_LIST_FREE(val, t)
Empd_Empdd_Song_free(t);
}
Eina_List *Array_Empd_Empdd_Song_copy(Eina_List *orig)
{
Eina_List *copy = NULL;
Eina_List *l;
Empd_Empdd_Song * t;
EINA_LIST_FOREACH(orig, l, t)
copy = eina_list_append(copy, Empd_Empdd_Song_copy((Empd_Empdd_Song *)t));
return copy;
}
Eina_Bool Array_Empd_Empdd_Song_eq(Eina_List * a, Eina_List * b)
{
Eina_List *y, *z;
if (a == b)
return EINA_TRUE;
if ((!a) || (!b))
return EINA_FALSE;
for (y = a, z = b;y && z; y = y->next, z = z->next)
{
if (!Empd_Empdd_Song_eq(y->data, z->data))
return EINA_FALSE;
}
return EINA_TRUE;
}
void Array_Empd_Empdd_Song_print(const char *pre, int indent, const Eina_List *a)
{
const Eina_List *l;
Empd_Empdd_Song * t;
if (!a)
return;
EINA_LIST_FOREACH(a, l, t)
Empd_Empdd_Song_print(pre, indent + 1, t);
}
void Empd_Array_Songs_free(Empd_Array_Songs * val)
{
if (!val)
return;
Array_Empd_Empdd_Song_free(val->songs);
free(val);
}
Empd_Array_Songs * Empd_Array_Songs_copy(Empd_Array_Songs * orig)
{
Empd_Array_Songs * copy;
if (!orig)
return NULL;
copy = Empd_Array_Songs_new();
copy->songs = Array_Empd_Empdd_Song_copy(orig->songs);
return copy;
}
Eina_Bool Empd_Array_Songs_eq(Empd_Array_Songs * a, Empd_Array_Songs * b)
{
if (a == b)
return EINA_TRUE;
if ((!a) || (!b))
return EINA_FALSE;
if (!Array_Empd_Empdd_Song_eq(a->songs, b->songs))
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Array_Songs_print(const char *pre, int indent, const Empd_Array_Songs *a)
{
int i;
if (!a)
return;
if (!pre) pre = "\t";
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("songs:\n");
Array_Empd_Empdd_Song_print(pre, indent + 1, a->songs);
printf("\n");
}
Eina_Bool Empd_Array_Songs_isnull(Empd_Array_Songs * a)
{
if (!a)
return EINA_TRUE;
if (a->songs != NULL)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_File_free(Empd_Empdd_File * val)
{
if (!val)
return;
eina_stringshare_del(val->uri);
eina_stringshare_del(val->artist);
eina_stringshare_del(val->title);
eina_stringshare_del(val->album);
eina_stringshare_del(val->name);
eina_stringshare_del(val->date);
eina_stringshare_del(val->disc);
free(val);
}
Empd_Empdd_File * Empd_Empdd_File_copy(Empd_Empdd_File * orig)
{
Empd_Empdd_File * copy;
if (!orig)
return NULL;
copy = Empd_Empdd_File_new();
copy->uri = eina_stringshare_ref(orig->uri);
copy->last_modified = orig->last_modified;
copy->duration = orig->duration;
copy->artist = eina_stringshare_ref(orig->artist);
copy->title = eina_stringshare_ref(orig->title);
copy->album = eina_stringshare_ref(orig->album);
copy->track = orig->track;
copy->name = eina_stringshare_ref(orig->name);
copy->date = eina_stringshare_ref(orig->date);
copy->disc = eina_stringshare_ref(orig->disc);
return copy;
}
Eina_Bool Empd_Empdd_File_eq(Empd_Empdd_File * a, Empd_Empdd_File * b)
{
if (a == b)
return EINA_TRUE;
if ((!a) || (!b))
return EINA_FALSE;
if (a->uri != b->uri)
return EINA_FALSE;
if (a->last_modified != b->last_modified)
return EINA_FALSE;
if (a->duration != b->duration)
return EINA_FALSE;
if (a->artist != b->artist)
return EINA_FALSE;
if (a->title != b->title)
return EINA_FALSE;
if (a->album != b->album)
return EINA_FALSE;
if (a->track != b->track)
return EINA_FALSE;
if (a->name != b->name)
return EINA_FALSE;
if (a->date != b->date)
return EINA_FALSE;
if (a->disc != b->disc)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_File_print(const char *pre, int indent, const Empd_Empdd_File *a)
{
int i;
if (!a)
return;
if (!pre) pre = "\t";
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("uri: %s\n", a->uri);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("last_modified: %ld\n", a->last_modified);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("duration: %ld\n", a->duration);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("artist: %s\n", a->artist);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("title: %s\n", a->title);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("album: %s\n", a->album);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("track: %i\n", a->track);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("name: %s\n", a->name);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("date: %s\n", a->date);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("disc: %s\n", a->disc);
}
Eina_Bool Empd_Empdd_File_isnull(Empd_Empdd_File * a)
{
if (!a)
return EINA_TRUE;
if (a->uri != NULL)
return EINA_FALSE;
if (a->last_modified != 0)
return EINA_FALSE;
if (a->duration != 0)
return EINA_FALSE;
if (a->artist != NULL)
return EINA_FALSE;
if (a->title != NULL)
return EINA_FALSE;
if (a->album != NULL)
return EINA_FALSE;
if (a->track != 0)
return EINA_FALSE;
if (a->name != NULL)
return EINA_FALSE;
if (a->date != NULL)
return EINA_FALSE;
if (a->disc != NULL)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_Directory_free(Empd_Empdd_Directory * val)
{
if (!val)
return;
eina_stringshare_del(val->uri);
free(val);
}
Empd_Empdd_Directory * Empd_Empdd_Directory_copy(Empd_Empdd_Directory * orig)
{
Empd_Empdd_Directory * copy;
if (!orig)
return NULL;
copy = Empd_Empdd_Directory_new();
copy->uri = eina_stringshare_ref(orig->uri);
copy->last_modified = orig->last_modified;
return copy;
}
Eina_Bool Empd_Empdd_Directory_eq(Empd_Empdd_Directory * a, Empd_Empdd_Directory * b)
{
if (a == b)
return EINA_TRUE;
if ((!a) || (!b))
return EINA_FALSE;
if (a->uri != b->uri)
return EINA_FALSE;
if (a->last_modified != b->last_modified)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_Directory_print(const char *pre, int indent, const Empd_Empdd_Directory *a)
{
int i;
if (!a)
return;
if (!pre) pre = "\t";
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("uri: %s\n", a->uri);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("last_modified: %ld\n", a->last_modified);
}
Eina_Bool Empd_Empdd_Directory_isnull(Empd_Empdd_Directory * a)
{
if (!a)
return EINA_TRUE;
if (a->uri != NULL)
return EINA_FALSE;
if (a->last_modified != 0)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_Playlist_free(Empd_Empdd_Playlist * val)
{
if (!val)
return;
eina_stringshare_del(val->uri);
free(val);
}
Empd_Empdd_Playlist * Empd_Empdd_Playlist_copy(Empd_Empdd_Playlist * orig)
{
Empd_Empdd_Playlist * copy;
if (!orig)
return NULL;
copy = Empd_Empdd_Playlist_new();
copy->uri = eina_stringshare_ref(orig->uri);
copy->last_modified = orig->last_modified;
return copy;
}
Eina_Bool Empd_Empdd_Playlist_eq(Empd_Empdd_Playlist * a, Empd_Empdd_Playlist * b)
{
if (a == b)
return EINA_TRUE;
if ((!a) || (!b))
return EINA_FALSE;
if (a->uri != b->uri)
return EINA_FALSE;
if (a->last_modified != b->last_modified)
return EINA_FALSE;
return EINA_TRUE;
}
void Empd_Empdd_Playlist_print(const char *pre, int indent, const Empd_Empdd_Playlist *a)
{
int i;
if (!a)
return;
if (!pre) pre = "\t";
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("uri: %s\n", a->uri);
for (i = 0; i < indent; i++)
printf("%s", pre);
printf("last_modified: %ld\n", a->last_modified);
}
Eina_Bool Empd_Empdd_Playlist_isnull(Empd_Empdd_Playlist * a)
{
if (!a)
return EINA_TRUE;
if (a->uri != NULL)
return EINA_FALSE;
if (a->last_modified != 0)
return EINA_FALSE;
return EINA_TRUE;
}

149
src/bin/Empd_Common.h Normal file
View File

@ -0,0 +1,149 @@
#ifndef Empd_Common_H
#define Empd_Common_H
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <Eina.h>
Eina_Bool azy_str_to_bool_(const char *d, Eina_Bool *ret);
Eina_Bool azy_str_to_str_(const char *d, const char **ret);
Eina_Bool azy_str_to_int_(const char *d, int *ret);
Eina_Bool azy_str_to_double_(const char *d, double *ret);
typedef struct Empd_Empdd_Song Empd_Empdd_Song;
typedef struct Empd_Array_Songs Empd_Array_Songs;
typedef struct Empd_Empdd_File Empd_Empdd_File;
typedef struct Empd_Empdd_Directory Empd_Empdd_Directory;
typedef struct Empd_Empdd_Playlist Empd_Empdd_Playlist;
struct Empd_Empdd_Song
{
Eina_Stringshare * uri; /* */
time_t last_modified; /* */
time_t duration; /* */
Eina_Stringshare * artist; /* */
Eina_Stringshare * title; /* */
Eina_Stringshare * album; /* */
int track; /* */
Eina_Stringshare * name; /* */
Eina_Stringshare * date; /* */
Eina_Stringshare * disc; /* */
int song_pos; /* */
int songid; /* */
};
static inline Empd_Empdd_Song *Empd_Empdd_Song_new(void)
{
return calloc(1, sizeof(Empd_Empdd_Song));
}
struct Empd_Array_Songs
{
Eina_List * songs; /* Array_Empd_Empdd_Song */
};
static inline Empd_Array_Songs *Empd_Array_Songs_new(void)
{
return calloc(1, sizeof(Empd_Array_Songs));
}
struct Empd_Empdd_File
{
Eina_Stringshare * uri; /* */
time_t last_modified; /* */
time_t duration; /* */
Eina_Stringshare * artist; /* */
Eina_Stringshare * title; /* */
Eina_Stringshare * album; /* */
int track; /* */
Eina_Stringshare * name; /* */
Eina_Stringshare * date; /* */
Eina_Stringshare * disc; /* */
};
static inline Empd_Empdd_File *Empd_Empdd_File_new(void)
{
return calloc(1, sizeof(Empd_Empdd_File));
}
struct Empd_Empdd_Directory
{
Eina_Stringshare * uri; /* */
time_t last_modified; /* */
};
static inline Empd_Empdd_Directory *Empd_Empdd_Directory_new(void)
{
return calloc(1, sizeof(Empd_Empdd_Directory));
}
struct Empd_Empdd_Playlist
{
Eina_Stringshare * uri; /* */
time_t last_modified; /* */
};
static inline Empd_Empdd_Playlist *Empd_Empdd_Playlist_new(void)
{
return calloc(1, sizeof(Empd_Empdd_Playlist));
}
/** @brief Free a #Empd_Empdd_Song * */
void Empd_Empdd_Song_free(Empd_Empdd_Song * val);
/** @brief Copy a #Empd_Empdd_Song * */
Empd_Empdd_Song *Empd_Empdd_Song_copy(Empd_Empdd_Song *orig);
/** @brief Check whether all the values of @p a are equal to @p b */
Eina_Bool Empd_Empdd_Song_eq(Empd_Empdd_Song * a, Empd_Empdd_Song * b);
/** @brief Print, indenting @p indent times @p pre, a Empd_Empdd_Song */
void Empd_Empdd_Song_print(const char *pre, int indent, const Empd_Empdd_Song *a);
/** @brief Check whether all the values of @p a are NULL */
Eina_Bool Empd_Empdd_Song_isnull(Empd_Empdd_Song * a);
/** @brief Free a #Eina_List * */
void Array_Empd_Empdd_Song_free(Eina_List * val);
/** @brief Copy a #Eina_List * */
Eina_List *Array_Empd_Empdd_Song_copy(Eina_List *orig);
/** @brief Check whether all the values of @p a are equal to @p b */
Eina_Bool Array_Empd_Empdd_Song_eq(Eina_List * a, Eina_List * b);
/** @brief Print, indenting @p indent times @p pre, an array of Array_Empd_Empdd_Song */
void Array_Empd_Empdd_Song_print(const char *pre, int indent, const Eina_List *a);
/** @brief Free a #Empd_Array_Songs * */
void Empd_Array_Songs_free(Empd_Array_Songs * val);
/** @brief Copy a #Empd_Array_Songs * */
Empd_Array_Songs *Empd_Array_Songs_copy(Empd_Array_Songs *orig);
/** @brief Check whether all the values of @p a are equal to @p b */
Eina_Bool Empd_Array_Songs_eq(Empd_Array_Songs * a, Empd_Array_Songs * b);
/** @brief Print, indenting @p indent times @p pre, a Empd_Array_Songs */
void Empd_Array_Songs_print(const char *pre, int indent, const Empd_Array_Songs *a);
/** @brief Check whether all the values of @p a are NULL */
Eina_Bool Empd_Array_Songs_isnull(Empd_Array_Songs * a);
/** @brief Free a #Empd_Empdd_File * */
void Empd_Empdd_File_free(Empd_Empdd_File * val);
/** @brief Copy a #Empd_Empdd_File * */
Empd_Empdd_File *Empd_Empdd_File_copy(Empd_Empdd_File *orig);
/** @brief Check whether all the values of @p a are equal to @p b */
Eina_Bool Empd_Empdd_File_eq(Empd_Empdd_File * a, Empd_Empdd_File * b);
/** @brief Print, indenting @p indent times @p pre, a Empd_Empdd_File */
void Empd_Empdd_File_print(const char *pre, int indent, const Empd_Empdd_File *a);
/** @brief Check whether all the values of @p a are NULL */
Eina_Bool Empd_Empdd_File_isnull(Empd_Empdd_File * a);
/** @brief Free a #Empd_Empdd_Directory * */
void Empd_Empdd_Directory_free(Empd_Empdd_Directory * val);
/** @brief Copy a #Empd_Empdd_Directory * */
Empd_Empdd_Directory *Empd_Empdd_Directory_copy(Empd_Empdd_Directory *orig);
/** @brief Check whether all the values of @p a are equal to @p b */
Eina_Bool Empd_Empdd_Directory_eq(Empd_Empdd_Directory * a, Empd_Empdd_Directory * b);
/** @brief Print, indenting @p indent times @p pre, a Empd_Empdd_Directory */
void Empd_Empdd_Directory_print(const char *pre, int indent, const Empd_Empdd_Directory *a);
/** @brief Check whether all the values of @p a are NULL */
Eina_Bool Empd_Empdd_Directory_isnull(Empd_Empdd_Directory * a);
/** @brief Free a #Empd_Empdd_Playlist * */
void Empd_Empdd_Playlist_free(Empd_Empdd_Playlist * val);
/** @brief Copy a #Empd_Empdd_Playlist * */
Empd_Empdd_Playlist *Empd_Empdd_Playlist_copy(Empd_Empdd_Playlist *orig);
/** @brief Check whether all the values of @p a are equal to @p b */
Eina_Bool Empd_Empdd_Playlist_eq(Empd_Empdd_Playlist * a, Empd_Empdd_Playlist * b);
/** @brief Print, indenting @p indent times @p pre, a Empd_Empdd_Playlist */
void Empd_Empdd_Playlist_print(const char *pre, int indent, const Empd_Empdd_Playlist *a);
/** @brief Check whether all the values of @p a are NULL */
Eina_Bool Empd_Empdd_Playlist_isnull(Empd_Empdd_Playlist * a);
#endif

989
src/bin/Empd_Common_Azy.c Normal file
View File

@ -0,0 +1,989 @@
#include "Empd_Common_Azy.h"
Eina_Value *Empd_Empdd_Song_to_azy_value(const Empd_Empdd_Song * azy_user_type)
{
Eina_Value *value_struct = NULL;
size_t offset = 0;
Eina_Value_Struct_Member *members = NULL;
Eina_Value *val = NULL;
Eina_Value_Struct_Desc *st_desc;
if (!azy_user_type) return NULL;
st_desc = eina_value_util_struct_desc_new();
members = malloc(12 * sizeof(Eina_Value_Struct_Member));
st_desc->members = members;
st_desc->member_count = 12;
members[0].name = eina_stringshare_add("uri");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[0].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[0].type = EINA_VALUE_TYPE_STRINGSHARE;
members[1].name = eina_stringshare_add("last_modified");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_TIMESTAMP, offset);
members[1].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_TIMESTAMP);
members[1].type = EINA_VALUE_TYPE_TIMESTAMP;
members[2].name = eina_stringshare_add("duration");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_TIMESTAMP, offset);
members[2].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_TIMESTAMP);
members[2].type = EINA_VALUE_TYPE_TIMESTAMP;
members[3].name = eina_stringshare_add("artist");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[3].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[3].type = EINA_VALUE_TYPE_STRINGSHARE;
members[4].name = eina_stringshare_add("title");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[4].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[4].type = EINA_VALUE_TYPE_STRINGSHARE;
members[5].name = eina_stringshare_add("album");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[5].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[5].type = EINA_VALUE_TYPE_STRINGSHARE;
members[6].name = eina_stringshare_add("track");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_INT, offset);
members[6].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_INT);
members[6].type = EINA_VALUE_TYPE_INT;
members[7].name = eina_stringshare_add("name");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[7].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[7].type = EINA_VALUE_TYPE_STRINGSHARE;
members[8].name = eina_stringshare_add("date");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[8].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[8].type = EINA_VALUE_TYPE_STRINGSHARE;
members[9].name = eina_stringshare_add("disc");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[9].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[9].type = EINA_VALUE_TYPE_STRINGSHARE;
members[10].name = eina_stringshare_add("song_pos");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_INT, offset);
members[10].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_INT);
members[10].type = EINA_VALUE_TYPE_INT;
members[11].name = eina_stringshare_add("songid");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_INT, offset);
members[11].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_INT);
members[11].type = EINA_VALUE_TYPE_INT;
st_desc->size = offset;
value_struct = eina_value_struct_new(st_desc);
val = eina_value_util_stringshare_new(azy_user_type->uri);
eina_value_struct_value_set(value_struct, "uri", val);
eina_value_free(val);
val = eina_value_util_time_new(azy_user_type->last_modified);
eina_value_struct_value_set(value_struct, "last_modified", val);
eina_value_free(val);
val = eina_value_util_time_new(azy_user_type->duration);
eina_value_struct_value_set(value_struct, "duration", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->artist);
eina_value_struct_value_set(value_struct, "artist", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->title);
eina_value_struct_value_set(value_struct, "title", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->album);
eina_value_struct_value_set(value_struct, "album", val);
eina_value_free(val);
val = eina_value_util_int_new(azy_user_type->track);
eina_value_struct_value_set(value_struct, "track", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->name);
eina_value_struct_value_set(value_struct, "name", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->date);
eina_value_struct_value_set(value_struct, "date", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->disc);
eina_value_struct_value_set(value_struct, "disc", val);
eina_value_free(val);
val = eina_value_util_int_new(azy_user_type->song_pos);
eina_value_struct_value_set(value_struct, "song_pos", val);
eina_value_free(val);
val = eina_value_util_int_new(azy_user_type->songid);
eina_value_struct_value_set(value_struct, "songid", val);
eina_value_free(val);
return value_struct;
}
Eina_Bool azy_value_to_Empd_Empdd_Song(const Eina_Value *value_struct, Empd_Empdd_Song * *azy_user_type)
{
Empd_Empdd_Song * azy_user_type_tmp = NULL;
Eina_Value val;
unsigned int arg = 0;
Eina_Bool found = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(azy_user_type, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(value_struct, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(eina_value_type_get(value_struct) != EINA_VALUE_TYPE_STRUCT, EINA_FALSE);
azy_user_type_tmp = Empd_Empdd_Song_new();
if ((!arg) && eina_value_struct_value_get(value_struct, "uri", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->uri = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->uri);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "last_modified", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->last_modified);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "duration", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->duration);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "artist", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->artist = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->artist);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "title", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->title = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->title);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "album", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->album = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->album);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "track", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->track);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "name", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->name = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->name);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "date", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->date = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->date);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "disc", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->disc = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->disc);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "song_pos", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->song_pos);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "songid", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->songid);
eina_value_flush(&val);
}
found = EINA_FALSE;
*azy_user_type = azy_user_type_tmp;
return EINA_TRUE;
}
Eina_Value *Array_Empd_Empdd_Song_to_azy_value(const Eina_List * azy_user_type)
{
const Eina_List *l;
Eina_Value_Struct st;
Empd_Empdd_Song * v;
Eina_Value *value_array = eina_value_array_new(EINA_VALUE_TYPE_STRUCT, 0);
EINA_LIST_FOREACH(azy_user_type, l, v)
{
Eina_Value *item_value = Empd_Empdd_Song_to_azy_value((Empd_Empdd_Song *)v);
eina_value_get(item_value, &st);
eina_value_array_append(value_array, st);
eina_value_free(item_value);
}
return value_array;
}
Eina_Bool azy_value_to_Array_Empd_Empdd_Song(const Eina_Value *value_array, Eina_List ** azy_user_type)
{
Eina_List *azy_user_type_tmp = NULL;
unsigned int x, total;
EINA_SAFETY_ON_NULL_RETURN_VAL(azy_user_type, EINA_FALSE);
if ((!value_array) || (eina_value_type_get(value_array) != EINA_VALUE_TYPE_ARRAY))
return EINA_FALSE;
total = eina_value_array_count(value_array);
for (x = 0; x < total; x++)
{
Empd_Empdd_Song * item_value = NULL;
Eina_Value val;
if (eina_value_array_value_get(value_array, x, &val))
{
azy_value_to_Empd_Empdd_Song(&val, &item_value);
eina_value_flush(&val);
}
azy_user_type_tmp = eina_list_append(azy_user_type_tmp, item_value);
}
*azy_user_type = azy_user_type_tmp;
return EINA_TRUE;
}
Eina_Value *Empd_Array_Songs_to_azy_value(const Empd_Array_Songs * azy_user_type)
{
Eina_Value *value_struct = NULL;
size_t offset = 0;
Eina_Value_Struct_Member *members = NULL;
Eina_Value *val = NULL;
Eina_Value_Struct_Desc *st_desc;
if (!azy_user_type) return NULL;
st_desc = eina_value_util_struct_desc_new();
members = malloc(1 * sizeof(Eina_Value_Struct_Member));
st_desc->members = members;
st_desc->member_count = 1;
members[0].name = eina_stringshare_add("songs");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_ARRAY, offset);
members[0].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_ARRAY);
members[0].type = EINA_VALUE_TYPE_ARRAY;
st_desc->size = offset;
value_struct = eina_value_struct_new(st_desc);
val = Array_Empd_Empdd_Song_to_azy_value(azy_user_type->songs);
eina_value_struct_value_set(value_struct, "songs", val);
eina_value_free(val);
return value_struct;
}
Eina_Bool azy_value_to_Empd_Array_Songs(const Eina_Value *value_struct, Empd_Array_Songs * *azy_user_type)
{
Empd_Array_Songs * azy_user_type_tmp = NULL;
Eina_Value val;
unsigned int arg = 0;
Eina_Bool found = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(azy_user_type, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(value_struct, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(eina_value_type_get(value_struct) != EINA_VALUE_TYPE_STRUCT, EINA_FALSE);
azy_user_type_tmp = Empd_Array_Songs_new();
if ((!arg) && eina_value_struct_value_get(value_struct, "songs", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
azy_value_to_Array_Empd_Empdd_Song(&val, &azy_user_type_tmp->songs);
eina_value_flush(&val);
}
found = EINA_FALSE;
*azy_user_type = azy_user_type_tmp;
return EINA_TRUE;
}
Eina_Value *Empd_Empdd_File_to_azy_value(const Empd_Empdd_File * azy_user_type)
{
Eina_Value *value_struct = NULL;
size_t offset = 0;
Eina_Value_Struct_Member *members = NULL;
Eina_Value *val = NULL;
Eina_Value_Struct_Desc *st_desc;
if (!azy_user_type) return NULL;
st_desc = eina_value_util_struct_desc_new();
members = malloc(10 * sizeof(Eina_Value_Struct_Member));
st_desc->members = members;
st_desc->member_count = 10;
members[0].name = eina_stringshare_add("uri");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[0].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[0].type = EINA_VALUE_TYPE_STRINGSHARE;
members[1].name = eina_stringshare_add("last_modified");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_TIMESTAMP, offset);
members[1].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_TIMESTAMP);
members[1].type = EINA_VALUE_TYPE_TIMESTAMP;
members[2].name = eina_stringshare_add("duration");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_TIMESTAMP, offset);
members[2].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_TIMESTAMP);
members[2].type = EINA_VALUE_TYPE_TIMESTAMP;
members[3].name = eina_stringshare_add("artist");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[3].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[3].type = EINA_VALUE_TYPE_STRINGSHARE;
members[4].name = eina_stringshare_add("title");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[4].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[4].type = EINA_VALUE_TYPE_STRINGSHARE;
members[5].name = eina_stringshare_add("album");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[5].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[5].type = EINA_VALUE_TYPE_STRINGSHARE;
members[6].name = eina_stringshare_add("track");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_INT, offset);
members[6].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_INT);
members[6].type = EINA_VALUE_TYPE_INT;
members[7].name = eina_stringshare_add("name");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[7].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[7].type = EINA_VALUE_TYPE_STRINGSHARE;
members[8].name = eina_stringshare_add("date");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[8].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[8].type = EINA_VALUE_TYPE_STRINGSHARE;
members[9].name = eina_stringshare_add("disc");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[9].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[9].type = EINA_VALUE_TYPE_STRINGSHARE;
st_desc->size = offset;
value_struct = eina_value_struct_new(st_desc);
val = eina_value_util_stringshare_new(azy_user_type->uri);
eina_value_struct_value_set(value_struct, "uri", val);
eina_value_free(val);
val = eina_value_util_time_new(azy_user_type->last_modified);
eina_value_struct_value_set(value_struct, "last_modified", val);
eina_value_free(val);
val = eina_value_util_time_new(azy_user_type->duration);
eina_value_struct_value_set(value_struct, "duration", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->artist);
eina_value_struct_value_set(value_struct, "artist", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->title);
eina_value_struct_value_set(value_struct, "title", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->album);
eina_value_struct_value_set(value_struct, "album", val);
eina_value_free(val);
val = eina_value_util_int_new(azy_user_type->track);
eina_value_struct_value_set(value_struct, "track", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->name);
eina_value_struct_value_set(value_struct, "name", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->date);
eina_value_struct_value_set(value_struct, "date", val);
eina_value_free(val);
val = eina_value_util_stringshare_new(azy_user_type->disc);
eina_value_struct_value_set(value_struct, "disc", val);
eina_value_free(val);
return value_struct;
}
Eina_Bool azy_value_to_Empd_Empdd_File(const Eina_Value *value_struct, Empd_Empdd_File * *azy_user_type)
{
Empd_Empdd_File * azy_user_type_tmp = NULL;
Eina_Value val;
unsigned int arg = 0;
Eina_Bool found = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(azy_user_type, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(value_struct, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(eina_value_type_get(value_struct) != EINA_VALUE_TYPE_STRUCT, EINA_FALSE);
azy_user_type_tmp = Empd_Empdd_File_new();
if ((!arg) && eina_value_struct_value_get(value_struct, "uri", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->uri = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->uri);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "last_modified", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->last_modified);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "duration", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->duration);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "artist", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->artist = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->artist);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "title", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->title = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->title);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "album", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->album = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->album);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "track", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->track);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "name", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->name = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->name);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "date", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->date = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->date);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "disc", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->disc = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->disc);
eina_value_flush(&val);
}
found = EINA_FALSE;
*azy_user_type = azy_user_type_tmp;
return EINA_TRUE;
}
Eina_Value *Empd_Empdd_Directory_to_azy_value(const Empd_Empdd_Directory * azy_user_type)
{
Eina_Value *value_struct = NULL;
size_t offset = 0;
Eina_Value_Struct_Member *members = NULL;
Eina_Value *val = NULL;
Eina_Value_Struct_Desc *st_desc;
if (!azy_user_type) return NULL;
st_desc = eina_value_util_struct_desc_new();
members = malloc(2 * sizeof(Eina_Value_Struct_Member));
st_desc->members = members;
st_desc->member_count = 2;
members[0].name = eina_stringshare_add("uri");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[0].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[0].type = EINA_VALUE_TYPE_STRINGSHARE;
members[1].name = eina_stringshare_add("last_modified");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_TIMESTAMP, offset);
members[1].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_TIMESTAMP);
members[1].type = EINA_VALUE_TYPE_TIMESTAMP;
st_desc->size = offset;
value_struct = eina_value_struct_new(st_desc);
val = eina_value_util_stringshare_new(azy_user_type->uri);
eina_value_struct_value_set(value_struct, "uri", val);
eina_value_free(val);
val = eina_value_util_time_new(azy_user_type->last_modified);
eina_value_struct_value_set(value_struct, "last_modified", val);
eina_value_free(val);
return value_struct;
}
Eina_Bool azy_value_to_Empd_Empdd_Directory(const Eina_Value *value_struct, Empd_Empdd_Directory * *azy_user_type)
{
Empd_Empdd_Directory * azy_user_type_tmp = NULL;
Eina_Value val;
unsigned int arg = 0;
Eina_Bool found = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(azy_user_type, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(value_struct, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(eina_value_type_get(value_struct) != EINA_VALUE_TYPE_STRUCT, EINA_FALSE);
azy_user_type_tmp = Empd_Empdd_Directory_new();
if ((!arg) && eina_value_struct_value_get(value_struct, "uri", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->uri = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->uri);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "last_modified", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->last_modified);
eina_value_flush(&val);
}
found = EINA_FALSE;
*azy_user_type = azy_user_type_tmp;
return EINA_TRUE;
}
Eina_Value *Empd_Empdd_Playlist_to_azy_value(const Empd_Empdd_Playlist * azy_user_type)
{
Eina_Value *value_struct = NULL;
size_t offset = 0;
Eina_Value_Struct_Member *members = NULL;
Eina_Value *val = NULL;
Eina_Value_Struct_Desc *st_desc;
if (!azy_user_type) return NULL;
st_desc = eina_value_util_struct_desc_new();
members = malloc(2 * sizeof(Eina_Value_Struct_Member));
st_desc->members = members;
st_desc->member_count = 2;
members[0].name = eina_stringshare_add("uri");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_STRINGSHARE, offset);
members[0].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_STRINGSHARE);
members[0].type = EINA_VALUE_TYPE_STRINGSHARE;
members[1].name = eina_stringshare_add("last_modified");
offset = eina_value_util_type_offset(EINA_VALUE_TYPE_TIMESTAMP, offset);
members[1].offset = offset;
offset += eina_value_util_type_size(EINA_VALUE_TYPE_TIMESTAMP);
members[1].type = EINA_VALUE_TYPE_TIMESTAMP;
st_desc->size = offset;
value_struct = eina_value_struct_new(st_desc);
val = eina_value_util_stringshare_new(azy_user_type->uri);
eina_value_struct_value_set(value_struct, "uri", val);
eina_value_free(val);
val = eina_value_util_time_new(azy_user_type->last_modified);
eina_value_struct_value_set(value_struct, "last_modified", val);
eina_value_free(val);
return value_struct;
}
Eina_Bool azy_value_to_Empd_Empdd_Playlist(const Eina_Value *value_struct, Empd_Empdd_Playlist * *azy_user_type)
{
Empd_Empdd_Playlist * azy_user_type_tmp = NULL;
Eina_Value val;
unsigned int arg = 0;
Eina_Bool found = EINA_FALSE;
EINA_SAFETY_ON_NULL_RETURN_VAL(azy_user_type, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(value_struct, EINA_FALSE);
EINA_SAFETY_ON_TRUE_RETURN_VAL(eina_value_type_get(value_struct) != EINA_VALUE_TYPE_STRUCT, EINA_FALSE);
azy_user_type_tmp = Empd_Empdd_Playlist_new();
if ((!arg) && eina_value_struct_value_get(value_struct, "uri", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
if (arg)
{
char *str = NULL;
if (eina_value_get(&val, &str))
azy_user_type_tmp->uri = eina_stringshare_add(str);
}
else
eina_value_util_stringshare_copy(&val, &azy_user_type_tmp->uri);
eina_value_flush(&val);
}
found = EINA_FALSE;
if ((!arg) && eina_value_struct_value_get(value_struct, "last_modified", &val))
found = EINA_TRUE;
else
{
char buf[128];
snprintf(buf, sizeof(buf), "arg%d", arg++);
if (eina_value_struct_value_get(value_struct, buf, &val))
found = EINA_TRUE;
}
if (found)
{
eina_value_get(&val, &azy_user_type_tmp->last_modified);
eina_value_flush(&val);
}
found = EINA_FALSE;
*azy_user_type = azy_user_type_tmp;
return EINA_TRUE;
}

23
src/bin/Empd_Common_Azy.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef Empd_Common_AZY_H
#define Empd_Common_AZY_H
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <Eina.h>
#include "Empd_Common.h"
Eina_Value *Empd_Empdd_Song_to_azy_value(const Empd_Empdd_Song * azy_user_type) EINA_WARN_UNUSED_RESULT;
Eina_Bool azy_value_to_Empd_Empdd_Song(const Eina_Value *value_struct, Empd_Empdd_Song ** azy_user_type);
Eina_Value *Array_Empd_Empdd_Song_to_azy_value(const Eina_List * azy_user_type) EINA_WARN_UNUSED_RESULT;
Eina_Bool azy_value_to_Array_Empd_Empdd_Song(const Eina_Value *value_array, Eina_List ** azy_user_type);
Eina_Value *Empd_Array_Songs_to_azy_value(const Empd_Array_Songs * azy_user_type) EINA_WARN_UNUSED_RESULT;
Eina_Bool azy_value_to_Empd_Array_Songs(const Eina_Value *value_struct, Empd_Array_Songs ** azy_user_type);
Eina_Value *Empd_Empdd_File_to_azy_value(const Empd_Empdd_File * azy_user_type) EINA_WARN_UNUSED_RESULT;
Eina_Bool azy_value_to_Empd_Empdd_File(const Eina_Value *value_struct, Empd_Empdd_File ** azy_user_type);
Eina_Value *Empd_Empdd_Directory_to_azy_value(const Empd_Empdd_Directory * azy_user_type) EINA_WARN_UNUSED_RESULT;
Eina_Bool azy_value_to_Empd_Empdd_Directory(const Eina_Value *value_struct, Empd_Empdd_Directory ** azy_user_type);
Eina_Value *Empd_Empdd_Playlist_to_azy_value(const Empd_Empdd_Playlist * azy_user_type) EINA_WARN_UNUSED_RESULT;
Eina_Bool azy_value_to_Empd_Empdd_Playlist(const Eina_Value *value_struct, Empd_Empdd_Playlist ** azy_user_type);
#endif

8
src/bin/Makefile.mk
View File

@ -44,8 +44,10 @@ $(AZY_SRC)
src/bin/empc.c: $(AZY_SRC) $(ELDBUS_SRC)
if HAVE_AZY_PARSER
$(AZY_SRC): src/bin/empdd.azy
@AZY_PARSER@ -H -o $(top_builddir)/src/bin src/bin/empdd.azy
endif
$(ELDBUS_SRC): src/bin/empdd.xml
@cd $(top_builddir)/src/bin && \
@ -57,7 +59,11 @@ src/bin/empdd.azy \
$(AZY_SRC) \
$(ELDBUS_SRC)
MAINTAINERCLEANFILES += $(ELDBUS_SRC) $(AZY_SRC)
MAINTAINERCLEANFILES += $(ELDBUS_SRC)
if HAVE_AZY_PARSER
MAINTAINERCLEANFILES += $(AZY_SRC)
endif
src_bin_empdd_CPPFLAGS = \
$(AM_CFLAGS) \