public final void getPropertyValueInternal(
      final Property property, final PropertyAcc pas, final boolean fromInstanceSlaveCall)
      throws InvalidModelException {
    /*
     * First see if the property is defined locally in the instance. Such
     * local property associations arise from component property
     * associations in the declarative spec, from explicit programmatic
     * setting of the property, or as cached results from earlier property
     * lookups.
     */
    if (pas.addLocal(this)) {
      return;
    }

    /*
     * If we don't find the property locally we defer to the declarative
     * specifications.
     */
    getPropertyValueFromDeclarativeModel(property, pas);

    /*
     * If we still don't have a value, and the property is "inherit", get it
     * from the enclosing component instance. Don't short-circuit this step
     * because the property caching during instantiation doesn't catch
     * contained property values that may be attached to an ancestor
     * instance and that might be inherited by this instance.
     */
    if (property.isInherit()) {
      final NamedElement ph = (NamedElement) eContainer();
      if (ph != null) {
        ph.getPropertyValueInternal(property, pas, false);
      }
    }
  }
Beispiel #2
0
 /**
  * Check that UnitLiteral unit is part of Property pd's UnitsType and returns the property value
  * by calling ph.getSimplePropertyValue(pd)
  *
  * @param ph The property holder from which to retrieve the property value.
  * @param pd The property to retrieve.
  * @param unit The literal to test against pd's units type.
  * @return The retrieved property value.
  * @throws InvalidModelException Thrown if the property value cannot be retrieved because the
  *     model is incomplete or otherwise invalid.
  * @throws PropertyNotPresentException Thrown if the property is undefined for ph.
  * @throws PropertyIsModalException Thrown if ph is modal and declarative.
  * @throws IllegalStateException Thrown if the lookup encounters a cycle of property reference
  *     dependencies.
  * @throws IllegalArgumentException Thrown if the given unit literal is not from the property's
  *     unit type or if ph, pd, or unit is null.
  * @throws PropertyDoesNotApplyToHolderException Thrown if pd does not apply to ph.
  * @throws PropertyIsListException Thrown if the property is not scalar.
  * @throws ClassCastException Thrown if the property's type is not a RangeType or a NumberType.
  */
 private static PropertyExpression checkUnitsAndGetSimplePropertyValue(
     final NamedElement ph, final Property pd, final UnitLiteral unit)
     throws InvalidModelException, PropertyNotPresentException, PropertyIsModalException,
         IllegalStateException, IllegalArgumentException, PropertyDoesNotApplyToHolderException,
         PropertyIsListException, ClassCastException {
   if (unit == null) {
     throw new IllegalArgumentException("UnitLiteral unit cannot be null.");
   }
   final PropertyExpression pv = getSimplePropertyValue(ph, pd);
   PropertyType pt = (PropertyType) pd.getType();
   if (pt instanceof RangeType) {
     pt = ((RangeType) pt).getNumberType();
   }
   final UnitsType theUnitsType = ((NumberType) pt).getUnitsType();
   if (unit.eContainer() != theUnitsType) {
     throw new IllegalArgumentException(
         "Unit literal "
             + unit.getName()
             + " is not from the property's type "
             + theUnitsType.getName());
   }
   return pv;
 }