本文整理汇总了Java中org.eclipse.xtext.xbase.XClosure类的典型用法代码示例。如果您正苦于以下问题:Java XClosure类的具体用法?Java XClosure怎么用?Java XClosure使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
XClosure类属于org.eclipse.xtext.xbase包,在下文中一共展示了XClosure类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: isPossibleFunctionType
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
/**
* Returns false if the argument expression is a lambda and the expected type
* of the argument is not a function type or {@link Object}.
* Returns true in all other cases.
*
* This serves as a shortcut to rule out decision path's where a method is overloaded
* and one of the overloads accepts a function type but the other doesn't. In those cases
* it is not necessary to compute the type of the lamdba expression twice.
*
* An example for this pattern is {@link IterableExtensions#filter(Iterable, Class)} vs
* {@link IterableExtensions#filter(Iterable, org.eclipse.xtext.xbase.lib.Functions.Function1)}.
*/
protected boolean isPossibleFunctionType(int idx) {
if (idx < arguments.getArgumentCount()) {
XExpression argument = arguments.getArgument(idx);
if (argument instanceof XClosure) {
XClosure closure = (XClosure) argument;
LightweightTypeReference declaredType = arguments.getDeclaredTypeForLambda(idx);
if (declaredType != null && !declaredType.isType(Object.class)) {
CommonTypeComputationServices services = getState().getReferenceOwner().getServices();
JvmOperation operation = services.getFunctionTypes().findImplementingOperation(declaredType);
if (operation == null) {
return false;
}
if (closure.isExplicitSyntax() && closure.getDeclaredFormalParameters().size() != operation.getParameters().size()) {
return false;
}
}
}
}
return true;
}
示例2: isXShortClosure
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean isXShortClosure(List<?> values, EReference reference, INodesForEObjectProvider nodes) {
if (values.isEmpty() || values.size() > 2 || !(values.get(0) instanceof XClosure))
return false;
XClosure closure = (XClosure) values.get(0);
if (!closure.isExplicitSyntax())
return false;
INode node = nodes.getNodeForMultiValue(reference, 0, 0, closure);
if (node != null) {
if (node.getGrammarElement() instanceof RuleCall)
return ((RuleCall) node.getGrammarElement()).getRule() == grammarAccess.getXShortClosureRule();
if (node.getGrammarElement() instanceof Action)
return node.getGrammarElement() == grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0();
return false;
}
return true;
}
示例3: isBuilderSyntax
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean isBuilderSyntax(List<?> values, EReference reference, INodesForEObjectProvider nodes) {
if (values.isEmpty())
return false;
int lastIndex = values.size() - 1;
Object lastValue = values.get(lastIndex);
if (!(lastValue instanceof XClosure))
return false;
INode node = nodes.getNodeForMultiValue(reference, lastIndex, lastIndex, values.get(lastIndex));
if (node != null) {
if (node.getGrammarElement() instanceof RuleCall)
return ((RuleCall) node.getGrammarElement()).getRule() == grammarAccess.getXClosureRule();
if (node.getGrammarElement() instanceof Action)
return node.getGrammarElement() == grammarAccess.getXClosureAccess().getXClosureAction_0_0_0();
return false;
}
return true;
}
示例4: bracesAreAddedByOuterStructure
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean bracesAreAddedByOuterStructure(XExpression expression) {
EObject container = expression.eContainer();
if (container instanceof XTryCatchFinallyExpression
|| container instanceof XIfExpression
|| container instanceof XClosure
|| container instanceof XSynchronizedExpression) {
return true;
}
if (container instanceof XBlockExpression) {
XBlockExpression blockExpression = (XBlockExpression) container;
EList<XExpression> expressions = blockExpression.getExpressions();
if (expressions.size() == 1 && expressions.get(0) == expression) {
return bracesAreAddedByOuterStructure(blockExpression);
}
}
if (!(container instanceof XExpression)) {
return true;
}
return false;
}
示例5: _toJavaStatement
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected void _toJavaStatement(final XClosure closure, final ITreeAppendable b, boolean isReferenced) {
if (!isReferenced)
throw new IllegalArgumentException("a closure definition does not cause any side-effects");
LightweightTypeReference type = getLightweightType(closure);
JvmOperation operation = findImplementingOperation(type);
if (operation != null) {
b.newLine().append("final ");
b.append(type);
b.append(" ");
String variableName = b.declareSyntheticVariable(closure, "_function");
b.append(variableName).append(" = ");
GeneratorConfig config = b.getGeneratorConfig();
if (config != null && config.getJavaSourceVersion().isAtLeast(JAVA8) && canCompileToJavaLambda(closure, type, operation)) {
toLambda(closure, b, type, operation, false);
} else {
toAnonymousClass(closure, b, type, operation);
}
b.append(";");
}
}
示例6: _toJavaExpression
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected void _toJavaExpression(final XClosure closure, final ITreeAppendable b) {
if (b.hasName(closure)) {
b.trace(closure, false).append(getVarName(closure, b));
} else {
LightweightTypeReference type = getLightweightType(closure);
JvmOperation operation = findImplementingOperation(type);
if (operation != null) {
GeneratorConfig config = b.getGeneratorConfig();
if (config != null && config.getJavaSourceVersion().isAtLeast(JAVA8) && canCompileToJavaLambda(closure, type, operation)) {
toLambda(closure, b.trace(closure, false), type, operation, true);
} else {
toAnonymousClass(closure, b.trace(closure, false), type, operation);
}
}
}
}
示例7: canCompileToJavaLambda
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean canCompileToJavaLambda(XClosure closure, LightweightTypeReference typeRef, JvmOperation operation) {
if (!typeRef.isInterfaceType())
return false;
if (!operation.getTypeParameters().isEmpty())
return false;
TreeIterator<EObject> iterator = closure.eAllContents();
JvmType jvmType = typeRef.getType();
while (iterator.hasNext()) {
EObject obj = iterator.next();
if (obj instanceof XClosure) {
iterator.prune();
} else if (obj instanceof XFeatureCall && isReferenceToSelf((XFeatureCall) obj, jvmType)) {
return false;
}
}
return true;
}
示例8: builder
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected XClosure builder(final List<XExpression> params) {
XClosure _xifexpression = null;
XExpression _last = IterableExtensions.<XExpression>last(params);
boolean _tripleNotEquals = (_last != null);
if (_tripleNotEquals) {
XClosure _xblockexpression = null;
{
final EObject grammarElement = this.textRegionExtensions.grammarElement(IterableExtensions.<XExpression>last(params));
XClosure _xifexpression_1 = null;
if (((Objects.equal(grammarElement, this.grammar.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()) ||
Objects.equal(grammarElement, this.grammar.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0())) ||
Objects.equal(grammarElement, this.grammar.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()))) {
XExpression _last_1 = IterableExtensions.<XExpression>last(params);
_xifexpression_1 = ((XClosure) _last_1);
}
_xblockexpression = _xifexpression_1;
}
_xifexpression = _xblockexpression;
}
return _xifexpression;
}
示例9: explicitParams
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected Iterable<XExpression> explicitParams(final List<XExpression> params) {
Iterable<XExpression> _xblockexpression = null;
{
final XClosure builder = this.builder(params);
Iterable<XExpression> _xifexpression = null;
if ((builder != null)) {
int _size = params.size();
int _minus = (_size - 1);
_xifexpression = IterableExtensions.<XExpression>take(params, _minus);
} else {
_xifexpression = params;
}
_xblockexpression = _xifexpression;
}
return _xblockexpression;
}
示例10: prependNewLineIfMultiline
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected boolean prependNewLineIfMultiline(final EObject obj) {
boolean _switchResult = false;
boolean _matched = false;
if (obj instanceof XMemberFeatureCall) {
_matched=true;
_switchResult = this.prependNewLineIfMultiline(this.builder(((XMemberFeatureCall)obj).getMemberCallArguments()));
}
if (!_matched) {
if (obj instanceof XClosure) {
_matched=true;
_switchResult = false;
}
}
if (!_matched) {
if (obj instanceof XBlockExpression) {
_matched=true;
_switchResult = false;
}
}
if (!_matched) {
_switchResult = true;
}
return _switchResult;
}
示例11: builder
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
protected XClosure builder(final List<XExpression> params) {
XClosure _xifexpression = null;
XExpression _last = IterableExtensions.<XExpression>last(params);
boolean _tripleNotEquals = (_last != null);
if (_tripleNotEquals) {
XClosure _xblockexpression = null;
{
INode _nodeForEObject = this._nodeModelAccess.nodeForEObject(IterableExtensions.<XExpression>last(params));
final EObject grammarElement = ((ICompositeNode) _nodeForEObject).getFirstChild().getGrammarElement();
XClosure _xifexpression_1 = null;
if (((Objects.equal(grammarElement, this._xbaseGrammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()) ||
Objects.equal(grammarElement, this._xbaseGrammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0())) ||
Objects.equal(grammarElement, this._xbaseGrammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()))) {
XExpression _last_1 = IterableExtensions.<XExpression>last(params);
_xifexpression_1 = ((XClosure) _last_1);
}
_xblockexpression = _xifexpression_1;
}
_xifexpression = _xblockexpression;
}
return _xifexpression;
}
示例12: isMultilineLambda
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
/**
* checks whether the given lambda should be formatted as a block.
* That includes newlines after and before the brackets, and a fresh line for each expression.
*/
protected boolean isMultilineLambda(final XClosure closure) {
final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(closure, "]");
HiddenLeafs _hiddenLeafsBefore = null;
if (closingBracket!=null) {
_hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket);
}
boolean _tripleNotEquals = (_hiddenLeafsBefore != null);
if (_tripleNotEquals) {
int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines();
return (_newLines > 0);
}
boolean _switchResult = false;
XExpression _expression = closure.getExpression();
final XExpression block = _expression;
boolean _matched = false;
if (block instanceof XBlockExpression) {
_matched=true;
_switchResult = ((((XBlockExpression)block).getExpressions().size() > 1) && this.isEachExpressionInOwnLine(((XBlockExpression)block).getExpressions()));
}
if (!_matched) {
_switchResult = false;
}
return _switchResult;
}
示例13: testClosureParameter
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Test
public void testClosureParameter() throws Exception {
// List<? super String> list = Lists.newArrayList();
// ListExtensions.map(list, new Functions.Function1<CharSequence, String>() {
// public String apply(CharSequence p) {
// return null;
// }
// });
// ListExtensions.map(list, new Functions.Function1<Object, String>() {
// public String apply(Object p) {
// return null;
// }
// });
XBlockExpression block = (XBlockExpression) expression(
"{\n" +
" var java.util.List<? super String> list = null;\n" +
" list.map(e|e)\n" +
"}");
XMemberFeatureCall featureCall = (XMemberFeatureCall) block.getExpressions().get(1);
XClosure closure = (XClosure) featureCall.getMemberCallArguments().get(0);
JvmFormalParameter e = closure.getDeclaredFormalParameters().get(0);
LightweightTypeReference typeRef = typeResolver.resolveTypes(closure).getActualType(e);
assertEquals("java.lang.Object", typeRef.getIdentifier());
}
示例14: testSerialize_01
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Test public void testSerialize_01() throws Exception {
Resource resource = newResource("'foo' as String");
XCastedExpression casted = (XCastedExpression) resource.getContents().get(0);
XbaseFactory factory = XbaseFactory.eINSTANCE;
XClosure closure = factory.createXClosure();
XStringLiteral stringLiteral = factory.createXStringLiteral();
stringLiteral.setValue("value");
XBlockExpression blockExpression = factory.createXBlockExpression();
blockExpression.getExpressions().add(stringLiteral);
closure.setExpression(blockExpression);
closure.setExplicitSyntax(true);
XInstanceOfExpression instanceOfExpression = factory.createXInstanceOfExpression();
instanceOfExpression.setExpression(closure);
instanceOfExpression.setType(EcoreUtil.copy(casted.getType()));
resource.getContents().clear();
resource.getContents().add(instanceOfExpression);
ISerializer serializer = get(ISerializer.class);
String string = serializer.serialize(instanceOfExpression);
assertEquals("[|\"value\"] instanceof String", string);
XInstanceOfExpression parsedExpression = parseHelper.parse(string);
assertTrue(EcoreUtil.equals(instanceOfExpression, parsedExpression));
}
示例15: checkClosureParameterTypes
import org.eclipse.xtext.xbase.XClosure; //导入依赖的package包/类
@Check
public void checkClosureParameterTypes(XClosure closure) {
if (closure.getFormalParameters().isEmpty())
return;
LightweightTypeReference closureType = getActualType(closure);
if (closureType != null && closureType.isUnknown())
return;
boolean checkedClosure = false;
for (JvmFormalParameter p : closure.getFormalParameters()) {
if (p.getParameterType() == null) {
if (!checkedClosure) {
LightweightTypeReference type = getExpectedType(closure);
if (type == null) {
error("There is no context to infer the closure's argument types from. Consider typing the arguments or put the closures into a typed context.",
closure, null, INSIGNIFICANT_INDEX, TOO_LITTLE_TYPE_INFORMATION);
return;
} else {
JvmOperation operation = getServices().getFunctionTypes().findImplementingOperation(type);
if (operation == null) {
error("There is no context to infer the closure's argument types from. Consider typing the arguments or use the closures in a more specific context.",
closure, null, INSIGNIFICANT_INDEX, TOO_LITTLE_TYPE_INFORMATION);
return;
}
}
checkedClosure = true;
}
LightweightTypeReference parameterType = getActualType(closure, p);
if (parameterType == null) {
error("There is no context to infer the closure's argument types from. Consider typing the arguments or use the closures in a more specific context.",
closure, null, INSIGNIFICANT_INDEX, TOO_LITTLE_TYPE_INFORMATION);
return;
}
}
}
}