eu.mihosoft.vmf.vmftext.grammar.impl.ReadOnlyUnparserModelImpl Maven / Gradle / Ivy

Go to download

package eu.mihosoft.vmf.vmftext.grammar.impl;

// vmf imports
//import eu.mihosoft.vmf.runtime.core.*;
//import eu.mihosoft.vmf.runtime.core.internal.*;
import eu.mihosoft.vcollections.*;
import eu.mihosoft.vmf.vmftext.grammar.*;
import java.beans.PropertyChangeListener;

// property types imports
import eu.mihosoft.vcollections.*;

// interface

/**
 * An read-only representation of the model object {@code eu.mihosoft.vmf.vmftext.grammar.UnparserModel}.
 */
@SuppressWarnings("deprecation")
class ReadOnlyUnparserModelImpl implements ReadOnlyUnparserModel, eu.mihosoft.vmf.runtime.core.internal.VObjectInternal, VCloneableInternal {

  private final UnparserModel mutableObject;

  // Read-only view for collection properties
  // - properties with collection type (model & non-model collections)
  // - we don't allow/provide setters for collection properties
  private VList lexerRules;
    private VList rules;
   
  public ReadOnlyUnparserModelImpl(UnparserModel mutableObject) {
    this.mutableObject = mutableObject;
  }


  @Override
  // generic type is a model-type
  public VList getLexerRules() {

    // we return an unmodifiable mapped list that contains read-only versions of the list elements
    // since read-only types and normal types are incompatible by design, we specify the lambda
    // operation that converts an element into a read-only version of that element
    if(this.lexerRules == null) {
      this.lexerRules = VMappedList.newUnmodifiableInstance(mutableObject.getLexerRules(), (e)->e.asReadOnly());
    }

    return this.lexerRules;

 
  }


  @Override
  // generic type is a model-type
  public VList getRules() {

    // we return an unmodifiable mapped list that contains read-only versions of the list elements
    // since read-only types and normal types are incompatible by design, we specify the lambda
    // operation that converts an element into a read-only version of that element
    if(this.rules == null) {
      this.rules = VMappedList.newUnmodifiableInstance(mutableObject.getRules(), (e)->e.asReadOnly());
    }

    return this.rules;

 
  }

 // end for each property

  @Override
  public void addPropertyChangeListener(PropertyChangeListener l) {
    ((eu.mihosoft.vmf.runtime.core.internal.VObjectInternal)this.mutableObject).addPropertyChangeListener(l);
  }

  @Override
  public void removePropertyChangeListener(PropertyChangeListener l) {
    ((eu.mihosoft.vmf.runtime.core.internal.VObjectInternal)this.mutableObject).removePropertyChangeListener(l);
  }

  @Override
  public String toString() {
    return this.mutableObject.toString();
  }

  @Override
  public boolean equals(Object o) {
    return this.mutableObject.equals(o);
  }

  @Override
  public int hashCode() {
    return this.mutableObject.hashCode();
  }

  @Override
  public UnparserModel _vmf_getMutableObject() {
    return this.mutableObject;
  }

  @Override
  public ReadOnlyUnparserModelImpl asReadOnly() {
    return this;
  }

  // --------------------------------------------------------------------
  // --- Cloning
  // --------------------------------------------------------------------

  @Override
  public ReadOnlyUnparserModel clone() {
    return this.mutableObject.clone().asReadOnly();
  }

  @Override
  public UnparserModel asModifiable() {
    return this.mutableObject.clone();
  }

  @Override
  public UnparserModel _vmf_deepCopy(
    java.util.IdentityHashMap identityMap) {
    return (UnparserModel)
      ((VCloneableInternal)this.mutableObject)._vmf_deepCopy(
        new java.util.IdentityHashMap<>());
  }

  @Override
  public ReadOnlyUnparserModel _vmf_shallowCopy(
    java.util.IdentityHashMap identityMap) {
    return (ReadOnlyUnparserModel)
      ((VCloneableInternal)this.mutableObject)._vmf_shallowCopy(
        new java.util.IdentityHashMap<>()).asReadOnly();
  }

  // --------------------------------------------------------------------
  // --- Public VMF API
  // --------------------------------------------------------------------

  @Override
  public eu.mihosoft.vmf.runtime.core.VMF vmf() {
    return new eu.mihosoft.vmf.runtime.core.VMF() {
      public eu.mihosoft.vmf.runtime.core.Content content() {
        return new eu.mihosoft.vmf.runtime.core.Content() {
          public eu.mihosoft.vmf.runtime.core.VIterator iterator() {
            return eu.mihosoft.vmf.runtime.core.VIterator.of(ReadOnlyUnparserModelImpl.this);
          }
          public java.util.stream.Stream stream() {
            return eu.mihosoft.vmf.runtime.core.VIterator.of(ReadOnlyUnparserModelImpl.this).asStream();
          }

          public eu.mihosoft.vmf.runtime.core.VIterator iterator(eu.mihosoft.vmf.runtime.core.VIterator.IterationStrategy strategy) {
            return eu.mihosoft.vmf.runtime.core.VIterator.of(ReadOnlyUnparserModelImpl.this, strategy);
          }
          public java.util.stream.Stream stream(eu.mihosoft.vmf.runtime.core.VIterator.IterationStrategy strategy) {
            return eu.mihosoft.vmf.runtime.core.VIterator.of(ReadOnlyUnparserModelImpl.this, strategy).asStream();
          }
          public  java.util.stream.Stream stream(Class type) {
            return stream().filter(e->type.isAssignableFrom(e.getClass())).map(e->(T)e);
          }
          public  java.util.stream.Stream stream(Class type, eu.mihosoft.vmf.runtime.core.VIterator.IterationStrategy strategy) {
            return stream(strategy).filter(e->type.isAssignableFrom(e.getClass())).map(e->(T)e);
          }
          public VList referencedBy() {
            return _vmf_referencedBy().asUnmodifiable();
          }
          public VList references() {
            return _vmf_references().asUnmodifiable();
          }

          @Override
          public ReadOnlyUnparserModel deepCopy() {
            return (ReadOnlyUnparserModelImpl)
              ((VCloneableInternal)ReadOnlyUnparserModelImpl.this.mutableObject)._vmf_deepCopy(
                new java.util.IdentityHashMap<>()).asReadOnly();
          }

          @Override
          public ReadOnlyUnparserModel shallowCopy() {
            return ReadOnlyUnparserModelImpl.
              this._vmf_shallowCopy(new java.util.IdentityHashMap<>());
          }
        };
      }

      private eu.mihosoft.vmf.runtime.core.internal.ReflectImpl reflect;

      public eu.mihosoft.vmf.runtime.core.Reflect reflect() {
        if (reflect==null) {
          reflect = new eu.mihosoft.vmf.runtime.core.internal.ReflectImpl();
          reflect.setModel(ReadOnlyUnparserModelImpl.this);
        }

        return reflect;
      }
    }; // end vmf
  }


  // --------------------------------------------------------------------
  // --- Reflection methods
  // --------------------------------------------------------------------

  // type id for improved reflection performance
  public static final int _VMF_TYPE_ID = 53;

  @Override
  public int _vmf_getTypeId() {
    return _VMF_TYPE_ID;
  }


  static final String[] _VMF_PROPERTY_NAMES = {
    "lexerRules",
    "rules"
  };

  static final String[] _VMF_PROPERTY_TYPE_NAMES = {
    "eu.mihosoft.vcollections.VList", // type id -2
    "eu.mihosoft.vcollections.VList"  // type id -2
  };

  static final int[] _VMF_PROPERTY_TYPES = {
       -2, // type eu.mihosoft.vcollections.VList
       -2  // type eu.mihosoft.vcollections.VList
  };


  /**
   * - indices of model objects as properties
   * - parents, i.e., containers are skipped
   * - only indices of reference properties and contained elements, i.e.,
   *   children are listed here
   */
  static final int[] _VMF_PROPERTIES_WITH_MODEL_TYPES_INDICES = {
  };

  /**
   * - indices of lists that contain model objects as elements
   */
  static final int[] _VMF_PROPERTIES_WITH_MODEL_ELEMENT_TYPES_INDICES = {
        0, // type eu.mihosoft.vcollections.VList
        1  // type eu.mihosoft.vcollections.VList
  };

  /**
   * - indices of model objects as properties and model objects as
   *   elements of lists
   * - parents, i.e., containers are skipped
   * - only indices of reference properties and contained elements, i.e.,
   *   children are listed here
   */
  static final int[] _VMF_PROPERTIES_WITH_MODEL_TYPE_OR_ELEMENT_TYPES_INDICES = {
        0, // type eu.mihosoft.vcollections.VList
        1  // type eu.mihosoft.vcollections.VList
  };

  /**
   * - indices of model children
   * - parents, i.e., containers and pure references are skipped
   * - only indices of contained elements, i.e.,
   *   children are listed here
   */
  static final int[] _VMF_CHILDREN_INDICES = {
        0, // type eu.mihosoft.vcollections.VList
        1  // type eu.mihosoft.vcollections.VList
  };

  @Override
  public String[] _vmf_getPropertyNames() {
    return _VMF_PROPERTY_NAMES;
  }

  @Override
  public int[] _vmf_getPropertyTypes() {
    return _VMF_PROPERTY_TYPES;
  }

  @Override
  public String[] _vmf_getPropertyTypeNames() {
    return _VMF_PROPERTY_TYPE_NAMES;
  }

  @Override
  public int[] _vmf_getIndicesOfPropertiesWithModelTypes() {
    return _VMF_PROPERTIES_WITH_MODEL_TYPES_INDICES;
  }

  @Override
  public int[] _vmf_getIndicesOfPropertiesWithModelElementTypes() {
    return _VMF_PROPERTIES_WITH_MODEL_ELEMENT_TYPES_INDICES;
  }

  @Override
  public int[] _vmf_getIndicesOfPropertiesWithModelTypeOrElementTypes() {
    return _VMF_PROPERTIES_WITH_MODEL_TYPE_OR_ELEMENT_TYPES_INDICES;
  }

  @Override
  public int[] _vmf_getChildrenIndices() {
    return _VMF_CHILDREN_INDICES;
  }

  @Override
  public Object _vmf_getPropertyValueById(int propertyId) {

    switch(propertyId) {
      case 0:
        // TODO check whether we can prevent lazy initialized properties from
        //      being initialized just for iterating the object graph
        return getLexerRules();
      case 1:
        // TODO check whether we can prevent lazy initialized properties from
        //      being initialized just for iterating the object graph
        return getRules();
    }

    return null;
  }

  @Override
  public int _vmf_getPropertyIdByName(String propertyName) {
    switch(propertyName) {
      case "lexerRules":
        return 0;
      case "rules":
        return 1;
      default:
        return -1;
    } // end switch
  }


  @Override
  public Object _vmf_getDefaultValueById(int propertyId) {

    switch(propertyId) {
      case 0:
        Object __vmf_default_value_tmpLexerRules = _VMF_DEFAULT_VALUES[0];
        if(__vmf_default_value_tmpLexerRules==null) {
            return null;
        } else {
            return __vmf_default_value_tmpLexerRules;
        }

      case 1:
        Object __vmf_default_value_tmpRules = _VMF_DEFAULT_VALUES[1];
        if(__vmf_default_value_tmpRules==null) {
            return null;
        } else {
            return __vmf_default_value_tmpRules;
        }

    } // end switch

    return null;
  }

  @Override
  public void _vmf_setDefaultValueById(int propertyId, Object defaultValue) {

    // property lexerRules
    if(propertyId == 0) { 
      throw new RuntimeException("Cannot set default value for property 'lexerRules' with id="+propertyId +": property is a containment property and not writable.");
    }
    // property rules
    if(propertyId == 1) { 
      throw new RuntimeException("Cannot set default value for property 'rules' with id="+propertyId +": property is a containment property and not writable.");
    }

  }

  @Override
  public boolean _vmf_isSetById(int propertyId) {
    return !java.util.Objects.equals(_vmf_getDefaultValueById(propertyId), _vmf_getPropertyValueById(propertyId));
  }


  final Object[] _VMF_DEFAULT_VALUES = {
    null, // type lexerRules (containment type, no defaut value possible)  
    null  // type rules (containment type, no defaut value possible)  
  };

  @Override
  public boolean _vmf_isReadOnly() {
    return true;
  }

  // --------------------------------------------------------------------
  // --- Id related methods
  // --------------------------------------------------------------------

  // id management is currently not part of VMF (TODO how should we support this?)

  // --------------------------------------------------------------------
  // --- Reference methods
  // --------------------------------------------------------------------

  public VList _vmf_referencedBy() { return  ((eu.mihosoft.vmf.runtime.core.internal.VObjectInternalModifiable)this.mutableObject)._vmf_referencedBy();}

  public VList _vmf_references() { return  ((eu.mihosoft.vmf.runtime.core.internal.VObjectInternalModifiable)this.mutableObject)._vmf_references();}
}