private static void findAtLevel(IModelObject mo, List<IConcept> ret, int level, int current, boolean filterAbstract) { IConcept k = KLAB.c(mo.getName()); if (!filterAbstract || !k.isAbstract()) { ret.add(k); } if (level < 0 || level < current) { for (IModelObject o : mo.getChildren()) { if (o instanceof IKnowledgeObject) { findAtLevel(o, ret, level, current + 1, filterAbstract); } } } }
private static int findLevel(IModelObject mo, String key, int level) { if (mo == null || mo.getName() == null) { return -1; } if (mo.getName().equals(key) || mo.getId().equalsIgnoreCase(key)) { return level; } for (IModelObject o : mo.getChildren()) { if (o instanceof IKnowledgeObject) { int l = findLevel(o, key, level + 1); if (l > 0) { return l; } } } return -1; }
/** * If current is a child of base at passed level, return it; otherwise return the * parent at the passed level, or null if the concept is unrelated or higher than * level. Uses the model object (stated) hierarchy. * * @param base * @param current * @param level * @return parent at level */ public static IConcept getParentAtLevel(IConcept base, IConcept current, int level) { IConcept ret = null; if (current.is(base)) { int l = getDetailLevel(base, current); if (l == level) { return current; } if (l > level) { for (IConcept c : getChildrenAtLevel(base, level)) { if (current.is(c)) { return c; } } } } return 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; }
.getExposedTraits(knowledge)); if (exposedTraits.isEmpty()) { context.error("no traits to adopt have been declared in parent class (using an 'exposes' statement)", lineNumber(statement IConcept thr = null; for (IConcept o : exposedTraits) { if (Types.isExposedAs(t, o)) { nMatch++; thr = o; Types.setExposedTraits(knowledge, adoptedTraits); } else if (exposedTraits != null) { Types.setExposedTraits(knowledge, exposedTraits);
/** * Get the level of detail of current in the DECLARED hierarchy of base - i.e. using * the model objects declared in k.IM. Only works with trait and class types, as this * is only relevant to classifications. * * @param base * @param current * @return detail level of current within base */ public static int getDetailLevel(IConcept base, IConcept current) { return getDetailLevel(base, current.toString()); }
@Override public IConcept getObservedType(KIMScope context, IConcept concept) { try { return Types.getClassificationType(concept); } catch (KlabValidationException e) { context.error(e.getMessage(), this.getFirstLineNumber()); } return concept; }
.getExposedTraits(model.getObservable().getType()); IConcept context = Observables .getContextType(model.getObservable().getType());
public KIMClassificationObserver(KIMScope context, KIMModel model, Observer statement) { super(context, model, statement); isDiscretization = statement.isDiscretizer(); metadataProperty = statement.getMetadataProperty(); authority = statement.getAuthority(); if (observable != null) { // ((ObservableSemantics) observable) // .setType(this.getObservedType(context, this.observable.getType())); if (metadataProperty != null) { try { classification = Types .createClassificationFromMetadata(getObservable() .getType(), metadataProperty); } catch (KlabValidationException e) { context.error(e.getMessage(), lineNumber(statement)); } } else if (statement.getClassification() != null) { classification = new KIMClassification(context .get(KIMScope.Type.CLASSIFICATION), statement .getClassification(), this.observable); } } if (observable != null && NS.isObject(observable.getType())) { context.error("cannot classify an object unless it's 'by' a trait", getFirstLineNumber()); } validate(context); }
if (Types.isDelegate(concept)) { concept = Types.getExposedTraits(concept).iterator().next();
.getChildrenAtLevel(trait, Types.getDetailLevel(trait, downTo))); cId += "DownTo" + cleanInternalId(downTo.getLocalName());
/** * Return a (flat) list of all CONCRETE children up to the passed level of detail, * using the model object (stated) hierarchy and keeping the order of declaration * (depth- first if more levels are involved). * * @param baseType * @param level * @return concrete children at level */ public static List<IConcept> getConcreteChildrenAtLevel(IConcept baseType, int level) { List<IConcept> ret = new ArrayList<>(); INamespace ns = KLAB.MMANAGER.getNamespace(baseType.getConceptSpace()); if (ns == null) { return ret; } IModelObject mo = ns.getModelObject(baseType.getLocalName()); if (mo == null) { return ret; } findAtLevel(mo, ret, level, 0, true); return ret; }
/** * Get the level of detail corresponding to the passed key in the DECLARED hierarchy * of baseType - i.e. using the model objects declared in k.IM. Key can be the concept * fully qualified name or its ID alone, matched case-insensitive. Semantics alone * does not suffice: the concepts must be arranged in a declaration hierarchy for the * levels to be attributed. Also only works with trait and class types, as this is * only relevant to classifications. * * @param baseType * @param key * @return detail level */ public static int getDetailLevel(IKnowledge baseType, String key) { /* * go through children using the model object hierarchy. Will only find the ones * declared in a hierarchy. */ INamespace ns = KLAB.MMANAGER.getNamespace(baseType.getConceptSpace()); if (ns == null) { return -1; } IModelObject mo = ns.getModelObject(baseType.getLocalName()); if (mo == null) { return -1; } return findLevel(mo, key, 0); }
/** * Return a (flat) list of all children up to the passed level of detail, using the * model object (stated) hierarchy and keeping the order of declaration (depth- first * if more levels are involved). Allows abstract concepts in the result - if only * concrete ones are desires, use {@link #getConcreteChildrenAtLevel} instead. * * @param baseType * @param level * @return all children at level */ public static List<IConcept> getChildrenAtLevel(IConcept baseType, int level) { List<IConcept> ret = new ArrayList<>(); INamespace ns = KLAB.MMANAGER.getNamespace(baseType.getConceptSpace()); if (ns == null) { return ret; } IModelObject mo = ns.getModelObject(baseType.getLocalName()); if (mo == null) { return ret; } findAtLevel(mo, ret, level, 0, false); return ret; }