/** Adds an annotation to the member.
* \relates adbus_Member
*/
void adbus_mbr_annotate(
adbus_Member* m,
const char* name,
int nameSize,
const char* value,
int valueSize)
{
name = (nameSize >= 0)
? adbusI_strndup(name, nameSize)
: adbusI_strdup(name);
value = (valueSize >= 0)
? adbusI_strndup(value, valueSize)
: adbusI_strdup(value);
int added;
dh_Iter ki = dh_put(StringPair, &m->annotations, name, &added);
if (!added) {
free((char*) dh_key(&m->annotations, ki));
free(dh_val(&m->annotations, ki));
}
dh_key(&m->annotations, ki) = name;
dh_val(&m->annotations, ki) = (char*) value;
}
static void FreeMember(adbus_Member* m)
{
if (!m)
return;
if (m->release[0])
m->release[0](m->ruser[0]);
if (m->release[1])
m->release[1](m->ruser[1]);
for (dh_Iter ii = dh_begin(&m->annotations); ii != dh_end(&m->annotations); ++ii) {
if (dh_exist(&m->annotations, ii)) {
free((char*) dh_key(&m->annotations, ii));
free(dh_val(&m->annotations, ii));
}
}
dh_free(StringPair, &m->annotations);
for (size_t i = 0; i < dv_size(&m->arguments); i++) {
free(dv_a(&m->arguments, i));
}
dv_free(String, &m->arguments);
for (size_t j = 0; j < dv_size(&m->returns); j++) {
free(dv_a(&m->returns, j));
}
dv_free(String, &m->returns);
free(m->propertyType);
free((char*) m->name.str);
free(m);
}
static adbus_Member* AddMethod(
adbus_Interface* i,
adbusI_MemberType type,
const char* name,
int size)
{
if (size < 0)
size = strlen(name);
adbus_Member* m = NEW(adbus_Member);
m->interface = i;
m->type = type;
m->name.str = adbusI_strndup(name, size);
m->name.sz = size;
int ret;
dh_Iter ki = dh_put(MemberPtr, &i->members, m->name, &ret);
if (!ret) {
FreeMember(dh_val(&i->members, ki));
}
dh_key(&i->members, ki) = m->name;
dh_val(&i->members, ki) = m;
return m;
}
static void IntrospectAnnotations(adbus_Member* m, d_String* out)
{
for (dh_Iter ai = dh_begin(&m->annotations); ai != dh_end(&m->annotations); ++ai) {
if (dh_exist(&m->annotations, ai)) {
ds_cat(out, "\t\t\t<annotation name=\"");
ds_cat(out, dh_key(&m->annotations, ai));
ds_cat(out, "\" value=\"");
ds_cat(out, dh_val(&m->annotations, ai));
ds_cat(out, "\"/>\n");
}
}
}
dh_key dh_key::take_ownership(pointer _ptr)
{
throw_error_if_not(_ptr);
return dh_key(_ptr, deleter);
}
/* -------------------------------------------------------------------------- */
int adbusI_serv_requestname(
adbus_Server* s,
adbus_Remote* r,
const char* name,
uint32_t flags)
{
int added;
dh_Iter ii = dh_put(Service, &s->services, name, &added);
if (added) {
struct Service** pserv = &dh_val(&s->services, ii);
*pserv = NEW(struct Service);
(*pserv)->name = adbusI_strdup(name);
dh_key(&s->services, ii) = (*pserv)->name;
}
struct Service* serv = dh_val(&s->services, ii);
if (dv_size(&serv->queue) == 0) {
struct Service** pserv = dv_push(Service, &r->services, 1);
*pserv = serv;
struct ServiceOwner* o = dv_push(ServiceOwner, &serv->queue, 1);
o->remote = r;
o->allowReplacement = flags & ADBUS_SERVICE_ALLOW_REPLACEMENT;
adbusI_serv_ownerchanged(s, name, NULL, r);
return ADBUS_SERVICE_SUCCESS;
} else if (dv_a(&serv->queue, 0).remote == r) {
struct ServiceOwner* o = &dv_a(&serv->queue, 0);
o->allowReplacement = flags & ADBUS_SERVICE_ALLOW_REPLACEMENT;
return ADBUS_SERVICE_REQUEST_ALREADY_OWNER;
} else if (flags & ADBUS_SERVICE_REPLACE_EXISTING && dv_a(&serv->queue, 0).allowReplacement) {
// We are replacing the owner, so we need to be removed from the queue
adbusI_serv_releasename(s, r, serv->name);
struct ServiceOwner* o = &dv_a(&serv->queue, 0);
adbus_Remote* old = o->remote;
adbusI_serv_removeServiceFromRemote(old, serv);
o->remote = r;
o->allowReplacement = flags & ADBUS_SERVICE_ALLOW_REPLACEMENT;
adbusI_serv_ownerchanged(s, name, old, r);
return ADBUS_SERVICE_SUCCESS;
} else if (!(flags & ADBUS_SERVICE_DO_NOT_QUEUE)) {
// If we are already in the queue then we just update the entry,
// otherwise we add a new entry
struct ServiceOwner* o = NULL;
for (size_t i = 0; i < dv_size(&serv->queue); i++) {
if (dv_a(&serv->queue, i).remote == r) {
o = &dv_a(&serv->queue, i);
break;
}
}
if (o == NULL) {
struct Service** pserv = dv_push(Service, &r->services, 1);
*pserv = serv;
o = dv_push(ServiceOwner, &serv->queue, 1);
}
o->remote = r;
o->allowReplacement = flags & ADBUS_SERVICE_ALLOW_REPLACEMENT;
return ADBUS_SERVICE_REQUEST_IN_QUEUE;
} else {
// If we already in the queue then we need to be removed
adbusI_serv_releasename(s, r, serv->name);
return ADBUS_SERVICE_REQUEST_FAILED;
}
}
