/** * Appends column value with parametrised builder object. Returns true if * value is present. * * @param builder * the builder * @param valueObj * the value obj * @param column * the column * @return true if value is not null,else false. */ private boolean appendColumnValue(StringBuilder builder, Object valueObj, Field column) { Object value = PropertyAccessorHelper.getObject(valueObj, column); boolean isPresent = false; isPresent = appendValue(builder, column.getType(), value, isPresent, false); return isPresent; }
/** * Sets the field value. * * @param entity * the entity * @param member * the member * @param retVal * the ret val */ private static void setFieldValue(Object entity, Field member, Object retVal) { if (member != null && retVal != null && entity != null) { PropertyAccessorHelper.set(entity, member, retVal); } }
@Override public Object getIdentifier(Object entity) { Class<?> entityClass = entity.getClass(); // EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClass); // // if (entityMetadata == null) // { // throw new IllegalArgumentException(entityClass + " is not an entity"); // } return PropertyAccessorHelper.getId(entity, /*entityMetadata*/null); }
/** * Gets the translated object. * * @param value * the value * @param sourceClass * the source class * @param targetClass * the target class * @return the translated object */ public static Object getTranslatedObject(Object value, Class<?> sourceClass, Class<?> targetClass) { if (sourceClass.isAssignableFrom(Date.class)) { value = PropertyAccessorHelper.fromDate(targetClass, sourceClass, value); } else { value = PropertyAccessorHelper.fromSourceToTargetClass(targetClass, sourceClass, value); } return value; }
private static void setId(Object entity, Object value, EntityMetadata m) { value = PropertyAccessorHelper.fromSourceToTargetClass(m.getIdAttribute().getJavaType(), value.getClass(), value); PropertyAccessorHelper.setId(entity, m, value); } }
private static void setFieldValue(Object entity, Object value, Attribute column) { value = PropertyAccessorHelper.fromSourceToTargetClass(column.getJavaType(), value.getClass(), value); PropertyAccessorHelper.set(entity, (Field) column.getJavaMember(), value); }
/** * After successfully parsing set relational entity object within entity * object. * * @param entity * @param relationEntity * @param relation */ private void setRelationToEntity(Object entity, Object relationEntity, Relation relation) { if (relation.getTargetEntity().isAssignableFrom(getEntity(relationEntity).getClass())) { if (relation.isUnary()) { PropertyAccessorHelper.set(entity, relation.getProperty(), getEntity(relationEntity)); } else { Object associationObject = PropertyAccessorHelper.getObject(entity, relation.getProperty()); if (associationObject == null || ProxyHelper.isProxyOrCollection(associationObject)) { associationObject = PropertyAccessorHelper.getCollectionInstance(relation.getProperty()); PropertyAccessorHelper.set(entity, relation.getProperty(), associationObject); } ((Collection) associationObject).add(getEntity(relationEntity)); } } }
rowKey = MongoDBUtils.populateValue(rowKey, idClass); rowKey = MongoDBUtils.getTranslatedObject(rowKey, rowKeyValueClass, idClass); PropertyAccessorHelper.setId(entity, m, rowKey); EntityType entityType = metaModel.entity(entityClazz); try PropertyAccessorHelper.set(entity, (Field) column.getJavaMember(), ByteStreams.toByteArray(is));
/** * Gets the _ id. * * @param field * the field * @param embeddedObject * the embedded object * @param embeddableType * the embeddable type * @param _id * the _id * @return the _ id */ static String get_Id(Field field, Object embeddedObject, EmbeddableType embeddableType, String _id) { Field[] fields = field.getType().getDeclaredFields(); for (Field columnField : fields) { if (!ReflectUtils.isTransientOrStatic(columnField) && !embeddableType.getAttribute(columnField.getName()).isAssociation()) { Object valueObject = PropertyAccessorHelper.getObject(embeddedObject, columnField); _id = _id + PropertyAccessorHelper.getString(valueObject); } } return _id; } }
Object obj = PropertyAccessorHelper.getObject(value, field); compositeKey.append(PropertyAccessorHelper.fromSourceToTargetClass(String.class, attrib.getBindableJavaType(), obj)).append(HBaseUtils.COMP_KEY_DELIM);
/** * Check and set if relation is set via primary key. * * @param relation * relation * @param childObject * target entity * @param childMetadata * target entity metadata * @param entityId * entity id * @return target entity. */ private Object onIfSharedByPK(Relation relation, Object childObject, EntityMetadata childMetadata, Object entityId) { if (relation.isJoinedByPrimaryKey()) { PropertyAccessorHelper.setId(childObject, childMetadata, entityId); } return childObject; }
void setMax(String field, Object fieldValue) { this.max = new HashMap<String, Double>(1); this.max.put( field, !StringUtils.isNumeric(fieldValue.toString()) ? Double.valueOf(PropertyAccessorHelper.getString( fieldValue).hashCode()) : Double.valueOf(fieldValue.toString())); }
/** * Converts a given field value to an object that is Neo4J compatible * * @param source * @return */ public Object toNeo4JProperty(Object source) { if (source instanceof BigDecimal || source instanceof BigInteger) { return source.toString(); } else if ((source instanceof Calendar) || (source instanceof GregorianCalendar)) { return PropertyAccessorHelper.fromSourceToTargetClass(String.class, Date.class, ((Calendar) source).getTime()); } if (source instanceof Date) { Class<?> sourceClass = source.getClass(); return PropertyAccessorHelper.fromSourceToTargetClass(String.class, sourceClass, source); } return source; }
List<byte[]> getColumns() { if (columns != null && columns.length > 0) { // byte[] fields = new byte[columns.length][1]; List<byte[]> fields = new ArrayList<byte[]>(columns.length); for (int i = 0; i < columns.length; i++) { if (columns[i] != null /* && columns[i].indexOf(".") >= 0 */) { byte[] f = PropertyAccessorHelper.getBytes(columns[i]); fields.add(f); } } return fields.isEmpty() ? null : fields; } return null; }
@Override public void index(Class entityClazz, EntityMetadata m, Map<String, Object> values, Object entityId, final Class parentClazz) { String idColumnName = ((AbstractAttribute) m.getIdAttribute()).getJPAColumnName(); Object id = values.get(idColumnName); for (String column : values.keySet()) { Object valueObject = values.get(column); List<String> majorKeyComponents = new ArrayList<String>(); majorKeyComponents.add(getIndexTableName(m)); majorKeyComponents.add(column); majorKeyComponents.add(PropertyAccessorHelper.getString(valueObject)); String minorKey = PropertyAccessorHelper.getString(id); Key key = Key.createKey(majorKeyComponents, minorKey); byte[] valueByteArray = PropertyAccessorHelper.getBytes(id); kvStore.put(key, Value.createValue(valueByteArray)); } }
byte[] value = PropertyAccessorHelper.get(embeddedObject, (Field) attrib.getJavaMember()); byte[] name; if (value != null) String valueAsStr = PropertyAccessorHelper.getString(embeddedObject, (Field) attrib.getJavaMember()); wrapper.addIndex( getHashKey(entityMetadata.getTableName(), ((AbstractAttribute) attrib).getJPAColumnName()),
Object generatedId = PropertyAccessorHelper.fromSourceToTargetClass(m.getIdAttribute().getJavaType(), Integer.class, new Integer(hashCode)); PropertyAccessorHelper.setId(e, m, generatedId); return generatedId;
/** * Sets the field value. * * @param entity * the entity * @param column * the column * @param value * the value */ private static void setFieldValue(Object entity, Attribute column, JsonElement value) { if (column.getJavaType().isAssignableFrom(byte[].class)) { PropertyAccessorHelper.set(entity, (Field) column.getJavaMember(), PropertyAccessorFactory.STRING.toBytes(value.getAsString())); } else { PropertyAccessorHelper.set( entity, (Field) column.getJavaMember(), PropertyAccessorHelper.fromSourceToTargetClass(column.getJavaType(), String.class, value.getAsString())); } }
/** * Initialize entity. * * @param key * the key * @param entityMetadata * the entity metadata * @return the object * @throws InstantiationException * the instantiation exception * @throws IllegalAccessException * the illegal access exception */ private Object initializeEntity(Object key, EntityMetadata entityMetadata) throws InstantiationException, IllegalAccessException { Object entity = null; entity = entityMetadata.getEntityClazz().newInstance(); if (key != null) { PropertyAccessorHelper.setId(entity, entityMetadata, key); } return entity; }