public static double computeTraitConcordance(Model model, IResolutionScope context) { /* * list of traits in common. Don't check the trait value - assumed the same * because of the search strategy. */ try { IKnowledge c = model.getObservableConcept(); // getWantedObservable(model, // context); if (c == null) { // TODO issues here - just a hack, should not happen return 0; } Collection<IConcept> attrs = Traits.separateAttributes(c).getSecond(); Collection<IConcept> wanted = ((ResolutionScope) context).getTraits(); int common = 0; if (attrs.size() == 0 && wanted.size() == 0) return 100.0; for (IConcept zio : wanted) { if (attrs.contains(zio)) { common++; } } if (wanted.size() > 0) { return 100.0 * ((double) common / (double) wanted.size()); } } catch (Exception e) { } return 0; }
@Override public boolean hasAttribute(IConcept attribute) { Collection<IConcept> roles = Traits.getAttributes(getType()); if (roles.contains(attribute)) { return true; } for (IConcept r : roles) { if (r.is(attribute)) { return true; } } return false; }
/** * Return the observable that represent the passed one without any of the traits it * may inherit. * * @param observable * @return naked observable */ public static IKnowledge getBaseObservable(IKnowledge observable) { if (!(observable instanceof IConcept)) { return observable; } if (getTraits(observable).isEmpty()) { return observable; } for (IConcept o : ((IConcept) observable).getParents()) { if (NS.isObservable(o)) { return getBaseObservable(o); } } return null; }
report.writeln(filler + "* root observable: " + baseType); Collection<IConcept> identities = Traits.getIdentities(k); Collection<IConcept> realms = Traits.getRealms(k); Collection<IConcept> attributes = Traits.getAttributes(k); Collection<IConcept> roles = Roles.getRoles(k); Collection<IConcept> exposed = Traits.getExposedTraits(k); if (exposed.isEmpty()) { report.writeln(filler + "* no exposed traits");
t = Traits.getTraitFor(t); t = Traits.getConcreteObservabilityTrait(t, co .isNegated()); } else if (co.isNegated()) { if (co.isNegated()) { try { t = Traits.getNegation(t); } catch (KlabValidationException e) { context.error(e.getMessage(), co.getFirstLineNumber()); try { for (ICompileWarning warning : Traits .addTraitsToDeclaredConcept(knowledge, Collections .singleton(trait), null, null)) { context.warning(warning.getMessage(), co try { for (ICompileWarning warning : Traits .addTraitsToDeclaredConcept(knowledge, identities, null, null)) { context.warning(warning.getMessage(), getFirstLineNumber());
concept = Traits.getImpliedObservable(concept); Collection<IConcept> traits = Traits.getTraits(concept); if (traits.size() > 0) { try {
.declareObservable(main, trs, ctx, inh, rls, byt, dnt, onto); if (observability || observable) { ret = Traits.getObservabilityOf(ret, observability); } else if (denied) { ret = Traits.getNegation(ret);
public void setConceptSpace(IConcept concept) { // avoid NPEs after parsing syntax errors. if (concept == null) { return; } if (Types.isDelegate(concept)) { concept = Types.getExposedTraits(concept).iterator().next(); } if (NS.isObservability(concept)) { concept = Traits.getImpliedObservable(concept); } IConcept traitType = Observables.getByType(concept); if (traitType != null) { concept = traitType; } this.allowedChildren.addAll(Observables.getRestrictedClosure(concept)); this.cSpace = concept; }
private static String negate(String id, KIMScope context, int line) { /* * ensure id is known */ IConcept original = null; if (id.contains(":")) { original = KLAB.KM.getConcept(id); } else { original = context.getNamespace().getOntology().getConcept(id); } if (original == null) { context.error("concept " + id + " is unknown", line); } else { try { original = Traits.getNegation(original); } catch (KlabValidationException e) { context.error(e.getMessage(), line); } } return original.toString(); }
@Override public boolean hasIdentity(IConcept identity) { Collection<IConcept> roles = Traits.getIdentities(getType()); if (roles.contains(identity)) { return true; } for (IConcept r : roles) { if (r.is(identity)) { return true; } } return false; }
return Observables.makeTypeFor(Traits.getObservabilityOf(original, true)); } else {
IConcept implied = getImpliedObservable(trait);
main = Traits.getNegation(main); } catch (KlabValidationException e) { context.error(e.getMessage(), lineNumber(statement));
.separateAttributes(observable.getType()); for (IConcept attribute : ast.getSecond()) { IConcept baset = NS.getBaseParentTrait(attribute);
/** * Analyze an observable concept and return the main observable with all the original * identities and realms but no attributes; separately, return the list of the * attributes that were removed. * * @param observable * @return attribute profile * @throws KlabValidationException */ public static Pair<IConcept, Collection<IConcept>> separateAttributes(IKnowledge observable) throws KlabValidationException { IKnowledge obs = getBaseObservable(observable); ArrayList<IConcept> tret = new ArrayList<>(); ArrayList<IConcept> keep = new ArrayList<>(); for (IConcept zt : getTraits(observable)) { if (zt.is(KLAB.c(NS.CORE_IDENTITY_TRAIT)) || zt.is(KLAB.c(NS.CORE_REALM_TRAIT))) { keep.add(zt); } else { tret.add(zt); } } return new Pair<>(Observables.declareObservable((IConcept) (obs == null ? observable : obs), keep, Observables.getContextType(observable), Observables .getInherentType(observable)), tret); }
/** * Return the passed knowledge after removing any traits of the passed base type, or * the original knowledge if the trait was absent. * * @param knowledge * @return knowledge without the trait * @throws KlabValidationException */ public static IKnowledge removeTrait(IConcept knowledge, IConcept baseTrait) throws KlabValidationException { Pair<IConcept, Collection<IConcept>> trs = separateAttributes(knowledge); ArrayList<IConcept> traits = new ArrayList<>(); boolean found = false; for (IConcept tr : trs.getSecond()) { if (tr.is(baseTrait)) { found = true; } else { traits.add(tr); } } return found ? Observables.declareObservable(trs.getFirst(), traits, Observables .getContextType(knowledge), Observables .getInherentType(knowledge)) : knowledge; }