Structure.java

package emulator.code;

import java.util.*;

import emulator.code.Code.Decl;
import emulator.memory.*;
import emulator.memory.Identifier.Property;
import emulator.memory.Memory.Access;

public abstract class Structure {
    // hash keys are fixed BigIntegers
    // provide next few free indices
    // scan/cleanup in background/parallel
    // id table entries are on fixed offsets

    public static class Type {
        // use this in code structure
        // functions are static
        // TODO provide function override by instance
        // TODO Type as variable, package as field access

        // classes have arbitrary property access (implicit, hashmap)
        // classes define mandatory fields and methods (for editor suggest)
        // subclasses inherit superclass mandatory fields and methods

        public Identifier.Type typeId;
        public Identifier.Type enclosingTypeId; // nested
        //public Identifier.Type enclosingTypeId; // anonymous
        public Structure.List.Vector extendsList = new Structure.List.Vector();
        public boolean instantiable;

        public final LinkedHashMap<Identifier.Property, Decl> declList = new LinkedHashMap<Identifier.Property, Decl>();// stack contains type var/literal, NO function
        public final LinkedHashMap<Identifier.Property, Decl> staticDeclList = new LinkedHashMap<Identifier.Property, Decl>();
        public final LinkedHashMap<Identifier.Property, Access> codeList = new LinkedHashMap<Identifier.Property, Access>();// only code objects OR Vector of code objects (statement)
        public final LinkedHashMap<Identifier.Property, Access> specialCodeList = new LinkedHashMap<Identifier.Property, Access>();
        // constructor / destructor
        // copy (flat, deep, custom)
        public final LinkedHashMap<Identifier.Property, Access> transformCodeList = new LinkedHashMap<Identifier.Property, Access>(); // cast to object, not neccessarily subtype/supertype
        public final Vector<Identifier.Property> abstractCodeList = new Vector<Identifier.Property>();

    }

    public static class TypeInstance extends Structure {
        public Identifier.Type typeId;
        public final Structure.HashMap data = new Structure.HashMap();// decls of all implemented classes

        public final Object[] typeId1 = new Object[]{ typeId };
        public final Object[] data1 = new Object[]{ data };

        @Override
        public Object[] get(Identifier.Property key) {
            if("data".equals(key.name)) {
                return data1;
            }
            else if("type".equals(key.name)) {
                return typeId1;
            }

            assert false;
            return null;
        }

        @Override
        public void set(Identifier.Property key, Object[] value) {
            assert false;
        }

        @Override
        public boolean containsKey(Identifier.Property key) {
            assert false;
            return false;
        }

        @Override
        public boolean containsReference(Object[] value) {
            assert false;
            return false;
        }

        @Override
        public int size() {
            assert false;
            return 0;
        }
    }

    public static abstract class List extends Structure {
        // linked list, vector-array
        // TODO configure unique values (hash set)

        /*public static class LinkedAVOID extends List {
            public final java.util.LinkedList<Object[]> dataTable = new java.util.LinkedList<Object[]>();

            @Override
            public Object[] get(Identifier.Property key) {
                assert "index".equals(key.name);
                assert key.counter >= 0 && key.counter < dataTable.size();

                return dataTable.get(key.counter);
            }

            @Override
            public void set(Identifier.Property key, Object[] value) {
                assert "index".equals(key.name);
                assert key.counter >= 0 && key.counter < dataTable.size();

                dataTable.set(key.counter, value);
            }

            @Override
            public boolean containsKey(Identifier.Property key) {
                assert "index".equals(key.name);

                return key.counter >= 0 && key.counter < dataTable.size();
            }

            @Override
            public boolean containsValue(Object[] value) {
                return dataTable.contains(value);
            }

            @Override
            public int size() {
                return dataTable.size();
            }
        }*/

        public static class Vector extends List {
            public final java.util.Vector<Object[]> dataTable = new java.util.Vector<Object[]>();
            public boolean unique; // TODO use hashSet

            @Override
            public Object[] get(Identifier.Property key) {
                assert "index".equals(key.name);
                assert key.counter >= 0 && key.counter < dataTable.size();

                return dataTable.get(key.counter);
            }

            @Override
            public void set(Identifier.Property key, Object[] value) {
                assert "index".equals(key.name);

                while(dataTable.size() <= key.counter)
                    dataTable.add(null);

                dataTable.set(key.counter, value);
            }

            @Override
            public boolean containsKey(Identifier.Property key) {
                assert "index".equals(key.name);

                return key.counter >= 0 && key.counter < dataTable.size();
            }

            @Override
            public boolean containsReference(Object[] value) {
                return dataTable.contains(value);
            }

            @Override
            public int size() {
                return dataTable.size();
            }

            @Override
            public int append(Object[] value) {
                int next = dataTable.size();
                set(new Identifier.Property("index", next), value);
                return next;
            }

            @Override
            public void push(Object[] value) {
                dataTable.add(value);
            }

            @Override
            public Object[] pop() {
                return dataTable.lastElement();
            }
        }

        public abstract int append(Object[] value);
        public abstract void push(Object[] value);// begin/end
        public abstract Object[] pop();// begin/end
        //public abstract boolean insert(Object[] value, Identifier.Property key);
    }

    /*public static class Net extends Structure {
        // use this as tree
        // net is back-referenced tree

        public int nextCounter = 0;
        public final LinkedHashMap<Integer, Object[]> dataTable = new LinkedHashMap<Integer, Object[]>();
        public final LinkedHashMap<Integer, NetItem> itemTable = new LinkedHashMap<Integer, NetItem>();
        public Identifier.Property rootItem;

        @Override
        public Object[] get(Identifier.Property key) {
            return dataTable.get(key.counter);
        }

        @Override
        public void set(Identifier.Property key, Object[] value) {
            dataTable.put(key.counter, value);
        }
    }

    public static class NetItem {
        Identifier.Property parentItemId;
        public final Vector<Identifier.Property> dataIdList = new Vector<Identifier.Property>();
        public final Vector<Identifier.Property> subItemIdList = new Vector<Identifier.Property>();
    }*/

    public static class HashMap extends Structure {
        // TODO configure linked or not
        // TODO configure unique values

        public final LinkedHashMap<Identifier.Property, Object[]> dataTable = new LinkedHashMap<Identifier.Property, Object[]>();

        @Override
        public Object[] get(Identifier.Property key) {
            return dataTable.get(key);
        }

        @Override
        public void set(Identifier.Property key, Object[] value) {
            dataTable.put(key, value);
        }

        @Override
        public boolean containsKey(Identifier.Property key) {
            return dataTable.containsKey(key);
        }

        @Override
        public boolean containsReference(Object[] value) {
            return dataTable.containsValue(value);
        }

        @Override
        public int size() {
            return dataTable.size();
        }
    }

    /*public static class ConstantTable {
        // internal use of strings for hashmap
        // internal use of ints for vector
    }*/

    public static class Difference/*<Structure>*/ extends Structure {
        // store difference instead of deep copy (patch)
        // TODO => integrate stack-structure in type-structure

        @Override
        public Object[] get(Identifier.Property key) {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public void set(Identifier.Property key, Object[] value) {
            // TODO Auto-generated method stub

        }

        @Override
        public boolean containsKey(Identifier.Property key) {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public boolean containsReference(Object[] value) {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public int size() {
            // TODO Auto-generated method stub
            return 0;
        }
    }

    // parameter:
    // extend: inherit methods fom supertype, NO traditional override methods (specific access)
    // implement: abstract methods from supertype

    // NO traditional overload methods (specific access)

    // class modifier: abstract
    // function modifier:

    // field getter/setter
    // class constructor/destructor
    // call destructor explicitly

    //public final LinkedHashMap<Identifier.Property, Memory.StructureAccess> dataList = new LinkedHashMap<Identifier.Property, Memory.StructureAccess>();// arbitrary data (expression)
    //public final LinkedHashMap<Identifier.Property, Memory.StructureAccess> codeList = new LinkedHashMap<Identifier.Property, Memory.StructureAccess>();// only code objects (statement)

    public abstract Object[] get(Identifier.Property key);
    public abstract void set(Identifier.Property key, Object[] value);
    public abstract boolean containsKey(Identifier.Property key);
    public abstract boolean containsReference(Object[] value); // compare IDENTICAL Object[] instances, not values
    //public abstract boolean containsValue(Object value);
    public abstract int size();
    //public abstract boolean append(Object[] value);
    //public abstract boolean push(Object[] value);// begin/end
    //public abstract boolean pop(Object[] value);// begin/end
    //public abstract boolean insert(Object[] value, Identifier.Property key);

    //public abstract int hashId();
    //public abstract int identityId();
    //public abstract int equals();

    // TODO ---------------------------------
    // TODO add more structure api
    // TODO better integration for java-native containers, keep hw implementation and memory management in mind
    // TODO USE ONLY THIS STRUCTURE API IN CODE TREE. REPLACE ALL JAVA COLLECTIONS.
}