Ejemplo n.º 1
0
 @Nullable
 public static JetTypeInfo getRecordedTypeInfo(
     @NotNull JetExpression expression, @NotNull BindingContext context) {
   if (!context.get(BindingContext.PROCESSED, expression)) return null;
   DataFlowInfo dataFlowInfo = BindingContextUtilPackage.getDataFlowInfo(context, expression);
   JetType type = context.get(BindingContext.EXPRESSION_TYPE, expression);
   return JetTypeInfo.create(type, dataFlowInfo);
 }
Ejemplo n.º 2
0
 @Nullable
 public static JetTypeInfo getRecordedTypeInfo(
     @NotNull JetExpression expression, @NotNull BindingContext context) {
   // noinspection ConstantConditions
   if (!context.get(BindingContext.PROCESSED, expression)) return null;
   // NB: should never return null if expression is already processed
   JetTypeInfo result = context.get(BindingContext.EXPRESSION_TYPE_INFO, expression);
   return result != null ? result : TypeInfoFactoryPackage.noTypeInfo(DataFlowInfo.EMPTY);
 }
Ejemplo n.º 3
0
 public static boolean isVarCapturedInClosure(
     BindingContext bindingContext, DeclarationDescriptor descriptor) {
   if (!(descriptor instanceof VariableDescriptor) || descriptor instanceof PropertyDescriptor)
     return false;
   VariableDescriptor variableDescriptor = (VariableDescriptor) descriptor;
   return bindingContext.get(CAPTURED_IN_CLOSURE, variableDescriptor) != null
       && variableDescriptor.isVar();
 }
Ejemplo n.º 4
0
 public String getElementName() {
   IObservable model = context.getModel();
   if (elementName == null && model != null && model.getType() == IObservable.OBSERVE_SWT_JFACE) {
     Object source = model.getSource();
     elementName = getWidgetName(source);
   }
   return elementName;
 }
Ejemplo n.º 5
0
 @NotNull
 public static JetType getTypeNotNull(
     @NotNull BindingContext bindingContext, @NotNull JetExpression expression) {
   JetType result = bindingContext.getType(expression);
   if (result == null) {
     throw new IllegalStateException("Type must be not null for " + expression);
   }
   return result;
 }
Ejemplo n.º 6
0
 @NotNull
 public static <K, V> V getNotNull(
     @NotNull BindingContext bindingContext,
     @NotNull ReadOnlySlice<K, V> slice,
     @NotNull K key,
     @NotNull String messageIfNull) {
   V value = bindingContext.get(slice, key);
   if (value == null) {
     throw new IllegalStateException(messageIfNull);
   }
   return value;
 }
Ejemplo n.º 7
0
 @Nullable
 public static VariableDescriptor extractVariableDescriptorIfAny(
     @NotNull BindingContext bindingContext, @Nullable JetElement element, boolean onlyReference) {
   DeclarationDescriptor descriptor = null;
   if (!onlyReference
       && (element instanceof JetVariableDeclaration || element instanceof JetParameter)) {
     descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
   } else if (element instanceof JetSimpleNameExpression) {
     descriptor =
         bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element);
   } else if (element instanceof JetQualifiedExpression) {
     descriptor =
         extractVariableDescriptorIfAny(
             bindingContext,
             ((JetQualifiedExpression) element).getSelectorExpression(),
             onlyReference);
   }
   if (descriptor instanceof VariableDescriptor) {
     return (VariableDescriptor) descriptor;
   }
   return null;
 }
Ejemplo n.º 8
0
 @NotNull
 public static DeclarationDescriptor getEnclosingDescriptor(
     @NotNull BindingContext context, @NotNull JetElement element) {
   JetNamedDeclaration declaration =
       PsiTreeUtil.getParentOfType(element, JetNamedDeclaration.class);
   if (declaration instanceof JetFunctionLiteral) {
     return getEnclosingDescriptor(context, declaration);
   }
   DeclarationDescriptor descriptor = context.get(DECLARATION_TO_DESCRIPTOR, declaration);
   assert descriptor != null
       : "No descriptor for named declaration: "
           + declaration.getText()
           + "\n(of type "
           + declaration.getClass()
           + ")";
   return descriptor;
 }
  /**
   * Invoke the method and return a Publisher for the return value.
   *
   * @param exchange the current exchange
   * @param bindingContext the binding context to use
   * @param providedArgs optional list of argument values to check by type (via {@code instanceof})
   *     for resolving method arguments.
   * @return Publisher that produces a single HandlerResult or an error signal; never throws an
   *     exception
   */
  public Mono<HandlerResult> invokeForRequest(
      ServerWebExchange exchange, BindingContext bindingContext, Object... providedArgs) {

    return resolveArguments(exchange, bindingContext, providedArgs)
        .then(
            args -> {
              try {
                Object value = doInvoke(args);
                ModelMap model = bindingContext.getModel();
                HandlerResult handlerResult =
                    new HandlerResult(this, value, getReturnType(), model);
                return Mono.just(handlerResult);
              } catch (InvocationTargetException ex) {
                return Mono.error(ex.getTargetException());
              } catch (Throwable ex) {
                String s = getInvocationErrorMessage(args);
                return Mono.error(new IllegalStateException(s));
              }
            });
  }
Ejemplo n.º 10
0
 public static FunctionDescriptor getEnclosingFunctionDescriptor(
     @NotNull BindingContext context, @NotNull JetElement element) {
   JetFunction function = PsiTreeUtil.getParentOfType(element, JetFunction.class);
   return (FunctionDescriptor) context.get(DECLARATION_TO_DESCRIPTOR, function);
 }
Ejemplo n.º 11
0
 public boolean canBinding() {
   return context.isValid();
 }
Ejemplo n.º 12
0
 public Property getTargetProperty() {
   return context.getTargetProperty();
 }
Ejemplo n.º 13
0
 public IObservable getTarget() {
   return context.getTarget();
 }
Ejemplo n.º 14
0
 public Property getModelProperty() {
   return context.getModelProperty();
 }
Ejemplo n.º 15
0
 public IObservable getModel() {
   return context.getModel();
 }
Ejemplo n.º 16
0
  public Command bindWithCommand() {
    if (!canBinding()) {
      return null;
    }
    CompoundCommand commandList = new CompoundCommand();

    Property targetProperty = context.getTargetProperty();
    Property modelProperty = context.getModelProperty();
    IObservable target = context.getTarget();
    IObservable model = context.getModel();
    Object targetSource = target.getSource();

    Object modelSource = model.getSource();

    XamlNode node = null;
    if (targetSource instanceof Widget) {
      node = XWTProxy.getModel((Widget) targetSource);
    } else if (targetSource instanceof XamlElement) {
      node = (XamlElement) targetSource;
    }

    if (node == null) {
      return UnexecutableCommand.INSTANCE;
    }

    // 1. Get attr of targetProperty, such as < text="{}"/>
    XamlAttribute attribute = node.getAttribute(targetProperty.getName(), IConstants.XWT_NAMESPACE);
    if (attribute != null) {
      commandList.add(new DeleteCommand(attribute));
      attribute = null;
    }
    if (attribute == null) {
      attribute =
          XamlFactory.eINSTANCE.createAttribute(targetProperty.getName(), IConstants.XWT_NAMESPACE);
    }
    // 2. Binding Node.
    if (bindingNode == null) {
      bindingNode = attribute.getChild(BINDING, IConstants.XWT_NAMESPACE);
    }
    if (bindingNode == null) {
      bindingNode = XamlFactory.eINSTANCE.createElement(BINDING, IConstants.XWT_NAMESPACE);
    }
    // 3. ElementName
    int type = model.getType();
    if (type == IObservable.OBSERVE_SWT_JFACE) {
      addAttr(
          bindingNode,
          ELEMENT_NAME,
          IConstants.XWT_NAMESPACE,
          getCreateName(modelSource, commandList));
    }
    // 4. DataContext
    else if (IObservable.OBSERVE_JAVA_BAEN == type) {
      XamlDocument ownerDocument = node.getOwnerDocument();
      XamlElement rootElement = ownerDocument.getRootElement();
      DataContext dataContext = (DataContext) modelSource;
      String key = dataContext.getKey();
      if (key != null) {
        boolean canUseDC = getCodeStyles().useDataContext;
        if (canUseDC) {
          XamlAttribute contextNode =
              getAttribute(rootElement, DATA_CONTEXT, IConstants.XWT_NAMESPACE);
          contextNode.setUseFlatValue(true);

          XamlElement resourceNode =
              getElement(contextNode, STATIC_RESOURCE, IConstants.XWT_NAMESPACE);
          if (!key.equals(resourceNode.getValue())) {
            if (resourceNode.getValue() != null) {
              canUseDC = false;
            } else {
              resourceNode.setValue(key);
              commandList.add(new AddNewChildCommand(contextNode, resourceNode));
              commandList.add(new AddNewChildCommand(rootElement, contextNode));
            }
          }
        }
        if (!canUseDC || !getCodeStyles().useDataContext) {
          XamlAttribute sourceAttr = getAttribute(bindingNode, SOURCE, IConstants.XWT_NAMESPACE);
          sourceAttr.setUseFlatValue(true);
          XamlElement resourceNode =
              getElement(sourceAttr, STATIC_RESOURCE, IConstants.XWT_NAMESPACE);

          resourceNode.setValue(key);
          commandList.add(new AddNewChildCommand(sourceAttr, resourceNode));
          commandList.add(new AddNewChildCommand(bindingNode, sourceAttr));
        }
      }
    }

    // 5. Path
    addAttr(bindingNode, PATH, IConstants.XWT_NAMESPACE, modelProperty.toString());

    // 6. BindingMode
    if (bindingMode != null && BindingMode.TwoWay.equals(bindingMode)) {
      addAttr(bindingNode, MODE, IConstants.XWT_NAMESPACE, bindingMode.name());
    }

    // 7. Converter.
    if (converter != null) {
      addAttr(bindingNode, CONVERTER, IConstants.XWT_NAMESPACE, converter);
    }

    // 8. UpdateSourceTrigger
    if (triggerMode != null) {
      addAttr(bindingNode, UPDATE_SOURCE_TRIGGER, IConstants.XWT_NAMESPACE, triggerMode.name());
    }

    // 9. Code Style.
    attribute.setUseFlatValue(getCodeStyles().useFlatVlaue);

    if (!attribute.getChildNodes().contains(bindingNode)) {
      attribute.getChildNodes().add(bindingNode);
    }
    if (!node.getAttributes().contains(attribute)) {
      commandList.add(new AddNewChildCommand(node, attribute));
    }
    return commandList.unwrap();
  }
Ejemplo n.º 17
0
 @Nullable
 public static ResolvedCall<ConstructorDescriptor> getDelegationConstructorCall(
     @NotNull BindingContext bindingContext,
     @NotNull ConstructorDescriptor constructorDescriptor) {
   return bindingContext.get(CONSTRUCTOR_RESOLVED_DELEGATION_CALL, constructorDescriptor);
 }
Ejemplo n.º 18
0
  public void execute(
      XFormsActionInterpreter actionInterpreter,
      Element actionElement,
      Scope actionScope,
      boolean hasOverriddenContext,
      Item overriddenContext) {

    final IndentedLogger indentedLogger = actionInterpreter.indentedLogger();
    final XFormsContainingDocument containingDocument = actionInterpreter.containingDocument();
    final XFormsContextStack contextStack = actionInterpreter.actionXPathContext();

    final String atAttribute = actionElement.attributeValue("at");
    final String originAttribute = actionElement.attributeValue("origin");
    final String contextAttribute = actionElement.attributeValue(XFormsConstants.CONTEXT_QNAME);

    // Extension: allow position to be an AVT
    final String resolvedPositionAttribute =
        actionInterpreter.resolveAVT(actionElement, "position");

    // Extension: xxf:default="true" AVT requires that recalculate apply default values on the
    // inserted nodes.
    final boolean setRequireDefaultValues =
        "true"
            .equals(
                actionInterpreter.resolveAVT(
                    actionElement, XFormsConstants.XXFORMS_DEFAULTS_QNAME));

    // "2. The Node Set Binding node-set is determined."
    final List<Item> collectionToBeUpdated;
    {
      final BindingContext currentBindingContext = contextStack.getCurrentBindingContext();
      collectionToBeUpdated =
          currentBindingContext.newBind()
              ? currentBindingContext.nodeset()
              : XFormsConstants.EMPTY_ITEM_LIST;
    }
    final boolean isEmptyNodesetBinding =
        collectionToBeUpdated == null || collectionToBeUpdated.size() == 0;

    // "1. The insert context is determined."

    // "The insert action is terminated with no effect if [...] a. The context attribute is not
    // given and the Node
    // Set Binding node-set is the empty node-set."
    if (contextAttribute == null && isEmptyNodesetBinding) {
      if (indentedLogger.isDebugEnabled())
        indentedLogger.logDebug("xf:insert", "context is empty, terminating");
      return;
    }

    // Handle insert context (with @context attribute)
    final Item insertContextItem;
    if (hasOverriddenContext) {
      // "If the result is an empty nodeset or not a nodeset, then the insert action is terminated
      // with no effect. "
      if (overriddenContext == null || !(overriddenContext instanceof NodeInfo)) {
        if (indentedLogger.isDebugEnabled())
          indentedLogger.logDebug(
              "xf:insert", "overridden context is an empty nodeset or not a nodeset, terminating");
        return;
      } else {
        insertContextItem = overriddenContext;
      }
    } else {
      insertContextItem = contextStack.getCurrentBindingContext().getSingleItem();
    }

    // "The insert action is terminated with no effect if [...] b. The context attribute is given,
    // the insert
    // context does not evaluate to an element node and the Node Set Binding node-set is the empty
    // node-set."
    // NOTE: In addition we support inserting into a context which is a document node
    if (contextAttribute != null
        && isEmptyNodesetBinding
        && !DataModel.isElement(insertContextItem)
        && !DataModel.isDocument(insertContextItem)) {
      if (indentedLogger.isDebugEnabled())
        indentedLogger.logDebug(
            "xf:insert",
            "insert context is not an element node and binding node-set is empty, terminating");
      return;
    }

    // "3. The origin node-set is determined."
    final List<Item> originObjects;
    {
      if (originAttribute == null) {
        originObjects = null;
      } else {
        // There is an @origin attribute

        // "If the origin attribute is given, the origin node-set is the result of the evaluation of
        // the
        // origin attribute in the insert context."

        originObjects =
            actionInterpreter.evaluateKeepItems(
                actionElement, Collections.singletonList(insertContextItem), 1, originAttribute);

        // "The insert action is terminated with no effect if the origin node-set is the empty
        // node-set."
        if (originObjects.size() == 0) {
          if (indentedLogger.isDebugEnabled())
            indentedLogger.logDebug("xf:insert", "origin node-set is empty, terminating");
          return;
        }
      }
    }

    // "4. The insert location node is determined."
    int insertionIndex;
    {
      if (isEmptyNodesetBinding) {
        // "If the Node Set Binding node-set empty, then this attribute is ignored"
        insertionIndex = 0;
      } else if (atAttribute == null) {
        // "If the attribute is not given, then the default is the size of the Node Set Binding
        // node-set"
        insertionIndex = collectionToBeUpdated.size();
      } else {
        // "a. The evaluation context node is the first node in document order from the Node Set
        // Binding
        // node-set, the context size is the size of the Node Set Binding node-set, and the context
        // position is 1."

        // "b. The return value is processed according to the rules of the XPath function round()"
        final String insertionIndexString =
            actionInterpreter.evaluateAsString(
                actionElement, collectionToBeUpdated, 1, "round(" + atAttribute + ")");

        // "c. If the result is in the range 1 to the Node Set Binding node-set size, then the
        // insert
        // location is equal to the result. If the result is non-positive, then the insert location
        // is
        // 1. Otherwise, the result is NaN or exceeds the Node Set Binding node-set size, so the
        // insert
        // location is the Node Set Binding node-set size."

        // Don't think we will get NaN with XPath 2.0...
        insertionIndex =
            "NaN".equals(insertionIndexString)
                ? collectionToBeUpdated.size()
                : Integer.parseInt(insertionIndexString);

        // Adjust index to be in range
        if (insertionIndex > collectionToBeUpdated.size())
          insertionIndex = collectionToBeUpdated.size();

        if (insertionIndex < 1) insertionIndex = 1;
      }
    }

    final String normalizedPosition;
    {
      if (resolvedPositionAttribute == null) {
        // Default value
        normalizedPosition = "after";
      } else if ("after".equals(resolvedPositionAttribute)
          || "before".equals(resolvedPositionAttribute)) {
        // Specified value
        normalizedPosition = resolvedPositionAttribute;
      } else {
        // Invalid value
        if (indentedLogger.isInfoEnabled())
          indentedLogger.logWarning(
              "xf:insert",
              "invalid position attribute, defaulting to \"after\"",
              "value",
              resolvedPositionAttribute);

        normalizedPosition = "after";
      }
    }

    doInsert(
        containingDocument,
        indentedLogger,
        normalizedPosition,
        collectionToBeUpdated,
        (NodeInfo) insertContextItem,
        originObjects,
        insertionIndex,
        true,
        true,
        setRequireDefaultValues);
  }