/** * Return all concepts that the passed concept is and are observables. * * @param subject * @return closure */ public static Set<IKnowledge> getObservableClosure(IKnowledge subject) { Set<IKnowledge> ret = new HashSet<>(); ret.add(subject); if (subject instanceof IConcept) { for (IConcept c : ((IConcept) subject).getAllParents()) { if (isObservable(c)) { ret.add(c); } } } else if (subject instanceof IProperty) { for (IProperty c : ((IProperty) subject).getAllParents()) { if (isObservable(c)) { ret.add(c); } } } return ret; }
@Override public boolean select(IKnowledge o) { return o.is(KLAB.c(NS.CORE_REALM_TRAIT)) && !NS.isObservable(o); } };
@Override public boolean select(IKnowledge o) { return o.is(KLAB.c(NS.CORE_IDENTITY_TRAIT)) && !NS.isObservable(o); } };
@Override public boolean select(IKnowledge o) { return o.is(KLAB.c(NS.ATTRIBUTE_TRAIT)) && !NS.isObservable(o); } };
private IConcept getConcept(IAnnotation declaration) throws KlabException { String cdef = declaration.getParameters().get("for").toString(); String[] cdefs = cdef.split("\\s+"); if (cdefs.length == 1) { return KLAB.c(cdefs[0]); } IConcept main = null; List<IConcept> traits = new ArrayList<>(); for (String s : cdefs) { IConcept cc = KLAB.c(s); if (NS.isObservable(cc)) { main = cc; } else { traits.add(cc); } } return Observables.declareObservable(main, traits); }
@Override public List<IObservableSemantics> getAlternativeObservables() { IConcept c = Observables.getInherentType(getObservable().getType()); if (c != null && NS.isObservable(c)) { return Collections.singletonList(new ObservableSemantics(c)); } return null; }
@Override public String validateCoreConcept(IKnowledge knowledge, String id) { /* * if an API and enough structure exists, this should check alignment with processes, subjects or * traits. */ if (!knowledge.is(KLAB.c(NS.CORE_IDENTITY_TRAIT)) && !NS.isObservable(knowledge)) { return "Concepts identified by the " + getAuthorityId() + " authority must be identities or observables"; } return null; }
/** * 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; }
if (k instanceof Concept) { for (Pair<IConcept, IProperty> cp : ((Concept) k).getObjectRestrictions()) { if (isObservable(cp.getFirst()) && !cp.getFirst().isAbstract()) { cc.put(cp.getFirst(), cp.getSecond());
if (NS.isObservable(concept)) { String traitID = concept.getLocalName() + "Observability"; ret = concept.getOntology().getConcept(traitID);
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; }
if (NS.isTrait(existing, false) && !NS.isObservable(existing)) { traits.add(existing); } else {
boolean acceptRealmDifferences = (flags & ACCEPT_REALM_DIFFERENCES) != 0; if ((!NS.isObservable(o1) || !NS.isObservable(o2)) && !(NS.isConfiguration(o1) && NS.isConfiguration(o2))) { return false;
/** * Return the most specific core observable that subsumes this object (e.g. * event, subject, length, trait etc) or null if it's not an observable or * trait. If the concept is a trait and not an observable, the core trait * type will be returned. Otherwise the core observable is returned (even if * it has traits). If this is not a core particular this will return null. * * @param observable * @return core type */ public static IKnowledge getCoreType(ISemantic observable) { String toCheck = isObservable(observable) ? CORE_OBSERVABLE : CORE_UNIVERSAL; IKnowledge k = observable.getType(); if (k.is(KLAB.p(STRUCTURING_PROPERTY))) { return k; } if (k.is(KLAB.c(toCheck))) { for (IConcept c : getLeastGeneral(((IConcept) k).getAllParents())) { if (c.is(KLAB.c(toCheck))) { return getLeastGeneralFrom(c, CORE_ONTOLOGY, KLAB.c(toCheck)); } } } return null; }
report.writeln(filler + "* core type: " + coreType); boolean isObservable = NS.isObservable(k); boolean isUniversal = NS.isUniversal(k);
IConcept type = observables.get(0).getType(); if (!NS.isObservable(type)) { if (type.getConceptSpace().equals(getNamespace().getId())) { if (observer != null && observer.getObservable() != null
if (NS.isObservable(obb)) {
if (NS.isObservable(t)) { if (!NS.isTrait(trait, false) || NS.isObservable(trait)) { context.error("only traits are allowed in an 'observing' list", lineNumber(statement .getActuallyInheritedTraits())); if (!NS.isRole(trait) || NS.isObservable(trait)) { context.error(trait + " is not a role", lineNumber(statement.getRoles()));