/** * INTERNAL: Grabs the topic which is the type of the given typedIF * * @param typed the given object; internally typecast to TypedIF * @return object which is the type; an object implementing TopicIF */ @Override public TopicIF grab(T typed) { return typed.getType(); }
public void setType(TypedIF typed, Topic type) { if (type == null) { return; } TopicIF resolved = topic.resolve(typed.getTopicMap(), type); if (!typed.getType().equals(resolved)) { typed.setType(resolved); } } }
public void testType() { assertTrue("type null initially", typed.getType() != null); TopicIF type = builder.makeTopic(); typed.setType(type); assertTrue("type identity not retained", typed.getType().equals(type)); try { typed.setType(null); fail("type could be set to null"); } catch (NullPointerException e) { } }
private static <T extends TypedIF> void replaceTopicType(Collection<T> objects, TopicIF t1) { Iterator<T> it = objects.iterator(); while (it.hasNext()) { T object = it.next(); object.setType(t1); } }
public void perform(ActionParametersIF params, ActionResponseIF response) { //test params ActionSignature paramsType = ActionSignature.getSignature("x"); paramsType.validateArguments(params, this); TypedIF typed = (TypedIF) params.get(0); typed.setType(null); }
/** * INTERNAL: Compares the given typedIF objects using the * comparator given to the constructor * * @param obj1 an object; typecast to TypedIF by the grabber * @param obj2 an object; typecast to TypedIF by the grabber * @return int; result from the comparator given to the constructor, when it compares the * types of the given objects */ @Override public int compare(TypedIF obj1, TypedIF obj2) { //! return subcomparator.compare(grabber.grab(obj1), grabber.grab(obj2)); return subcomparator.compare(obj1.getType(), obj2.getType()); }
public void testType() { if (typed instanceof TopicNameIF) { TopicMapIF tm = typed.getTopicMap(); TopicIF defaultNameType = tm.getTopicBySubjectIdentifier(PSI .getSAMNameType()); assertTrue("type not equal to the default name type initially", typed .getType().equals(defaultNameType)); } else { assertTrue("type null initially", typed.getType() != null); } TopicIF type = builder.makeTopic(); typed.setType(type); assertTrue("type identity not retained", typed.getType().equals(type)); if (typed instanceof TopicNameIF) { typed.setType(null); TopicMapIF tm = typed.getTopicMap(); TopicIF defaultNameType = tm.getTopicBySubjectIdentifier(PSI .getSAMNameType()); assertTrue("type is not equal to the default name type when set to null", typed.getType().equals(defaultNameType)); } else { try { typed.setType(null); fail("type could be set to null"); } catch (NullPointerException e) { } assertTrue("type identity not retained", typed.getType().equals(type)); } }
public void perform(ActionParametersIF params, ActionResponseIF response) { //test params ActionSignature paramsType = ActionSignature.getSignature("x"); paramsType.validateArguments(params, this); TypedIF typed = (TypedIF) params.get(0); TopicIF type = (TopicIF) params.getTMObjectValue(); typed.setType(type); }
@Override public boolean ok(Object object) { if (object instanceof TypedIF) { TypedIF typed = (TypedIF) object; return oktypes.contains(typed.getType()); } return false; } }
protected boolean isInstanceOf(TypedIF object, Collection types) { if (types == null) return true; return types.contains(object.getType()); }
/** * INTERNAL: Returns true if the TypedIF object is an instance the * given type. */ public static boolean isInstanceOf(TypedIF typed, TopicIF type) { return (type != null && type.equals(typed.getType())); }
@Override public boolean evaluate(TypedIF typed) { return Objects.equals(typed.getType(), type); } }
/** * INTERNAL: Returns the topic which types the singly typed object * <code>typed</code> and all of its supertypes. * * @param typed a typedIF object * @return a collection of topicIF objects; the type and all * supertypes of the given typedIF object. */ public Collection<TopicIF> getSupertypes(TypedIF typed) { if (typed.getType() == null) return new ArrayList<TopicIF>(); return supertypesWalker.walkTopics(typed.getType()); }
private void writeType(TypedIF obj, ContentHandler dh) throws SAXException { if (obj.getType() == null || ((obj instanceof TopicNameIF) && isDefaultNameType(obj.getType()))) return; dh.startElement(EMPTY_NAMESPACE, EMPTY_LOCALNAME, "type", EMPTY_ATTR_LIST); writeTopicRef(obj.getType(), dh); dh.endElement(EMPTY_NAMESPACE, EMPTY_LOCALNAME, "type"); }
@Override public void processEvent(Object object, String event, T new_value, T removed) { // Unregister type objects.remove(removed.getType(), removed); } }
@Override public void processEvent(Object object, String event, T added, T old_value) { // Register type objects.add(added.getType(), added); } }
/** * INTERNAL: Finds first characteristic of a specified type. * * @param objects A collection of TypedIF objects. * @return The first object that has the specified type. * * @since 2.0 */ public static <T extends TypedIF> T getByType(Collection<T> objects, TopicIF type) { Iterator<T> it = objects.iterator(); while (it.hasNext()) { T typed = it.next(); if (type.equals(typed.getType())) return typed; } return null; }
@Override public boolean ok(Object object) { if (object instanceof TypedIF) { TopicIF type = ((TypedIF) object).getType(); if (type == null) return false; Iterator it = type.getSubjectIdentifiers().iterator(); while (it.hasNext()) if (okpsis.contains(it.next())) return true; } return false; } }
protected static String makeTypedKey(TypedIF typed) { return typed.getType().getObjectId(); }