/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of SourcePawn.

  *

  * SourcePawn 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.

  * 

  * SourcePawn 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

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

  */

 #ifndef _include_jc_structure_h_

 #define _include_jc_structure_h_

 #include "Objects.h"

 #include "Handles.h"

 #include "Vector.h"

 #include "Heap.h"

 namespace ke {

 class Type;

 class String;

 class FixedArray;

 class StructType;

 // When describing composite structures, the GC must be able to trace interior

 // references to Objects. To make this possible, maps that describe composite

 // structures must provide a list of offsets into their objects that are

 // traceable. StructureBufferBuilder assists with this.

 class StructureBufferBuilder

 {

   public:

     StructureBufferBuilder();

     bool add(Handle<Type> type, unsigned *offset);

     unsigned structureSize() const {

         return size_;

     }

     unsigned traceableOffsetCount() const {

         return offsets_.length();

     }

     const unsigned *offsets() const {

         return offsets_.buffer();

     }

   private:

     Vector<unsigned> offsets_;

     unsigned size_;

 };

 // Represents a property descriptor for a structure field.

 class Descriptor : public Object

 {

   public:

     enum Visibility {

         Private,

         Protected,

         Public

     };

   private:

     // The name of the field.

     Barriered<String> name_;

     // The type of the field.

     Barriered<Type> type_;

     // The offset into an object at which this field can be accessed.

     unsigned offset_;

     Visibility visibility_;

   public:

     static Descriptor *New(Zone *zone, Handle<String> name, Handle<Type> type, Visibility visibility);

     String *name() {

         return name_;

     }

     Type *type() {

         return type_;

     }

     unsigned offset() {

         assert(offset_ != unsigned(-1));

         return offset_;

     }

     void setOffset(unsigned offset) {

         assert(offset_ == unsigned(-1));

         offset_ = offset;

     }

     // Begin GC descriptor.

     static inline size_t offsetOfName() {

         return OFFSETOF(Descriptor, name_);

     }

     static inline size_t offsetOfType() {

         return OFFSETOF(Descriptor, type_);

     }

     // End GC descriptor.

     static inline Descriptor *cast(Object *obj) {

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

         return reinterpret_cast<Descriptor *>(obj);

     }

 };

 class StructMap : public Map

 {

     unsigned structureSize_;

     unsigned traceOffsetCount_;

     Barriered<StructType> type_;

     // List of descriptors which must be allocated upon initialization.

     Barriered<FixedArray> composed_;

   public:

     static StructMap *New(Zone *zone, const StructureBufferBuilder &builder, Handle<StructType> type);

     unsigned structureSize() {

         return structureSize_;

     }

     unsigned traceOffsetCount() {

         return traceOffsetCount_;

     }

     const unsigned *traceOffsets() {

         return reinterpret_cast<unsigned *>(this + 1);

     }

     size_t objSize() {

         return sizeof(StructMap) + sizeof(unsigned) * traceOffsetCount();

     }

     StructType *type() {

         return type_;

     }

     FixedArray *composed() {

         return composed_;

     }

     void setType(StructType *type) {

         assert(!type_);

         type_ = type;

     }

     // Begin GC descriptors.

     static inline size_t offsetOfType() {

         return OFFSETOF(StructMap, type_);

     }

     static inline size_t offsetOfComposed() {

         return OFFSETOF(StructMap, composed_);

     }

     // End GC descriptors.

     static inline StructMap *cast(Object *obj) {

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

         return reinterpret_cast<StructMap *>(obj);

     }

 };

 class Struct : public Object

 {

   public:

     static Struct *New(Zone *zone, Handle<StructMap> map, Heap::Tenure tenure = Heap::Tenure_Default);

     static bool Copy(Zone *zone, Handle<Struct> dest, Handle<Struct> src);

     StructMap *map() {

         return StructMap::cast(Object::map());

     }

     void *ref(Descriptor *desc) {

         return reinterpret_cast<Address>(this) + offsetOfSlotOffset(desc->offset());

     }

     static inline size_t SizeFor(StructMap *map) {

         return Max(sizeof(Struct) + map->structureSize(), kMinObjectSize);

     }

     template <typename T> T get(Descriptor *desc) {

         return *reinterpret_cast<T *>(ref(desc));

     }

     // This must NOT be used with any Object * type!

     // :TODO: prevent with type system

     template <typename T> void set(Descriptor *desc, const T &t) {

         *reinterpret_cast<T *>(ref(desc)) = t;

     }

     void set(Zone *zone, Descriptor *desc, Object *obj) {

         // :TODO: write barrier

         *reinterpret_cast<Object **>(

             reinterpret_cast<Address>(this) +

             offsetOfSlotOffset(desc->offset())) = obj;

     }

     static inline size_t offsetOfSlotOffset(unsigned offset) {

         return sizeof(Struct) + offset;

     }

     static inline Struct *cast(Object *obj) {

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

         return reinterpret_cast<Struct *>(obj);

     }

 };

 }

 #endif // _include_jc_structure_h_