ArrayLayoutImpl.java

package org.jruby.truffle.nodes.core.array;

import java.util.EnumSet;
import com.oracle.truffle.api.object.*;
import org.jruby.truffle.om.dsl.api.UnexpectedLayoutRefusalException;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.CompilerAsserts;
import org.jruby.truffle.nodes.core.array.ArrayNodes.ArrayLayout;
import org.jruby.truffle.nodes.core.BasicObjectLayoutImpl;

public class ArrayLayoutImpl extends BasicObjectLayoutImpl implements ArrayLayout {
    
    public static final ArrayLayout INSTANCE = new ArrayLayoutImpl();
    
    protected static class ArrayType extends BasicObjectLayoutImpl.BasicObjectType {
        
        public ArrayType(
                com.oracle.truffle.api.object.DynamicObject logicalClass,
                com.oracle.truffle.api.object.DynamicObject metaClass) {
            super(
                logicalClass,
                metaClass);
        }
        
        @Override
        public ArrayType setLogicalClass(com.oracle.truffle.api.object.DynamicObject logicalClass) {
            return new ArrayType(
                logicalClass,
                metaClass);
        }
        
        @Override
        public ArrayType setMetaClass(com.oracle.truffle.api.object.DynamicObject metaClass) {
            return new ArrayType(
                logicalClass,
                metaClass);
        }
        
    }
    
    protected static final HiddenKey STORE_IDENTIFIER = new HiddenKey("store");
    protected static final Property STORE_PROPERTY = Property.create(STORE_IDENTIFIER, ALLOCATOR.locationForType(java.lang.Object.class), 0);
    
    protected static final HiddenKey SIZE_IDENTIFIER = new HiddenKey("size");
    protected static final Property SIZE_PROPERTY = Property.create(SIZE_IDENTIFIER, ALLOCATOR.locationForType(int.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected ArrayLayoutImpl() {
    }
    
    @Override
    public DynamicObjectFactory createArrayShape(
            com.oracle.truffle.api.object.DynamicObject logicalClass,
            com.oracle.truffle.api.object.DynamicObject metaClass) {
        return LAYOUT.createShape(new ArrayType(
                logicalClass,
                metaClass))
            .addProperty(STORE_PROPERTY)
            .addProperty(SIZE_PROPERTY)
            .createFactory();
    }
    
    @Override
    public DynamicObject createArray(
            DynamicObjectFactory factory,
            java.lang.Object store,
            int size) {
        assert factory != null;
        CompilerAsserts.compilationConstant(factory);
        assert createsArray(factory);
        assert factory.getShape().hasProperty(STORE_IDENTIFIER);
        assert factory.getShape().hasProperty(SIZE_IDENTIFIER);
        return factory.newInstance(
            store,
            size);
    }
    
    @Override
    public boolean isArray(DynamicObject object) {
        return isArray(object.getShape().getObjectType());
    }
    
    @Override
    public boolean isArray(ObjectType objectType) {
        return objectType instanceof ArrayType;
    }
    
    private boolean createsArray(DynamicObjectFactory factory) {
        return isArray(factory.getShape().getObjectType());
    }
    
    @Override
    public java.lang.Object getStore(DynamicObject object) {
        assert isArray(object);
        assert object.getShape().hasProperty(STORE_IDENTIFIER);
        
        return (java.lang.Object) STORE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setStore(DynamicObject object, java.lang.Object value) {
        assert isArray(object);
        assert object.getShape().hasProperty(STORE_IDENTIFIER);
        
        try {
            STORE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public int getSize(DynamicObject object) {
        assert isArray(object);
        assert object.getShape().hasProperty(SIZE_IDENTIFIER);
        
        return (int) SIZE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setSize(DynamicObject object, int value) {
        assert isArray(object);
        assert object.getShape().hasProperty(SIZE_IDENTIFIER);
        
        try {
            SIZE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
}

BasicObjectLayoutImpl.java

package org.jruby.truffle.nodes.core;

import java.util.EnumSet;
import com.oracle.truffle.api.object.*;
import org.jruby.truffle.om.dsl.api.UnexpectedLayoutRefusalException;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.CompilerAsserts;
import org.jruby.truffle.nodes.core.BasicObjectNodes.BasicObjectLayout;

public class BasicObjectLayoutImpl implements BasicObjectLayout {
    
    public static final BasicObjectLayout INSTANCE = new BasicObjectLayoutImpl();
    
    protected static class BasicObjectType extends org.jruby.truffle.runtime.RubyObjectType {
        
        protected final com.oracle.truffle.api.object.DynamicObject logicalClass;
        protected final com.oracle.truffle.api.object.DynamicObject metaClass;
        
        public BasicObjectType(
                com.oracle.truffle.api.object.DynamicObject logicalClass,
                com.oracle.truffle.api.object.DynamicObject metaClass) {
            this.logicalClass = logicalClass;
            this.metaClass = metaClass;
        }
        
        public com.oracle.truffle.api.object.DynamicObject getLogicalClass() {
            return logicalClass;
        }
        
        public BasicObjectType setLogicalClass(com.oracle.truffle.api.object.DynamicObject logicalClass) {
            return new BasicObjectType(
                logicalClass,
                metaClass);
        }
        
        public com.oracle.truffle.api.object.DynamicObject getMetaClass() {
            return metaClass;
        }
        
        public BasicObjectType setMetaClass(com.oracle.truffle.api.object.DynamicObject metaClass) {
            return new BasicObjectType(
                logicalClass,
                metaClass);
        }
        
    }
    
    protected static final Layout LAYOUT = Layout.createLayout(Layout.INT_TO_LONG);
    protected static final Shape.Allocator ALLOCATOR = LAYOUT.createAllocator();
    
    protected BasicObjectLayoutImpl() {
    }
    
    @Override
    public DynamicObjectFactory createBasicObjectShape(
            com.oracle.truffle.api.object.DynamicObject logicalClass,
            com.oracle.truffle.api.object.DynamicObject metaClass) {
        return LAYOUT.createShape(new BasicObjectType(
                logicalClass,
                metaClass))
            .createFactory();
    }
    
    @Override
    public DynamicObject createBasicObject(DynamicObjectFactory factory) {
        assert factory != null;
        CompilerAsserts.compilationConstant(factory);
        assert createsBasicObject(factory);
        return factory.newInstance();
    }
    
    @Override
    public boolean isBasicObject(Object object) {
        return (object instanceof DynamicObject) && isBasicObject((DynamicObject) object);
    }
    
    private boolean isBasicObject(DynamicObject object) {
        return isBasicObject(object.getShape().getObjectType());
    }
    
    private boolean isBasicObject(ObjectType objectType) {
        return objectType instanceof BasicObjectType;
    }
    
    private boolean createsBasicObject(DynamicObjectFactory factory) {
        return isBasicObject(factory.getShape().getObjectType());
    }
    
    @Override
    public com.oracle.truffle.api.object.DynamicObject getLogicalClass(ObjectType objectType) {
        assert isBasicObject(objectType);
        return ((BasicObjectType) objectType).getLogicalClass();
    }
    
    @Override
    public com.oracle.truffle.api.object.DynamicObject getLogicalClass(DynamicObject object) {
        assert isBasicObject(object);
        return getObjectType(object).getLogicalClass();
    }
    
    @TruffleBoundary
    @Override
    public DynamicObjectFactory setLogicalClass(DynamicObjectFactory factory, com.oracle.truffle.api.object.DynamicObject value) {
        assert createsBasicObject(factory);
        final Shape shape = factory.getShape();
        return shape.changeType(((BasicObjectType) shape.getObjectType()).setLogicalClass(value)).createFactory();
    }
    
    @TruffleBoundary
    @Override
    public void setLogicalClass(DynamicObject object, com.oracle.truffle.api.object.DynamicObject value) {
        assert isBasicObject(object);
        final Shape shape = object.getShape();
        object.setShapeAndResize(shape, shape.changeType(getObjectType(object).setLogicalClass(value)));
    }
    
    @Override
    public com.oracle.truffle.api.object.DynamicObject getMetaClass(DynamicObject object) {
        assert isBasicObject(object);
        return getObjectType(object).getMetaClass();
    }
    
    @TruffleBoundary
    @Override
    public DynamicObjectFactory setMetaClass(DynamicObjectFactory factory, com.oracle.truffle.api.object.DynamicObject value) {
        assert createsBasicObject(factory);
        final Shape shape = factory.getShape();
        return shape.changeType(((BasicObjectType) shape.getObjectType()).setMetaClass(value)).createFactory();
    }
    
    @TruffleBoundary
    @Override
    public void setMetaClass(DynamicObject object, com.oracle.truffle.api.object.DynamicObject value) {
        assert isBasicObject(object);
        final Shape shape = object.getShape();
        object.setShapeAndResize(shape, shape.changeType(getObjectType(object).setMetaClass(value)));
    }
    
    private BasicObjectType getObjectType(DynamicObject object) {
        assert isBasicObject(object);
        return (BasicObjectType) object.getShape().getObjectType();
    }
    
}

HashLayoutImpl.java

package org.jruby.truffle.nodes.core.hash;

import java.util.EnumSet;
import com.oracle.truffle.api.object.*;
import org.jruby.truffle.om.dsl.api.UnexpectedLayoutRefusalException;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.CompilerAsserts;
import org.jruby.truffle.nodes.core.hash.HashNodes.HashLayout;
import org.jruby.truffle.nodes.core.BasicObjectLayoutImpl;

public class HashLayoutImpl extends BasicObjectLayoutImpl implements HashLayout {
    
    public static final HashLayout INSTANCE = new HashLayoutImpl();
    
    protected static class HashType extends BasicObjectLayoutImpl.BasicObjectType {
        
        public HashType(
                com.oracle.truffle.api.object.DynamicObject logicalClass,
                com.oracle.truffle.api.object.DynamicObject metaClass) {
            super(
                logicalClass,
                metaClass);
        }
        
        @Override
        public HashType setLogicalClass(com.oracle.truffle.api.object.DynamicObject logicalClass) {
            return new HashType(
                logicalClass,
                metaClass);
        }
        
        @Override
        public HashType setMetaClass(com.oracle.truffle.api.object.DynamicObject metaClass) {
            return new HashType(
                logicalClass,
                metaClass);
        }
        
    }
    
    protected static final HiddenKey DEFAULT_BLOCK_IDENTIFIER = new HiddenKey("defaultBlock");
    protected static final Property DEFAULT_BLOCK_PROPERTY = Property.create(DEFAULT_BLOCK_IDENTIFIER, ALLOCATOR.locationForType(com.oracle.truffle.api.object.DynamicObject.class), 0);
    
    protected static final HiddenKey DEFAULT_VALUE_IDENTIFIER = new HiddenKey("defaultValue");
    protected static final Property DEFAULT_VALUE_PROPERTY = Property.create(DEFAULT_VALUE_IDENTIFIER, ALLOCATOR.locationForType(java.lang.Object.class), 0);
    
    protected static final HiddenKey STORE_IDENTIFIER = new HiddenKey("store");
    protected static final Property STORE_PROPERTY = Property.create(STORE_IDENTIFIER, ALLOCATOR.locationForType(java.lang.Object.class), 0);
    
    protected static final HiddenKey SIZE_IDENTIFIER = new HiddenKey("size");
    protected static final Property SIZE_PROPERTY = Property.create(SIZE_IDENTIFIER, ALLOCATOR.locationForType(int.class), 0);
    
    protected static final HiddenKey FIRST_IN_SEQUENCE_IDENTIFIER = new HiddenKey("firstInSequence");
    protected static final Property FIRST_IN_SEQUENCE_PROPERTY = Property.create(FIRST_IN_SEQUENCE_IDENTIFIER, ALLOCATOR.locationForType(org.jruby.truffle.runtime.hash.Entry.class), 0);
    
    protected static final HiddenKey LAST_IN_SEQUENCE_IDENTIFIER = new HiddenKey("lastInSequence");
    protected static final Property LAST_IN_SEQUENCE_PROPERTY = Property.create(LAST_IN_SEQUENCE_IDENTIFIER, ALLOCATOR.locationForType(org.jruby.truffle.runtime.hash.Entry.class), 0);
    
    protected static final HiddenKey COMPARE_BY_IDENTITY_IDENTIFIER = new HiddenKey("compareByIdentity");
    protected static final Property COMPARE_BY_IDENTITY_PROPERTY = Property.create(COMPARE_BY_IDENTITY_IDENTIFIER, ALLOCATOR.locationForType(boolean.class), 0);
    
    protected HashLayoutImpl() {
    }
    
    @Override
    public DynamicObjectFactory createHashShape(
            com.oracle.truffle.api.object.DynamicObject logicalClass,
            com.oracle.truffle.api.object.DynamicObject metaClass) {
        return LAYOUT.createShape(new HashType(
                logicalClass,
                metaClass))
            .addProperty(DEFAULT_BLOCK_PROPERTY)
            .addProperty(DEFAULT_VALUE_PROPERTY)
            .addProperty(STORE_PROPERTY)
            .addProperty(SIZE_PROPERTY)
            .addProperty(FIRST_IN_SEQUENCE_PROPERTY)
            .addProperty(LAST_IN_SEQUENCE_PROPERTY)
            .addProperty(COMPARE_BY_IDENTITY_PROPERTY)
            .createFactory();
    }
    
    @Override
    public DynamicObject createHash(
            DynamicObjectFactory factory,
            com.oracle.truffle.api.object.DynamicObject defaultBlock,
            java.lang.Object defaultValue,
            java.lang.Object store,
            int size,
            org.jruby.truffle.runtime.hash.Entry firstInSequence,
            org.jruby.truffle.runtime.hash.Entry lastInSequence,
            boolean compareByIdentity) {
        assert factory != null;
        CompilerAsserts.compilationConstant(factory);
        assert createsHash(factory);
        assert factory.getShape().hasProperty(DEFAULT_BLOCK_IDENTIFIER);
        assert factory.getShape().hasProperty(DEFAULT_VALUE_IDENTIFIER);
        assert factory.getShape().hasProperty(STORE_IDENTIFIER);
        assert factory.getShape().hasProperty(SIZE_IDENTIFIER);
        assert factory.getShape().hasProperty(FIRST_IN_SEQUENCE_IDENTIFIER);
        assert factory.getShape().hasProperty(LAST_IN_SEQUENCE_IDENTIFIER);
        assert factory.getShape().hasProperty(COMPARE_BY_IDENTITY_IDENTIFIER);
        return factory.newInstance(
            defaultBlock,
            defaultValue,
            store,
            size,
            firstInSequence,
            lastInSequence,
            compareByIdentity);
    }
    
    @Override
    public boolean isHash(DynamicObject object) {
        return isHash(object.getShape().getObjectType());
    }
    
    @Override
    public boolean isHash(ObjectType objectType) {
        return objectType instanceof HashType;
    }
    
    private boolean createsHash(DynamicObjectFactory factory) {
        return isHash(factory.getShape().getObjectType());
    }
    
    @Override
    public com.oracle.truffle.api.object.DynamicObject getDefaultBlock(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(DEFAULT_BLOCK_IDENTIFIER);
        
        return (com.oracle.truffle.api.object.DynamicObject) DEFAULT_BLOCK_PROPERTY.get(object, true);
    }
    
    @Override
    public void setDefaultBlock(DynamicObject object, com.oracle.truffle.api.object.DynamicObject value) {
        assert isHash(object);
        assert object.getShape().hasProperty(DEFAULT_BLOCK_IDENTIFIER);
        
        try {
            DEFAULT_BLOCK_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public java.lang.Object getDefaultValue(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(DEFAULT_VALUE_IDENTIFIER);
        
        return (java.lang.Object) DEFAULT_VALUE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setDefaultValue(DynamicObject object, java.lang.Object value) {
        assert isHash(object);
        assert object.getShape().hasProperty(DEFAULT_VALUE_IDENTIFIER);
        
        try {
            DEFAULT_VALUE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public java.lang.Object getStore(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(STORE_IDENTIFIER);
        
        return (java.lang.Object) STORE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setStore(DynamicObject object, java.lang.Object value) {
        assert isHash(object);
        assert object.getShape().hasProperty(STORE_IDENTIFIER);
        
        try {
            STORE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public int getSize(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(SIZE_IDENTIFIER);
        
        return (int) SIZE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setSize(DynamicObject object, int value) {
        assert isHash(object);
        assert object.getShape().hasProperty(SIZE_IDENTIFIER);
        
        try {
            SIZE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public org.jruby.truffle.runtime.hash.Entry getFirstInSequence(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(FIRST_IN_SEQUENCE_IDENTIFIER);
        
        return (org.jruby.truffle.runtime.hash.Entry) FIRST_IN_SEQUENCE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setFirstInSequence(DynamicObject object, org.jruby.truffle.runtime.hash.Entry value) {
        assert isHash(object);
        assert object.getShape().hasProperty(FIRST_IN_SEQUENCE_IDENTIFIER);
        
        try {
            FIRST_IN_SEQUENCE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public org.jruby.truffle.runtime.hash.Entry getLastInSequence(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(LAST_IN_SEQUENCE_IDENTIFIER);
        
        return (org.jruby.truffle.runtime.hash.Entry) LAST_IN_SEQUENCE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setLastInSequence(DynamicObject object, org.jruby.truffle.runtime.hash.Entry value) {
        assert isHash(object);
        assert object.getShape().hasProperty(LAST_IN_SEQUENCE_IDENTIFIER);
        
        try {
            LAST_IN_SEQUENCE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public boolean getCompareByIdentity(DynamicObject object) {
        assert isHash(object);
        assert object.getShape().hasProperty(COMPARE_BY_IDENTITY_IDENTIFIER);
        
        return (boolean) COMPARE_BY_IDENTITY_PROPERTY.get(object, true);
    }
    
    @Override
    public void setCompareByIdentity(DynamicObject object, boolean value) {
        assert isHash(object);
        assert object.getShape().hasProperty(COMPARE_BY_IDENTITY_IDENTIFIER);
        
        try {
            COMPARE_BY_IDENTITY_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
}