/*

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of JITCraft.

  *

  * JITCraft is free software: you can redistribute it and/or modify it under

  * the terms of the GNU General Public License as published by the Free

  * Software Foundation, either version 3 of the License, or (at your option)

  * any later version.

  * 

  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along with

  * JITCraft. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _include_jitcraft_array_h_

 #define _include_jitcraft_array_h_

 #include "Heap.h"

 #include "Types.h"

 namespace jc {

 class ArrayMap;

 class Array : public Object

 {

     friend class ArrayMap;

     OBJECT_FIELD(uint32, nelements);

     OBJECT_FIELD(VoidPtr, elements);

   private:

     void init(unsigned nelements);

     void *vec() {

         return READ_FIELD(elements);

     }

   public:

     static Array *New(Zone *zone, ArrayMap *map, uint32 elements,

                       Heap::Tenure = Heap::Tenure_Default);

     uint32 nelements() {

         return READ_FIELD(nelements);

     }

     inline int *int32Vec();

     inline float *floatVec();

     inline Object **objVec();

     int readInt32(size_t index) {

         assert(index < nelements());

         return int32Vec()[index];

     }

     void writeInt32(size_t index, int i) {

         assert(index < nelements());

         int32Vec()[index] = i;

     }

     float readFloat(size_t index) {

         assert(index < nelements());

         return floatVec()[index];

     }

     void writeFloat(size_t index, float f) {

         assert(index < nelements());

         floatVec()[index] = f;

     }

     Object *readObject(size_t index) {

         assert(index < nelements());

         return objVec()[index];

     }

     void writeObject(Zone *zone, size_t index, Object *ptr) {

         assert(index < nelements());

         write(zone, &objVec()[index], ptr);

     }

     static Array *cast(Object *obj) {

         assert(obj->is(MapKind_Array));

         return reinterpret_cast<Array *>(obj);

     }

 };

 class ArrayMap : public Map

 {

     OBJECT_FIELD(Type *, type);

     OBJECT_FIELD(ArrayMap *, contained);

   private:

     void init(Type *type, ArrayMap *contained) {

         WRITE_FIELD_OBJ_NO_BARRIER(type, type);

         WRITE_FIELD_OBJ_NO_BARRIER(contained, contained);

     }

   public:

     static ArrayMap *New(Zone *zone, Type *type, ArrayMap *contained);

     Type *type() {

         return Type::cast(READ_FIELD_OBJ(type));

     }

     ArrayMap *contained() {

         return ArrayMap::cast(READ_FIELD_OBJ(contained));

     }

     static ArrayMap *cast(Object *obj) {

         assert(!obj || obj->is(MapKind_MetaArray));

         return reinterpret_cast<ArrayMap *>(obj);

     }

 };

 inline int *

 Array::int32Vec()

 {

     assert(ArrayMap::cast(map())->type()->levels() == 1);

     assert(ArrayMap::cast(map())->type()->contained()->isInt());

     return reinterpret_cast<int *>(vec());

 }

 inline float *

 Array::floatVec()

 {

     assert(ArrayMap::cast(map())->type()->levels() == 1);

     assert(ArrayMap::cast(map())->type()->contained()->isFloat());

     return reinterpret_cast<float *>(vec());

 }

 inline Object **

 Array::objVec()

 {

     assert(ArrayMap::cast(map())->type()->levels() > 1);

     return reinterpret_cast<Object **>(vec());

 }

 }

 #endif // _include_jitcraft_array_h_