Java LogicalConstant.getBaseName方法代码示例

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
/**
 * Extract the "lemma" of a constant.
 */
@Deprecated
public static String lemmatizeConstant(LogicalConstant constant) {
	if (isAmrRelation(constant)) {
		return null;
	}

	final String lemma;
	final Matcher matcher = FRAME_PREDICATE_REGEX
			.matcher(constant.getBaseName());
	if (matcher.matches()) {
		lemma = matcher.group("pred");
	} else {
		lemma = constant.getBaseName();
	}
	return lemma;
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
public LogicalExpressionCoordinationServices(
		LogicalConstant baseConjunctionConstant,
		LogicalConstant baseDisjunctionConstant,
		ICategoryServices<LogicalExpression> categoryServices) {
	this.baseConjunctionConstant = baseConjunctionConstant;
	this.baseDisjunctionConstant = baseDisjunctionConstant;
	this.categoryServices = categoryServices;
	this.baseConjunctionName = baseConjunctionConstant.getBaseName();
	this.baseDisjunctionName = baseDisjunctionConstant.getBaseName();
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
/**
 * Given a passive relation, returns its active form. Otherwise, returns
 * null.
 *
 * @param underspecified
 *            The output should be underspecified or not.
 */
public static LogicalExpression makeRelationActive(LogicalConstant constant,
		boolean underspecified) {
	if (isAmrRelation(constant)) {
		String baseName;
		boolean overload;
		if (constant instanceof OverloadedLogicalConstant) {
			baseName = ((OverloadedLogicalConstant) constant)
					.getWrappedConstant().getBaseName();
			overload = true;
		} else {
			baseName = constant.getBaseName();
			overload = false;
		}

		if (baseName.endsWith(INVERSE_RELATION_SUFFIX)) {
			final LogicalConstant activeConstant = underspecified
					? (LogicalConstant) underspecify(LogicalConstant.create(
							baseName.substring(0, baseName.length()
									- INVERSE_RELATION_SUFFIX.length()),
							constant.getType(), true))
					: LogicalConstant.create(
							baseName.substring(0, baseName.length()
									- INVERSE_RELATION_SUFFIX.length()),
							constant.getType(), true);
			if (overload) {
				return ((OverloadedLogicalConstant) constant)
						.cloneWrapper(activeConstant);
			} else {
				return activeConstant;
			}
		}
	}
	return null;
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
/**
 * Convert a binary relation to its passive version, e.g., boo:<e,<e,t>> ->
 * boo-of:<e,<e,t>>.
 */
public static LogicalConstant makeRelationPassive(LogicalConstant constant,
		boolean underspecified) {
	if (isAmrRelation(constant)) {
		String baseName;
		boolean overload;
		if (constant instanceof OverloadedLogicalConstant) {
			baseName = ((OverloadedLogicalConstant) constant)
					.getWrappedConstant().getBaseName();
			overload = true;
		} else {
			baseName = constant.getBaseName();
			overload = false;
		}

		if (!baseName.endsWith(INVERSE_RELATION_SUFFIX)) {
			final LogicalConstant passiveConstant = underspecified
					? (LogicalConstant) underspecify(LogicalConstant.create(
							baseName + INVERSE_RELATION_SUFFIX,
							constant.getType(), true))
					: LogicalConstant.create(
							baseName + INVERSE_RELATION_SUFFIX,
							constant.getType(), true);
			if (overload) {
				return ((OverloadedLogicalConstant) constant)
						.cloneWrapper(passiveConstant);
			} else {
				return passiveConstant;
			}
		}
	}
	return null;
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
public Set<LogicalExpression> getAssignments(
		LogicalConstant underspecifiedConstant) {
	final LogicalConstant stripped = OverloadedLogicalConstant
			.getWrapped(underspecifiedConstant);
	final String baseName = stripped.getBaseName();
	final Type type = stripped.getType();
	if (assignmentMapping.containsKey(baseName)) {
		return assignmentMapping.get(baseName).stream()
				.map((name) -> LogicalConstant.create(name, type, true))
				.collect(Collectors.toSet());
	} else if (underspecifyPropBank
			&& baseName.endsWith(PROPBANK_ROLE_WILDCARD)) {
		final String lemma = baseName.substring(0,
				baseName.length() - PROPBANK_ROLE_WILDCARD.length());
		final Set<PropBankFrame> frames = AMRServices
				.getPropBankFrames(lemma);
		if (frames.isEmpty()) {
			return Collections.emptySet();
		}
		return frames.stream()
				.map(frame -> LogicalConstant.create(
						lemma + PROPBANK_ROLE_SEP
								+ String.format("%02d", frame.getId()),
						type, true))
				.collect(Collectors.toSet());
	} else {
		return Collections.emptySet();
	}
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
public LogicalConstant underspecify(LogicalConstant constant) {
	final String baseName = constant.getBaseName();

	// Verify type <?,<?,t>>.
	if (constant.getType().isComplex()
			&& constant.getType().getRange().isComplex()
			&& LogicLanguageServices.getTypeRepository().getTruthValueType()
					.equals(constant.getType().getRange().getRange())
			&& underspecMapping.containsKey(baseName)) {
		return LogicalConstant.create(underspecMapping.get(baseName),
				constant.getType(), true);
	}

	// Verify type <?,t>.
	if (underspecifyPropBank && constant.getType().isComplex()
			&& constant.getType().getRange().equals(LogicLanguageServices
					.getTypeRepository().getTruthValueType())) {
		// If this is a PropBank frame, underspecify.
		if (AMRServices.isPropBankFrame(baseName)) {
			final String lemma = baseName.substring(0,
					baseName.length() - PROPBANK_ROLE_WILDCARD.length());
			if (!AMRServices.getPropBankFrames(lemma).isEmpty()) {
				return LogicalConstant.create(
						lemma + PROPBANK_ROLE_WILDCARD, constant.getType(),
						true);
			}
		}
	}

	return constant;
}
 

import edu.cornell.cs.nlp.spf.mr.lambda.LogicalConstant; //导入方法依赖的package包/类
@Override
public void visit(LogicalConstant logicalConstant) {
	headString = stripType ? logicalConstant.getBaseName()
			: logicalConstant.getName();
}