static EjsVar *arrayConstructor(Ejs *ejs, EjsArray *ap, int argc, EjsVar **argv)
{
EjsArray *args;
EjsVar *arg0, **src, **dest;
int size, i;
mprAssert(argc == 1 && ejsIsArray(argv[0]));
args = (EjsArray*) argv[0];
if (args->length == 0) {
return 0;
}
size = 0;
arg0 = getArrayProperty(ejs, args, 0);
if (args->length == 1 && ejsIsNumber(arg0)) {
/*
* x = new Array(size);
*/
size = ejsGetInt(arg0);
if (size > 0 && growArray(ejs, ap, size) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
} else {
/*
* x = new Array(element0, element1, ..., elementN):
*/
size = args->length;
if (size > 0 && growArray(ejs, ap, size) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
src = args->data;
dest = ap->data;
for (i = 0; i < size; i++) {
dest[i] = src[i];
}
}
ap->length = size;
return (EjsVar*) ap;
}
static EjsArray *cloneArray(Ejs *ejs, EjsArray *ap, bool deep)
{
EjsArray *newArray;
EjsVar **dest, **src;
int i;
newArray = (EjsArray*) ejsCopyObject(ejs, (EjsObject*) ap, deep);
if (newArray == 0) {
ejsThrowMemoryError(ejs);
return 0;
}
if (ap->length > 0) {
if (growArray(ejs, newArray, ap->length) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
src = ap->data;
dest = newArray->data;
if (deep) {
for (i = 0; i < ap->length; i++) {
dest[i] = ejsCloneVar(ejs, src[i], 1);
}
} else {
memcpy(dest, src, ap->length * sizeof(EjsVar*));
}
}
return newArray;
}
PUBLIC EjsArray *ejsCloneArray(Ejs *ejs, EjsArray *ap, bool deep)
{
EjsArray *newArray;
EjsObj **dest, **src;
int i;
if ((newArray = ejsClonePot(ejs, ap, deep)) == 0) {
ejsThrowMemoryError(ejs);
return 0;
}
if (ap->length > 0) {
if (growArray(ejs, newArray, ap->length) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
src = ap->data;
dest = newArray->data;
if (deep) {
for (i = 0; i < ap->length; i++) {
dest[i] = ejsClone(ejs, src[i], deep);
}
} else {
memcpy(dest, src, ap->length * sizeof(EjsObj*));
}
}
return newArray;
}
/*
* function unshift(...args): Array
*/
static EjsVar *unshiftArray(Ejs *ejs, EjsArray *ap, int argc, EjsVar **argv)
{
EjsArray *args;
EjsVar **src, **dest;
int i, delta, endInsert;
mprAssert(argc == 1 && ejsIsArray(argv[0]));
args = (EjsArray*) argv[0];
if (args->length <= 0) {
return (EjsVar*) ap;
}
if (growArray(ejs, ap, ap->length + args->length) < 0) {
return 0;
}
delta = args->length;
dest = ap->data;
src = args->data;
endInsert = delta;
for (i = ap->length - 1; i >= endInsert; i--) {
dest[i] = dest[i - delta];
}
for (i = 0; i < delta; i++) {
dest[i] = src[i];
}
return (EjsVar*) ap;
}
void ScannedModel::addPoint(float x, float y, float z) {
if(nextFreeIndex + 2 >= arraySize)
growArray();
vectArray[nextFreeIndex++] = x;
vectArray[nextFreeIndex++] = y;
vectArray[nextFreeIndex++] = z;
}
/*
* Concatenate the supplied elements with the array to create a new array. If any arguments specify an array,
* their elements are catenated. This is a one level deep copy.
*
* function concat(...args): Array
*/
static EjsVar *concatArray(Ejs *ejs, EjsArray *ap, int argc, EjsVar **argv)
{
EjsArray *args, *newArray, *vpa;
EjsVar *vp, **src, **dest;
int i, k, next;
mprAssert(argc == 1 && ejsIsArray(argv[0]));
args = ((EjsArray*) argv[0]);
newArray = ejsCreateArray(ejs, ap->length);
src = ap->data;
dest = newArray->data;
/*
* Copy the original array
*/
for (next = 0; next < ap->length; next++) {
dest[next] = src[next];
}
/*
* Copy the args. If any element is itself an array, then flatten it and copy its elements.
*/
for (i = 0; i < args->length; i++) {
vp = args->data[i];
if (ejsIsArray(vp)) {
vpa = (EjsArray*) vp;
if (growArray(ejs, newArray, next + vpa->length) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
dest = newArray->data;
dest = newArray->data;
for (k = 0; k < vpa->length; k++) {
dest[next++] = vpa->data[k];
}
} else {
if (growArray(ejs, newArray, next + 1) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
dest[next++] = vp;
}
}
return (EjsVar*) newArray;
}
static int checkSlot(Ejs *ejs, EjsArray *ap, int slotNum)
{
if (slotNum < 0) {
if (!ap->obj.var.dynamic) {
ejsThrowTypeError(ejs, "Object is not dynamic");
return EJS_ERR;
}
slotNum = ap->length;
if (growArray(ejs, ap, ap->length + 1) < 0) {
ejsThrowMemoryError(ejs);
return EJS_ERR;
}
} else if (slotNum >= ap->length) {
if (growArray(ejs, ap, slotNum + 1) < 0) {
ejsThrowMemoryError(ejs);
return EJS_ERR;
}
}
return slotNum;
}
PUBLIC EjsArray *ejsCreateArray(Ejs *ejs, int size)
{
EjsArray *ap;
/*
No need to invoke constructor
*/
if ((ap = ejsCreatePot(ejs, ESV(Array), 0)) != 0) {
ap->length = 0;
if (size > 0 && growArray(ejs, ap, size) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
}
return ap;
}
EjsArray *ejsCreateArray(Ejs *ejs, int size)
{
EjsArray *ap;
/*
* No need to invoke constructor
*/
ap = (EjsArray*) ejsCreateObject(ejs, ejs->arrayType, 0);
if (ap != 0) {
ap->length = 0;
if (size > 0 && growArray(ejs, ap, size) < 0) {
ejsThrowMemoryError(ejs);
return 0;
}
}
ejsSetDebugName(ap, "array instance");
return ap;
}
/*
Append items to the end of the array.
@return Returns the new length of the array.
function push(...items): Number
*/
static EjsNumber *pushArray(Ejs *ejs, EjsArray *ap, int argc, EjsAny **argv)
{
EjsArray *args;
EjsObj **src, **dest;
int i, oldLen;
assert(argc == 1 && ejsIs(ejs, argv[0], Array));
args = (EjsArray*) argv[0];
oldLen = ap->length;
if (growArray(ejs, ap, ap->length + args->length) < 0) {
return 0;
}
dest = ap->data;
src = args->data;
for (i = 0; i < args->length; i++) {
dest[i + oldLen] = src[i];
}
return ejsCreateNumber(ejs, ap->length);
}
Car* Lane::populateQueue(){
int currentIndex = 0;
int currentSize = 10;
Car* cars = new Car[currentSize];
ifstream input;
input.open("input.txt");
string dontCare;
int startTime = 0;
int speed = 0;
while (!input.eof())
{
input >> dontCare;
input >> dontCare;
input >> dontCare;
input >> dontCare;
if(!input.eof()){
if(currentIndex == currentSize)
{
cars = growArray(cars,currentSize);
currentSize = currentSize * 2;
}
input >> startTime;
input >> dontCare;
input >> dontCare;
input >> speed;
cars[currentIndex].setStartTime(startTime);
cars[currentIndex].setMPH(speed);
currentIndex++;
input >> dontCare;
//cout << startTime << " and " << speed <<endl;
}
}
input.close();
//Somewhere here I need to start sorting the cars by time.
numberOfCars = currentIndex; //Let the lane know how many cars it will be taking care of.
return cars; // Assuming this works for now.
}
/*
* Insert elements. Insert elements at the specified position. Negative indicies are measured from the end of the array.
* @return Returns a the original array.
*
* function insert(pos: Number, ...args): Array
*/
static EjsVar *insertArray(Ejs *ejs, EjsArray *ap, int argc, EjsVar **argv)
{
EjsArray *args;
EjsVar **src, **dest;
int i, pos, delta, endInsert;
mprAssert(argc == 2 && ejsIsArray(argv[1]));
pos = ejsGetInt(argv[0]);
if (pos < 0) {
pos += ap->length;
}
if (pos < 0) {
pos = 0;
}
if (pos >= ap->length) {
pos = ap->length;
}
args = (EjsArray*) argv[1];
if (args->length <= 0) {
return (EjsVar*) ap;
}
if (growArray(ejs, ap, ap->length + args->length) < 0) {
return 0;
}
delta = args->length;
dest = ap->data;
src = args->data;
endInsert = pos + delta;
for (i = ap->length - 1; i >= endInsert; i--) {
dest[i] = dest[i - delta];
}
for (i = 0; i < delta; i++) {
dest[pos++] = src[i];
}
return (EjsVar*) ap;
}
static EjsVar *setArrayLength(Ejs *ejs, EjsArray *ap, int argc, EjsVar **argv)
{
EjsVar **data, **dest;
int length;
mprAssert(argc == 1 && ejsIsNumber(argv[0]));
mprAssert(ejsIsArray(ap));
length = (int) ((EjsNumber*) argv[0])->value;
if (length < 0) {
length = 0;
}
if (length > ap->length) {
if (growArray(ejs, ap, length) < 0) {
return 0;
}
data = ap->data;
for (dest = &data[ap->length]; dest < &data[length]; dest++) {
*dest = 0;
}
}
ap->length = length;
return 0;
}
void IntQueue::add(int32_t i)
{
if (lastIndex == arraySize)
growArray();
array[lastIndex++] = i;
}
/*
* Insert, remove or replace array elements. Return the removed elements.
*
* function splice(start: Number, deleteCount: Number, ...values): Array
*
*/
static EjsVar *spliceArray(Ejs *ejs, EjsArray *ap, int argc, EjsVar **argv)
{
EjsArray *result, *values;
EjsVar **data, **dest, **items;
int start, deleteCount, i, delta, endInsert, oldLen;
mprAssert(1 <= argc && argc <= 3);
start = ejsGetInt(argv[0]);
deleteCount = ejsGetInt(argv[1]);
values = (EjsArray*) argv[2];
if (ap->length == 0) {
if (deleteCount <= 0) {
return (EjsVar*) ap;
}
ejsThrowArgError(ejs, "Array is empty");
return 0;
}
if (start < 0) {
start += ap->length;
}
if (start < 0) {
start = 0;
}
if (start >= ap->length) {
start = ap->length - 1;
}
if (deleteCount < 0) {
deleteCount = ap->length - start + 1;
}
if (deleteCount > ap->length) {
deleteCount = ap->length;
}
result = ejsCreateArray(ejs, deleteCount);
if (result == 0) {
ejsThrowMemoryError(ejs);
return 0;
}
data = ap->data;
dest = result->data;
items = values->data;
/*
* Copy removed items to the result
*/
for (i = 0; i < deleteCount; i++) {
dest[i] = data[i + start];
}
oldLen = ap->length;
delta = values->length - deleteCount;
if (delta > 0) {
/*
* Make room for items to insert
*/
if (growArray(ejs, ap, ap->length + delta) < 0) {
return 0;
}
data = ap->data;
endInsert = start + delta;
for (i = ap->length - 1; i >= endInsert; i--) {
data[i] = data[i - delta];
}
} else {
ap->length += delta;
}
/*
* Copy in new values
*/
for (i = 0; i < values->length; i++) {
data[start + i] = items[i];
}
/*
* Remove holes
*/
if (delta < 0) {
for (i = start + values->length; i < oldLen; i++) {
data[i] = data[i - delta];
}
}
return (EjsVar*) result;
}