Java ScopeMapping.push方法代碼示例

import edu.cornell.cs.nlp.spf.mr.lambda.mapping.ScopeMapping; //導入方法依賴的package包/類
@Override
public boolean equals(LogicalExpression exp,
		ScopeMapping<Variable, Variable> mapping) {
	if (!(exp instanceof SkolemId)) {
		return false;
	}

	final Variable mappedValue = mapping.peek(this);
	if (mappedValue == exp && mapping.peekValue(mappedValue) == this) {
		return true;
	} else if (exp instanceof SkolemIdInstanceWrapper) {
		return exp.equals(this, mapping);
	} else if (!mapping.containsValue((SkolemId) exp)) {
		mapping.push(this, (SkolemId) exp);
		return true;
	} else {
		return false;
	}
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.mapping.ScopeMapping; //導入方法依賴的package包/類
@Test
public void testCreateArg4() {
	final LogicalExpression resultSubExp = TestServices
			.getCategoryServices().readSemantics("(pred:<e,t> $0:e)");
	final LogicalExpression functionSubExp = TestServices
			.getCategoryServices().readSemantics("($1:<e,t> $0:e)");
	final Variable applicationArg = (Variable) ((Literal) functionSubExp)
			.getPredicate();
	final LogicalExpression expected = TestServices.getCategoryServices()
			.readSemantics("pred:<e,t>");
	final ScopeMapping<Variable, Variable> scope = new ScopeMapping<Variable, Variable>();
	scope.push((Variable) ((Literal) functionSubExp).getArg(0),
			(Variable) ((Literal) resultSubExp).getArg(0));
	Assert.assertEquals(expected, GetApplicationArgument.createArgument(
			resultSubExp, functionSubExp, applicationArg, scope));

}
 

import edu.cornell.cs.nlp.spf.mr.lambda.mapping.ScopeMapping; //導入方法依賴的package包/類
@Override
public Variable read(String string,
		ScopeMapping<String, LogicalExpression> mapping,
		TypeRepository typeRepository, ITypeComparator typeComparator,
		LogicalExpressionReader reader) {

	try {
		final Pair<String, Variable> defintion = readVariableDefintion(
				string, typeRepository);
		if (defintion != null && !mapping.containsKey(string)) {
			mapping.push(defintion.first(), defintion.second());
			return defintion.second();
		} else if (defintion != null) {
			throw new LogicalExpressionRuntimeException(
					"Re-define a global variable: " + string);
		} else {
			// Case variable reference.
			if (mapping.containsKey(string)) {
				return (Variable) mapping.peek(string);
			} else {
				throw new LogicalExpressionRuntimeException(
						"Undefined variable reference: " + string);
			}
		}
	} catch (final RuntimeException e) {
		LOG.error("Variable error: %s", string);
		throw e;
	}

}
 

import edu.cornell.cs.nlp.spf.mr.lambda.mapping.ScopeMapping; //導入方法依賴的package包/類
@Override
protected boolean doEquals(LogicalExpression exp,
		ScopeMapping<Variable, Variable> mapping) {
	if (this == exp) {
		// Since skolem IDs from this literal may be used in other parts of
		// the logical form, we need to create a mapping of them. As the
		// instances are identical, we can just update the mapping by
		// creating a mapping from each SkolemId to itself.
		if (!freeVariables.isEmpty()) {
			for (final Variable freeVariable : freeVariables) {
				if (freeVariable instanceof SkolemId) {
					mapping.push(freeVariable, freeVariable);
				}
			}
		}
		return true;
	}
	if (getClass() != exp.getClass()) {
		return false;
	}
	final Lambda other = (Lambda) exp;
	if (!type.equals(other.type)) {
		return false;
	}

	if (argument.getType().equals(other.argument.getType())) {
		// If the types are equal and both are not null, add the mapping for
		// the comparison of the body.
		mapping.push(argument, other.argument);
	} else {
		return false;
	}

	final boolean ret = body.equals(other.body, mapping);

	// Remove mapping.
	mapping.pop(argument);

	return ret;
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.mapping.ScopeMapping; //導入方法依賴的package包/類
@Override
public SkolemId read(String string,
		ScopeMapping<String, LogicalExpression> mapping,
		TypeRepository typeRepository, ITypeComparator typeComparator,
		LogicalExpressionReader reader) {
	if (!mapping.containsKey(string)) {
		mapping.push(string, new SkolemId());
	}
	return (SkolemId) mapping.peek(string);
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.mapping.ScopeMapping; //導入方法依賴的package包/類
@Override
public Lambda read(String string,
		ScopeMapping<String, LogicalExpression> mapping,
		TypeRepository typeRepository, ITypeComparator typeComparator,
		LogicalExpressionReader reader) {

	try {
		final LispReader lispReader = new LispReader(new StringReader(
				string));

		// The first argument is the 'lambda' keyword. We just ignore
		// it.
		lispReader.next();

		// The second argument is the variable definition.
		final Pair<String, Variable> variableDef = Variable
				.readVariableDefintion(lispReader.next(),
						typeRepository);

		if (variableDef == null) {
			throw new LogicalExpressionRuntimeException(
					"Invalid lambda argument: " + string);
		}

		// Update the scope mapping.
		mapping.push(variableDef.first(), variableDef.second());

		// The next argument is the body expression.
		final LogicalExpression lambdaBody = reader.read(
				lispReader.next(), mapping, typeRepository,
				typeComparator);

		// Verify that we don't have any more elements.
		if (lispReader.hasNext()) {
			throw new LogicalExpressionRuntimeException(String.format(
					"Invalid lambda expression: %s", string));
		}

		// Remove the variable from the mapping.
		if (mapping.pop(variableDef.first()) == null) {
			throw new LogicalExpressionRuntimeException(
					"Failed to remove variable from mapping. Something werid is happening: "
							+ string);
		}

		return new Lambda(variableDef.second(), lambdaBody);
	} catch (final RuntimeException e) {
		LOG.error("Lambda syntax error: %s", string);
		throw e;
	}

}