IoObject *IoTagDB_atKeyPutTags(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB atKeyPutTags(key, tagNameList)
Sets the tags for key to those in tagNameList. Returns self.
*/
TagDB *tdb = DATA(self);
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
IoList *tagNames = IoMessage_locals_listArgAt_(m, locals, 1);
symbolid_t keyid = TagDB_idForSymbol_size_(tdb, CSTRING(key), IoSeq_rawSize(key));
// debugging check
/*
Datum *keyDatum = TagDB_symbolForId_(tdb, keyid);
printf("%s -> %i\n", CSTRING(key), (int)keyid);
printf("%i -> %s\n", (int)keyid, (char *)(keyDatum->data));
assert(strcmp((char *)(keyDatum->data), (char *)CSTRING(key)) == 0);
Datum_free(keyDatum);
*/
{
Uint64Array *tags = IoTagDB_tagArrayForTagNames_(self, m, tagNames);
TagDB_begin(tdb);
TagDB_atKey_putTags_(tdb, keyid, tags);
TagDB_commit(tdb);
Uint64Array_free(tags);
}
return self;
}
IoObject *IoSyslog_open(IoSyslog *self, IoObject *locals, IoMessage *m)
{
/*doc Syslog open(aPriority, someOptions, optionalIdentity)
Opens the syslog for writing. optionalIdentity need not be entered
and will default to the name of the distribution of Io you are running
or if you have embedded Io into your application and set
Lobby distribution = "foo", it will be set to "foo".
*/
int syslog_facility, syslog_options;
//int i, max;
char *syslog_ident;
if (DATA(self)->syslog_opened)
{
IoState_error_(IOSTATE, m, "System log is already open");
return IONIL(self);
}
{
DATA(self)->facility = IOREF(IoMessage_locals_numberArgAt_(m, locals, 0));
if (ISNIL(DATA(self)->facility))
{
syslog_facility = LOG_USER;
}
else
{
syslog_facility = IoObject_dataUint32(DATA(self)->facility);
}
DATA(self)->options = IOREF(IoMessage_locals_listArgAt_(m, locals, 1));
syslog_options = 0;
if (ISNIL(DATA(self)->options))
{
syslog_options = LOG_PID | LOG_CONS;
}
else
{
List *list = IoList_rawList(DATA(self)->options);
LIST_FOREACH(list, i, v,
syslog_options |= (int)CNUMBER(v);
);
}
syslog_ident = (char *)IOSYMBOL_BYTES(DATA(self)->ident);
if ((strlen(syslog_ident) == 0) || ISNIL(DATA(self)->ident))
{
char *s = CSTRING(IoState_doCString_(IOSTATE, "Lobby distribution"));
strncpy(syslog_ident, s, strlen(s));
}
openlog(syslog_ident, syslog_options, syslog_facility);
DATA(self)->syslog_opened = 1;
DATA(self)->syslog_mask = setlogmask(0);
setlogmask(DATA(self)->syslog_mask);
}
/*doc Memcached getMulti(keys)
Asks memcached to retrieve data corresponding to the list of keys.
Returns a Map with the results.
If some of the keys appearing in a retrieval request are not sent back
by the server in the item list this means that the server does not
hold items with such keys
*/
IoObject *IoMemcached_getMulti(IoMemcached *self, IoObject *locals, IoMessage *m)
{
IoList *keys_list = IoMessage_locals_listArgAt_(m, locals, 0);
size_t keys_list_size = IoList_rawSize(keys_list);
IoObject *results_map = IoMap_new(IOSTATE);
if(keys_list_size == 0)
return results_map;
int i;
for(i = 0; i < keys_list_size; i++) {
IoSeq *key = IoList_rawAt_(keys_list, i);
IOASSERT(ISSEQ(key), "key must be a Sequence");
IOASSERT(IOSEQ_LENGTH(key) > 0, "key cannot be an empty Sequence");
IOASSERT(IOSEQ_LENGTH(key) < MEMCACHED_MAX_KEY, "key is too long");
}
const char **ckeys = (const char **) malloc(sizeof(const char *) * keys_list_size);
size_t *ckey_lengths = (size_t *) malloc(sizeof(size_t) * keys_list_size);
for(i = 0; i < keys_list_size; i++) {
ckeys[i] = CSTRING(IoList_rawAt_(keys_list, i));
ckey_lengths[i] = strlen(ckeys[i]);
}
memcached_return_t rc = memcached_mget(DATA(self)->mc, ckeys, ckey_lengths, keys_list_size);
free(ckeys);
free(ckey_lengths);
char returned_key[MEMCACHED_MAX_KEY], *returned_value;
size_t returned_key_length, returned_value_length;
uint32_t flags;
returned_value = memcached_fetch(DATA(self)->mc,
returned_key, &returned_key_length,
&returned_value_length, &flags, &rc
);
while(returned_value != NULL) {
IoMap_rawAtPut(results_map,
IoSeq_newSymbolWithData_length_(IOSTATE, returned_key, returned_key_length),
IoMemcached_deserialize(self, returned_value, returned_value_length, flags)
);
free(returned_value);
returned_value = memcached_fetch(DATA(self)->mc,
returned_key, &returned_key_length,
&returned_value_length, &flags, &rc
);
}
return results_map;
}
IoObject *IoTagDB_keysForTags(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB keysForTags(aTagNameList)
Returns list of keys whose tags contain all of the tags in aTagNameList.
*/
TagDB *tdb = DATA(self);
IoList *tagNames = IoMessage_locals_listArgAt_(m, locals, 0);
Uint64Array *tags = IoTagDB_tagArrayForTagNames_(self, m, tagNames);
Uint64Array *keys = TagDB_keysForTags_(tdb, tags);
UArray *keyArray = UArray_newWithData_type_size_copy_(Uint64Array_data(keys), CTYPE_uint64_t, Uint64Array_size(keys), 1);
IoSeq *keySeq = IoSeq_newWithUArray_copy_(IOSTATE, keyArray, 0);
Uint64Array_free(tags);
return keySeq;
}
IO_METHOD(IoMessage, setArguments)
{
/*doc Message setArguments(aListOfMessages)
Sets the arguments of the receiver to deep copies of
those contained in aListOfMessages. Returns self.
*/
IoList *ioList = IoMessage_locals_listArgAt_(m, locals, 0);
List *newArgs = IoList_rawList(ioList);
List_removeAll(DATA(self)->args);
LIST_FOREACH(newArgs, i, argMessage,
if (!ISMESSAGE((IoMessage *)argMessage))
{
IoState_error_(IOSTATE, m, "arguments_() takes a list containing only Message objects");
}
List_append_(DATA(self)->args, IOREF((IoMessage *)argMessage));
);
IO_METHOD(IoSeq, findSeqs)
{
/*doc Sequence findSeqs(listOfSequences, optionalStartIndex)
Returns an object with two slots - an \"index\" slot which contains
the first occurrence of any of the sequences in listOfSequences found
in the receiver after the startIndex, and a \"match\" slot, which
contains a reference to the matching sequence from listOfSequences.
If no startIndex is specified, the search starts at index 0.
nil is returned if no occurences are found.
*/
IoList *others = IoMessage_locals_listArgAt_(m, locals, 0);
List *delims = IoList_rawList(others);
long f = 0;
long firstIndex = -1;
size_t match = 0;
if (IoMessage_argCount(m) > 1)
{
f = IoMessage_locals_longArgAt_(m, locals, 1);
}
{
size_t index;
LIST_FOREACH(delims, i, s,
if (!ISSEQ((IoSeq *)s))
{
IoState_error_(IOSTATE, m, "requires Sequences as arguments, not %ss", IoObject_name((IoSeq *)s));
}
index = UArray_find_from_(DATA(self), DATA(((IoSeq *)s)), f);
if(index != -1 && (firstIndex == -1 || index < firstIndex))
{
firstIndex = (long)index;
match = i;
}
);
}
