public static void restrict(IConcept target, IProperty property, LogicalConnector how, Set<IConcept> fillers) throws KlabValidationException { /* * divide up in bins according to base trait; take property from annotation; * restrict each group. */ Map<IConcept, List<IConcept>> pairs = new HashMap<>(); for (IConcept t : fillers) { IConcept base = NS.getBaseParentTrait(t); if (!pairs.containsKey(base)) { pairs.put(base, new ArrayList<>()); } pairs.get(base).add(t); } for (IConcept base : pairs.keySet()) { String prop = base.getMetadata().getString(NS.TRAIT_RESTRICTING_PROPERTY); if (prop == null || KLAB.KM.getProperty(prop) == null) { throw new KlabValidationException("cannot find property to restrict for trait " + base); } OWL.restrictSome(target, KLAB.p(prop), how, pairs.get(base)); } }
private static void insertIds(IConcept concept, List<String> ids) { String id = NS.getDisplayName(concept); if (!ids.contains(id)) { ids.add(id); } id = CamelCase.toLowerCase(id, '-'); if (!ids.contains(id)) { ids.add(id); } }
if (NS.isClass(original)) { if (original.isAbstract() || NS.isBaseDeclaration(original)) { return original; } else { problem = "classified type cannot be specific"; } else if (NS.isTrait(original)) { if (by == null) { return Observables.makeTypeFor(original); } else if (NS.isDirect(original)) { if (by == null) { return Observables.makeTypeFor(Traits.getObservabilityOf(original, true)); } else if (NS.isQuality(original)) {
/** * True if the passed knowledge is a direct observable, i.e., an object * (see @{link isObject}) or a relationship. * * @param o * @return true if directly observable */ public static boolean isDirect(ISemantic o) { IKnowledge observable = o.getType(); return isObject(observable) || isRelationship(observable); }
if (NS.isIdentity(coreConcept)) { context.getNamespace().registerAuthority(identity); ((Ontology) context.getNamespace().getOntology()) coreConcept = (IConcept) NS.getCoreType(cconcept); } else { if (NS.isNothing(co)) { NS.registerNothingConcept(knowledge.toString()); IConcept core = (IConcept) NS.getCoreType(c); if (!Validator.checkParent(core, coreConcept)) { context.error("cannot make " if (NS.isObservable(t)) { } else if (!NS.isTrait(t)) { context.error(co.getId() + ": only traits or observables are allowed here", co } else if (coreConcept != null && NS.isConfiguration(coreConcept)) { context.error("configurations must specify a subject type in the 'applies to' clause", lineNumber(statement)); if (coreConcept != null && !NS.isProcess(coreConcept)) { context.error("only processes can use the 'affects' clause, to define the qualities they modify in their context", lineNumber(statement)); && !(NS.isProcess(coreConcept) || NS.isEvent(coreConcept))) { context.error("only processes can use the 'confers' clause, to define traits they confer to their context subjects", lineNumber(statement));
if (NS.isQuality(obs) || NS.isTrait(obs)) { .getType(), lineNumber(statement.getConcept()), NS.isQuality(obs)); } else if (!(NS.isClass(obs) || NS.isTrait(obs)) && !NS.isDirect(obs)) { if (NS.isObject(this.observable)) { ((ObservableSemantics) this.observable).setModel(null); context.error("unknown concept " + statement.getTraitConferred() + ": must be a role or trait", lineNumber(statement)); } else if (!NS.isTrait(trait) && !NS.isRole(trait)) { context.error("concept " + statement.getTraitConferred() + " is not a role or trait", lineNumber(statement)); .get(KIMScope.Type.DEPENDENCY_OBSERVABLE), statement .getDcontext(), null); if (!((statement.isEach() && NS.isCountable(dctx)) || (statement.isEach() && NS.isProcess(dctx)))) { context.error("distributing dependencies must be on countable observables (subjects or events) if 'each' is given, or on processes if not", lineNumber(statement .getDcontext())); if (!NS.isCountable(observable.getType()) || observable.getType().isAbstract()) { context.error("generic dependencies ('every') are only allowed with non-abstract, countable observables", lineNumber(statement));
private IConcept chooseDirectAccessorType(IKnowledge ob) throws KlabValidationException { if (NS.isQuality(ob)) { return KLAB.c(NS.STATE_CONTEXTUALIZER); } else if (NS.isThing(ob)) { return KLAB.c(NS.SUBJECT_CONTEXTUALIZER); } else if (NS.isProcess(ob)) { return KLAB.c(NS.PROCESS_CONTEXTUALIZER); } else if (NS.isEvent(ob)) { return KLAB.c(NS.EVENT_INSTANTIATOR); } throw new KlabValidationException("subject model has observable that doesn't match any accessor type"); }
context.error("cannot understand " + observable.getRole() + " as a role", lineNumber(statement)); } else if (!NS.isRole(role)) { context.error(observable.getRole() + " does not specify a role", lineNumber(statement)); refContext = (NS.isCountable(ko) && !isInstantiator) ? ko.getType() : Observables.getContextType(ko.getType()); } else if (refContext != null && !NS.isDirect(ko)) { if (!Observables .isCompatible(refContext, ctx, Observables.ACCEPT_REALM_DIFFERENCES)) { context.error("observable " + NS.getDisplayName(ko.getType()) + " has incompatible context (" + NS.getDisplayName(ctx) + ") with the overall model context (" + NS.getDisplayName(refContext) + ")", lineNumber(observable)); if (!NS.isCountable(dependency.getObservable())) { context.error("archetypes in learning processes must be subjects or events", dependency .getFirstLineNumber()); if (!NS.isObservable(type)) { if (type.getConceptSpace().equals(getNamespace().getId())) { if (observer != null && observer.getObservable() != null if (NS.isQuality(match)) {
if (NS.isTrait(existing, false)) { } else if (NS.isRole(existing)) { if (!NS.isQuality(main) && !NS.isTrait(main) && !NS.isConfiguration(main)) { context.error("inherent types ('of') can only be specified for qualities, traits and configurations", lineNumber(statement)); && !(NS.isDirect(inherentType) || NS.isConfiguration(inherentType))) { if (!((NS.isQuality(inherentType) || NS.isTrait(inherentType)) && NS.isRelativeQuality(main))) { context.error("the inherent type ('of') must be a subject, process, event, configuration or relationship" + (NS.isQuality(main) ? ": this relative quality can also name a compatible quality or trait" : ""), line); } else if (main != null && !NS.isThing(contextType)) { boolean ok = false; IModelObject mainobs = context if (mainobs instanceof IKnowledgeObject && ((IKnowledgeObject) mainobs).getConcept() != null && NS.isRole(((IKnowledgeObject) mainobs).getConcept())) { for (IConcept app : Observables .getApplicableObservables(contextType)) { if (NS.isThing(app)) { ok = true; break;
if (NS.isProcess(obs)) { if (last != null) { ret.add(last); } else if (NS.isQuality(obs) /* FIXME should not have traits */|| NS.isTrait(obs)) { if (last == null) { last = new ArrayList<>(); } else if (NS.isObject(obs) || NS.isRelationship(obs)) { if (last != null) { ret.add(last);
private IConcept getExpectedDirectContextualizer() { if (observables.size() < 1 || observables.get(0).getType() == null) { return null; } if (NS.isThing(getObservable())) { return isInstantiator ? KLAB.c(NS.SUBJECT_INSTANTIATOR) : KLAB.c(NS.SUBJECT_CONTEXTUALIZER); } else if (NS.isProcess(getObservable())) { return KLAB.c(NS.PROCESS_CONTEXTUALIZER); } else if (NS.isEvent(getObservable())) { return isInstantiator ? KLAB.c(NS.EVENT_INSTANTIATOR) : KLAB.c(NS.EVENT_CONTEXTUALIZER); } else if (isInstantiator && NS.isRelationship(getObservable())) { return KLAB.c(NS.RELATIONSHIP_INSTANTIATOR); } else if (NS.isFunctionalRelationship(getObservable())) { return KLAB.c(NS.FUNCTIONAL_RELATIONSHIP_CONTEXTUALIZER); } else if (NS.isStructuralRelationship(getObservable())) { return KLAB.c(NS.STRUCTURAL_RELATIONSHIP_CONTEXTUALIZER); } return null; }
private static IConcept getContextType(IKnowledge concept, boolean recurse) { if (!(concept instanceof IConcept)) { return null; } IConcept ret = null; if (recurse && (NS.isAttribute(concept) || NS.isRealm(concept) || NS.isClass(concept) || NS.isConfiguration(concept))) { IConcept described = getDescribedQuality((IConcept) concept); ret = described == null ? null : getContextType(described, false); } else if (recurse && (NS.isIdentity(concept) || NS.isProcess(concept))) { Collection<IConcept> described = getApplicableObservables(concept); ret = described.size() > 0 ? NS.getLeastGeneralCommonConcept(described) : null; } else { Collection<IConcept> cls = OWL .getRestrictedClasses((IConcept) concept, KLAB .p(NS.HAS_CONTEXT_PROPERTY)); ret = cls.isEmpty() ? null : cls.iterator().next(); } if (ret == null && NS.isObservable(concept)) { IConcept inherent = getInherentType(concept); if (inherent != null) { ret = getContextType(inherent, false); } } return ret; }
cov = (NS.isThing(observable) && context.isExplanatoryModel) ? Coverage.FULL(context.getScale()) : Coverage.EMPTY; && (NS.isQuality(observable) || NS.isTrait(observable))) { if (NS.isThing(observable) && (!context.isExplanatoryModel || ((ObservableSemantics) observable).isInstantiator())) { || (observable.getType().isAbstract() && NS.isCountable(observable) && context.isForInstantiation()); Map<IConcept, Pair<List<IModel>, ICoverage>> modelCache = new HashMap<>(); context.monitor.info("query for abstract " + NS.getDisplayName(observable.getType()) + " produced:", Messages.INFOCLASS_NETWORK); for (IConcept c : modelCache.keySet()) { Pair<List<IModel>, ICoverage> mdata = modelCache.get(c); context.monitor.info(" " + NS.getDisplayName(c) + " (" + mdata.getFirst().size() + " models, " + NumberFormat.getCurrencyInstance()
if (!NS.isCountable(ret)) { context.error(cid.getId() + " is not a countable concept: you cannot count this", lineNumber(cid)); if (!NS.isObject(ret)) { context.error(cid.getId() + " is not an object: you can only observe the distance to an object", lineNumber(cid)); if (!NS.isObject(ret)) { context.error(cid.getId() + " is not an object: you can only observe the presence of an object or process", lineNumber(cid)); if (!NS.isEvent(ret)) { context.error(cid.getId() + " is not an event: you can only observe the probability of an event", lineNumber(cid)); if (!(NS.isQuality(ret) || NS.isTrait(ret)) && !NS.isQuality(other)) { context.error(cid.getId() + " proportions are of qualities in qualities or traits in qualities", lineNumber(cid)); if (!(NS.isQuality(ret) || NS.isTrait(ret)) && !NS.isQuality(other)) { context.error(cid.getId() + " ratios are of qualities over qualities or traits over qualities", lineNumber(cid));
if (NS.isObservable(obb)) { IKnowledge c1 = NS.getCoreType(obb); IKnowledge c2 = NS.getCoreType(observer.getObservable()); if (NS.isTrait(obb) && !(observer instanceof IClassifyingObserver)) { context.error("inconsistent semantics: " + NS.getDisplayName(obb) + ": traits can only be observed through a classify statement", lineNumber(statement)); } else if (!(NS.isTrait(obb) && observer instanceof IClassifyingObserver) && !c1.equals(c2)) { context.error("wrong observables: cannot mix a " + c1 + " with a " if (NS.isClass(obb) && !(observer instanceof IClassifyingObserver)) { + NS.getDisplayName(obb) + " is a type and the observer is not a classification", lineNumber(statement)); + NS.getDisplayName(obb) + " is not an observable", lineNumber(statement)); && (NS.isQuality(getObservable()) || NS.isTrait(getObservable())) && observer == null) { context.error("quality models must have an observer", lineNumber(statement)); context.error("observable " + NS.getDisplayName(o.getType()) + " is not consistent. Please check semantics.", lineNumber(statement)); if (!NS.isClass(obs)) { context.error("the observed type for a model cannot be abstract: abstract types are only "
public ResolutionScope forObservable(IObservableSemantics observable) { ResolutionScope ret = new ResolutionScope(this, Type.OBSERVABLE, subject); ret.observable = observable; ret.attributes = mergeTraits(this.attributes, observable); ret.model = null; if (NS.isQuality(observable) || NS.isTrait(observable)) { // force explanation, which may be false from upstream context. ret.isExplanatoryModel = true; } // trace(ret); return ret; }
if (NS.isCountable(c.getFirst())) { obs.setInstantiator(true); if (NS.isDirect(getObservable())) { .getObservationTypeFor(c), fname), fname, null, isOptional, null, context); ret.add(ndep); .getSemanticDependencies(getObservable())) { IConcept dep = sd.getFirst(); String fname = CamelCase.toLowerCase(dep.getLocalName(), '-'); .getObservationTypeFor(dep), fname), fname, sd .getThird(), isOptional, null, context); ret.add(ndep);
IConcept base = NS.getBaseParentTrait(c); baseTraits.add(base); if (c.isAbstract()) { IConcept base = NS.getBaseParentTrait(t); + t.getDefinition(); tids.add(NS.getDisplayName(t)); if (!NS.isTrait(byTrait)) { throw new KlabValidationException("the concept in a 'by' clause must be a base abstract trait"); if (!NS.isBaseDeclaration(byTrait) || !byTrait.isAbstract()) { throw new KlabValidationException("traits used in a 'by' clause must be abstract and declared at root level"); if (!NS.isTrait(trait)) { throw new KlabValidationException("cannot use 'down to' on non-trait observables"); rids.add(NS.getDisplayName(role)); acceptedRoles.add(role);