private void reportPropertyTypes(DataObject data) throws Exception { ObjectType type = data.getObjectType(); Iterator keys = type.getProperties(); s_log.info("Properties for type: " + type.getName()); while (keys.hasNext()) { Property p = (Property) keys.next(); if (p.isAttribute()) { String msg = "Property " + p.getName() + " is attribute. Class is: " + p.getJavaClass(); if (type.isKeyProperty(p)) { msg += " is key property."; } msg += " value is: " + data.get(p.getName()); s_log.info(msg); } else { s_log.info( "Property " + p.getName() + " is component: " + p.isComponent() + " is collection: " + p.isCollection() + " is role: " + p.isRole()); s_log.info("ObjectType is is: " + p.getType().getName()); } } s_log.info("END Properties for type: " + type.getName()); }
private void setDefaultProperties(DataObject data, DataObject associatedObject) throws Exception { final ObjectType type = data.getObjectType(); s_log.info(""); s_log.info("Making new object for: " + type.getQualifiedName()); KeyGenerator.setKeyValues(data); ObjectType associated = (associatedObject == null) ? null : associatedObject.getObjectType(); for (Iterator it = type.getKeyProperties(); it.hasNext(); ) { Property prop = (Property) it.next(); if (prop.isAttribute()) { continue; } DataType propType = prop.getType(); if (propType.equals(associated)) { data.set(prop.getName(), associatedObject); } else { makeChild(prop, data); } } PropertyManipulator.NonKeyManipulator manip = new PropertyManipulator.NonKeyManipulator(type) { public void manipulate(Property p, DataObject dataInner) throws Exception { m_manipulator.setDefaultProperty(p, dataInner); } }; PropertyManipulator.manipulateProperties(data, manip); s_log.info("END new object."); s_log.info(""); s_log.info(""); }
public void testGetObjectType() { DataCollection allItems = getDefaultCollection(); int count = 0; while (allItems.next()) { ObjectType type = allItems.getObjectType(); s_log.info("Type: " + type.getQualifiedName()); assertEquals("Somehow failed to retrieve a Node?", "Node", type.getName()); count++; } assertTrue("No data objects?", count > 0); }
/** * Indicates if two OIDs have the same base type and contain the same values. Note that if values * are null this isn't an ideal distinction; it's best to check "arePropertiesNull" before relying * on this equals method (see DomainObject's equals method for an example). */ public boolean equals(Object obj) { if (obj instanceof OID) { OID oid = (OID) obj; // we rely on the toString ecause the HashMap.equals does not // give us what we need return m_type.getBasetype().equals(oid.m_type.getBasetype()) && m_values.equals(oid.m_values); } return false; }
public boolean isInitialized() { for (Iterator it = m_type.getKeyProperties(); it.hasNext(); ) { if (!m_values.containsKey(((Property) it.next()).getName())) { return false; } } return true; }
/** * Adds a property to the OID. Is used as part of the key for the Object ID. * * @param propertyName Name of the property * @param value The property */ public void set(String propertyName, Object value) { Property prop = m_type.getProperty(propertyName); // We do some type-checking here, to ensure that OIDs are being // created with legit types of values. if (prop == null) { throw new PersistenceException( "no such property: " + propertyName + " for type " + m_type.getName()); } // null has no type // if prop isn't an attribute, not sure what to do with it. if (prop.isAttribute() && value != null) { // we can be sure this is a simpletype because // isAttribute was true. SimpleType expectedType = (SimpleType) prop.getType(); if (!expectedType.getJavaClass().isAssignableFrom(value.getClass())) { throw new PersistenceException( "expected " + expectedType.getJavaClass() + "actual type " + value.getClass()); } } else if (value != null) { if (value instanceof DataObject) { ObjectType ot = (ObjectType) prop.getType(); DataObject dobj = (DataObject) value; ObjectType.verifySubtype(ot, dobj.getObjectType()); } else { throw new PersistenceException( "expected DataObject for property " + propertyName + " but got " + value.getClass()); } } if (hasProperty(propertyName)) { throw new PersistenceException(propertyName + " is already set to " + get(propertyName)); } m_values.put(propertyName, value); }
/** * Creates an OID with a single attribute for the key. To create a multi-valued OID, use a single * arg OID constructor, and add individual properties with the set method. This constructor should * be used when the object type being instantiated has a single primary key. For instance, if the * object type is <code>com.arsdigita.kernel.ACSObject</code> then the value should be the <code> * object_id</code>. So, if developers wanted to create the OID for ID zero, they would call * <code>new OID(acsObjectType, new BigDecimal(0))</code>. A <code>BigDecimal</code> is passed in * because the "id" attribute for the ACSObject type is declared as <code>BigDecimal</code> in the * PDL file. * * @param type The ObjectType of the ID * @param value The value of the ID * @exception PersistenceException will be thrown if the given object type does not have exactly a * single key (if <code>type.getObjectMap().getObjectKey().getCount() * != 1</code>). * @pre type != null * @pre type.getObjectMap().getObjectKey().getCount() == 1 */ public OID(ObjectType type, Object value) { this(type); Iterator it = type.getKeyProperties(); if (!it.hasNext()) { throw new PersistenceException("Empty object key: " + type); } Property prop = (Property) it.next(); if (it.hasNext()) { throw new PersistenceException("This object type has a compound key."); } String attr = prop.getName(); set(attr, value); }
public static final com.redhat.persistence.metadata.ObjectType type(Root root, ObjectType type) { return type(root, type.getQualifiedName()); }
/** * Simple hashcode method to calculate hashcode based on the information used in the equals * method. Needed because we overrode equals; two equivalent objects must hash to the same value. */ public int hashCode() { // here we rely on the values collection's hashcode method // to base its hashcode on the hashcodes of the contained values. return (m_type.getBasetype().hashCode() + m_values.hashCode()); }
/** Serializes the OID. */ public String toString() { String fullType = m_type.getQualifiedName(); Object[] args = {fullType, getProperties().toString()}; return m_format.format(args); }
void specialize(ObjectType subtype) { ObjectType.verifySubtype(m_type, subtype); m_type = subtype; }
private static boolean isNonKeyAttribute(Property p, ObjectType type) { return p.isAttribute() && !type.isKeyProperty(p); }
private void checkUpdates(DataObject data, final DataObject parent) throws Exception { final ObjectType type = data.getObjectType(); try { PropertyManipulator.NonKeyManipulator manip = new PropertyManipulator.NonKeyManipulator(type) { public void manipulate(Property p, DataObject dataInner) throws Exception { m_manipulator.updateAllPropertyCombinations(p, dataInner); } }; PropertyManipulator.manipulateProperties(data, manip); PropertyManipulator.PredicateManipulator childManip = new PropertyManipulator.ComponentManipulator() { public void manipulate(Property p, DataObject dataInner) throws Exception { if (p.isCollection()) { DataAssociation children = (DataAssociation) dataInner.get(p.getName()); DataAssociationCursor cursor = children.cursor(); while (cursor.next()) { DataObject child = cursor.getDataObject(); s_log.debug("checkUpdates on child: " + child.getObjectType().getQualifiedName()); checkUpdates(child, dataInner); } } else { DataObject child = (DataObject) dataInner.get(p.getName()); s_log.debug("checkUpdates on child: " + child.getObjectType().getQualifiedName()); checkUpdates(child, dataInner); } } }; PropertyManipulator.manipulateProperties(data, childManip); PropertyManipulator.AssociationManipulator assocManip = new PropertyManipulator.AssociationManipulator() { public void manipulate(Property p, DataObject dataInner) throws Exception { if (p.isCollection()) { DataAssociation associations = (DataAssociation) dataInner.get(p.getName()); DataAssociationCursor cursor = associations.cursor(); while (cursor.next()) { DataObject assoc = cursor.getDataObject(); if (!assoc.equals(parent)) { s_log.debug( "checkUpdates on assoc: " + assoc.getObjectType().getQualifiedName()); checkUpdates(assoc, dataInner); } } } else { DataObject assoc = (DataObject) dataInner.get(p.getName()); if (null != assoc && !assoc.equals(parent)) { s_log.debug("checkUpdates on assoc: " + assoc.getObjectType().getQualifiedName()); checkUpdates(assoc, dataInner); } } } }; PropertyManipulator.manipulateProperties(data, assocManip); } catch (UndefinedEventException e) { s_log.info( "Update event undefined for type: " + type.getQualifiedName() + " Update tests cannot be performed."); s_log.info("UndefinedEventException: " + e.getMessage()); } }