IoObject *IoSocket_asyncUdpRead(IoSocket *self, IoObject *locals, IoMessage *m)
{
/*doc Socket asyncUdpRead(ipAddress, aSeq, readSize)
Reads up to readSize number of bytes from ipAddress into aSeq if data is available.
Returns self immediately if successful. Returns an error object on Error. Returns nil if the socket is disconnected.
*/
IoObject *address = IoMessage_locals_addressArgAt_(m, locals, 0);
UArray *buffer = IoSeq_rawUArray(IoMessage_locals_mutableSeqArgAt_(m, locals, 1));
size_t readSize = IoMessage_locals_sizetArgAt_(m, locals, 2);
if (Socket_udpRead(SOCKET(self), IoSocket_rawAddressFrom_(address), buffer, readSize))
{
return self;
}
else
{
if (Socket_asyncFailed())
{
return SOCKETERROR("Socket udp read failed");
}
else
{
return IONIL(self);
}
}
}
IO_METHOD(IoSeq, leaveThenRemove)
{
/*doc MutableSequence IoSeq_leaveThenRemove(aNumberToLeave, aNumberToRemove)
Leaves aNumberToLeave items then removes aNumberToRemove items. Returns self.
*/
size_t itemsToLeave = IoMessage_locals_sizetArgAt_(m, locals, 0);
size_t itemsToRemove = IoMessage_locals_sizetArgAt_(m, locals, 1);
IO_ASSERT_NOT_SYMBOL(self);
IOASSERT(itemsToLeave > 0 || itemsToRemove > 0, "either aNumberToLeave or aNumberToRemove must be > 0");
UArray_leave_thenRemove_(DATA(self), itemsToLeave, itemsToRemove);
return self;
}
IO_METHOD(IoObject, setMaxRecycledObjects)
{
/*doc System setMaxRecycledObjects(aNumber)
Sets the max number of recycled objects used.
*/
size_t max = IoMessage_locals_sizetArgAt_(m, locals, 0);
IOSTATE->maxRecycledObjects = max;
return self;
}
IO_METHOD(IoSeq, setSize)
{
/*doc Sequence setSize(aNumber)
Sets the length in bytes of the receiver to aNumber. Return self.
*/
size_t len = IoMessage_locals_sizetArgAt_(m, locals, 0);
IO_ASSERT_NOT_SYMBOL(self);
UArray_setSize_(DATA(self), len);
return self;
}
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;
}
IO_METHOD(IoSeq, preallocateToSize)
{
/*doc Sequence preallocateToSize(aNumber)
If needed, resize the memory alloced for the receivers
byte array to be large enough to fit the number of bytes specified by
aNumber. This is useful for pio_reallocating the memory so it doesn't
keep getting allocated as the Sequence is appended to. This operation
will not change the Sequence's length or contents. Returns self.
*/
size_t newSize = IoMessage_locals_sizetArgAt_(m, locals, 0);
IO_ASSERT_NOT_SYMBOL(self);
UArray_sizeTo_(DATA(self), newSize);
return self;
}
IO_METHOD(IoSeq, atInsertSeq)
{
/*doc Sequence atInsertSeq(indexNumber, object)
Calls asString on object and inserts the string at position indexNumber. Returns self.
*/
size_t n = IoMessage_locals_sizetArgAt_(m, locals, 0);
IoSeq *otherSeq = IoMessage_locals_valueAsStringArgAt_(m, locals, 1);
IO_ASSERT_NOT_SYMBOL(self);
IOASSERT(n <= UArray_size(DATA(self)), "insert index out of sequence bounds");
UArray_at_putAll_(DATA(self), n, DATA(otherSeq));
return self;
}
IO_METHOD(IoSeq, insertSeqEvery)
{
/*doc MutableSequence IoSeq_insertSeqEvery(aSequence, aNumberOfItems)
Inserts aSequence every aNumberOfItems. Returns self.
*/
IoSeq *otherSeq = IoMessage_locals_valueAsStringArgAt_(m, locals, 0);
size_t itemCount = IoMessage_locals_sizetArgAt_(m, locals, 1);
IO_ASSERT_NOT_SYMBOL(self);
IOASSERT(itemCount > 0, "aNumberOfItems must be > 0");
IOASSERT(itemCount <= UArray_size(DATA(self)), "aNumberOfItems out of sequence bounds");
UArray_insert_every_(DATA(self), DATA(otherSeq), itemCount);
return self;
}
IoObject *IoRandom_bytes(IoObject *self, IoObject *locals, IoMessage *m)
{
/*doc Random bytes(count)
Returns a Sequence of size count containing random bytes.
*/
size_t i, count = IoMessage_locals_sizetArgAt_(m, locals, 0);
UArray *a;
uint8_t *d = malloc(count);
for(i = 0; i < count; i ++)
{
d[i] = (uint8_t)(RandomGen_randomInt(DATA(self)) & 255);
}
a = UArray_newWithData_type_size_copy_(d, CTYPE_uint8_t, count, 0);
UArray_setEncoding_(a, CENCODING_NUMBER);
return IoSeq_newWithUArray_copy_(IOSTATE, a, 0);
}
IO_METHOD(IoSeq, at)
{
/*doc Sequence at(aNumber)
Returns a value at the index specified by aNumber.
Returns nil if the index is out of bounds.
*/
size_t i = IoMessage_locals_sizetArgAt_(m, locals, 0);
UArray *a = DATA(self);
//IOASSERT((i < UArray_size(DATA(self))), "index out of bounds");
if(i >= UArray_size(DATA(self))) return IONIL(self);
if(UArray_isFloatType(a))
{
return IONUMBER(UArray_doubleAt_(a, i));
}
else
{
return IONUMBER(UArray_longAt_(a, i));
}
}
UArray *IoFile_readUArrayOfLength_(IoFile *self, IoObject *locals, IoMessage *m)
{
size_t length = IoMessage_locals_sizetArgAt_(m, locals, 0);
UArray *ba = UArray_new();
IoFile_assertOpen(self, locals, m);
UArray_readNumberOfItems_fromCStream_(ba, length, DATA(self)->stream);
if (ferror(DATA(self)->stream) != 0)
{
clearerr(DATA(self)->stream);
UArray_free(ba);
IoState_error_(IOSTATE, m, "error reading file '%s'", UTF8CSTRING(DATA(self)->path));
}
if (!UArray_size(ba))
{
UArray_free(ba);
return NULL;
}
return ba;
}
