IOIMAGE_API IoImage *IoImage_newWithImage_(void *state, Image* image)
{
IoImage* self = IoImage_new(state);
DATA(self)->image = image;
DATA(self)->buffer = IoSeq_newWithData_length_(state, Image_data(image), Image_sizeInBytes(image));
Image_setExternalUArray_(image, IoSeq_rawUArray(DATA(self)->buffer));
return self;
}
IO_METHOD(IoNumber, asUint32Buffer)
{
/*doc Number asUint32Buffer
Returns a Sequence containing a 4 byte representation of the uint32 value of the receiver.
*/
uint32_t i = (int)DATA(self);
return IoSeq_newWithData_length_(IOSTATE, (unsigned char *)&i, sizeof(uint32_t));
}
IO_METHOD(IoNumber, asCharacter)
{
/*doc Number asCharacter
Returns a String containing a single character whose
value is the value of the first byte of the receiver.
Returns nil if the number has no valid UCS mapping.
*/
double d =DATA(self);
long ld = d;
if (d < 0 || d != ld)
{
return IONIL(self);
}
else
{
uint32_t i = io_uint32InBigEndian((uint32_t)d);
int bytes = countBytes(ld);
IoSeq *s;
if (bytes == 0)
{
bytes = 1;
}
if (bytes == 3)
{
bytes = 4;
}
if (bytes > 4)
{
// no valid UCS encoding for this value
return IONIL(self);
}
s = IoSeq_newWithData_length_(IOSTATE, (unsigned char *)&i, bytes);
{
UArray *u = IoSeq_rawUArray(s);
int e = CENCODING_ASCII;
switch (bytes)
{
case 1: e = CENCODING_ASCII; break;
case 2: e = CENCODING_UCS2; break;
case 4: e = CENCODING_UCS4; break;
}
UArray_setEncoding_(u, e);
}
return s;
}
}
IoObject *IoTagDB_symbolForId(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB symbolForId(aNumber)
Returns the TagDB symbol for aNumber.
*/
symbolid_t id = IoMessage_locals_sizetArgAt_(m, locals, 0);
Datum *d = TagDB_symbolForId_(DATA(self), id);
IoSeq *s = IoSeq_newWithData_length_(IOSTATE, Datum_data(d), Datum_size(d));
Datum_free(d);
return s;
}
IoObject *IoTagDB_keyAtIndex(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB keyAtIndex(indexNumber)
Returns the key at the specified index of nil if the index is out of range.
*/
TagDB *tdb = DATA(self);
IoNumber *index = IoMessage_locals_numberArgAt_(m, locals, 0);
Datum *key = TagDB_keyAtIndex_(tdb, CNUMBER(index));
if (!key)
{
return IONIL(self);
}
return IoSeq_newWithData_length_(IOSTATE, (void *)(key->data), key->size);
}
IO_METHOD(IoNumber, asBuffer)
{
/*doc Number asBuffer(optionalNumberOfBytes)
Returns a Buffer containing a the number of bytes specified by
optionalNumberOfBytes (up to the size of a double on the platform) of the reciever.
If no optionalNumberOfBytes is specified, it is assumed to be the number of bytes
in a double on the host platform.
*/
IoNumber *byteCount = IoMessage_locals_valueArgAt_(m, locals, 0);
int bc = sizeof(double);
if (!ISNIL(byteCount))
{
bc = DATA(byteCount);
}
return IoSeq_newWithData_length_(IOSTATE, (unsigned char *)&(DATA(self)), bc);
}
IoObject *IoTagDB_tagsAtKey(IoTagDB *self, IoObject *locals, IoMessage *m)
{
/*doc TagDB tagsAtKey(key)
Returns the tags for the specified key.
*/
TagDB *tdb = DATA(self);
IoSeq *key = IoMessage_locals_seqArgAt_(m, locals, 0);
symbolid_t keyid = TagDB_idForSymbol_size_(tdb, CSTRING(key), IoSeq_rawSize(key));
IoList *tagNames = IoList_new(IOSTATE);
Uint64Array *tags = TagDB_tagsAtKey_(tdb, keyid);
int i;
//printf("IoTagDB_tagsAt self = %p\n", (void *)self);
if (!tags)
{
//printf("IoTagDB_tagsAtKey: no tags found for key\n");
return IONIL(self);
}
for (i = 0; i < Uint64Array_size(tags); i ++)
{
uint64_t tagid = Uint64Array_at_(tags, i);
Datum *name = TagDB_symbolForId_(tdb, tagid);
//printf("tagid %i = %i\n", i, (int)tagid);
//printf("name '%s'\n", (char *)name->data);
if (!name)
{
printf("IoTagDB_tagsAtKey: no datum returned for TagDB_symbolForId_\n");
}
else
{
IoList_rawAppend_(tagNames, IoSeq_newWithData_length_(IOSTATE, name->data, name->size));
Datum_free(name);
}
}
//Uint64Array_free(tags);
return tagNames;
}
IoObject *IoTokyoCabinetPrefixCursor_value(IoObject *self, IoObject *locals, IoMessage *m)
{
/*doc TokyoCabinetPrefixCursor value
Returns current cursor value or nil.
*/
int size;
char *value;
IOASSERT(TokyoCabinetPrefixCursor(self), "invalid TokyoCabinetPrefixCursor");
value = tcbdbcurval(TokyoCabinetPrefixCursor(self), &size);
if (value)
{
IoSeq *s = IoSeq_newWithData_length_(IOSTATE, (unsigned char *)value, size);
free(value);
return s;
}
return IONIL(self);
}
IoSeq *IoSeq_newWithCString_length_(void *state, const char *s, size_t length)
{
return IoSeq_newWithData_length_(state, (unsigned char *)s, length);
}
IoSeq *IoSeq_newWithCString_(void *state, const char *s)
{
return IoSeq_newWithData_length_(state, (unsigned char *)s, strlen(s));
}
