@Override protected JsonSerializer initialValue() { return new JsonSerializerFactory().addFilter((parent, fieldAccess) -> !fieldAccess.name().equals("metaClass")).create(); } };
private void addClass(final ClassMeta<?> classMeta) { try { if (definitionMap.containsKey(classMeta.name())) { return; } definitionMap.put(classMeta.name(), null); final DefinitionBuilder definitionBuilder = new DefinitionBuilder(); final String description = getDescription(classMeta); definitionBuilder.setDescription(description); final Map<String, FieldAccess> fieldAccessMap = classMeta.fieldMap(); fieldAccessMap.entrySet().forEach(fieldAccessEntry -> { final FieldAccess fieldAccess = fieldAccessEntry.getValue(); if (fieldAccess.ignore() || fieldAccess.isStatic()) { return; } definitionBuilder.addProperty(fieldAccess.name(), convertFieldToSchema(fieldAccess)); }); final Definition definition = definitionBuilder.build(); definitionMap.put(classMeta.name(), definition); } catch (Exception ex) { logger.warn("Unable to add class " + classMeta.longName(), ex); } }
private Schema convertFieldToSchema(final FieldAccess fieldAccess) { try { final Class<?> type = fieldAccess.type(); final Schema schema = mappings.get(type); final String description = getDescription(fieldAccess); if (schema != null) { if (description == null) { return schema; } else { return Schema.schemaWithDescription(schema, description); } } return convertFieldToComplexSchema(fieldAccess); } catch (Exception ex) { logger.warn("unable to convert field " + fieldAccess.name() + " from " + fieldAccess.declaringParent(), ex); return Schema.schemaWithFormat("error", "error.see.logs"); } }
final String fieldName = fieldAccess.alias(); TypeType typeEnum = fieldAccess.typeEnum(); if ( useAnnotations && fieldAccess.ignore() ) { return false; if ( useAnnotations && view != null && !fieldAccess.isViewActive(view) ) { return false; final boolean include = (useAnnotations && fieldAccess.include()); final CustomFieldSerializer customFieldSerializer = customFieldSerializerMap.get ( fieldAccess.name() ); if ( customFieldSerializer.serializeField (serializer, parent, fieldAccess, builder) ) { return true; int value = fieldAccess.getInt ( parent ); if (includeDefault || include || value !=0) { serializeFieldName ( fieldName, builder ); boolean bvalue = fieldAccess.getBoolean ( parent ); if (includeDefault || include || bvalue ) { serializeFieldName ( fieldName, builder ); byte byvalue = fieldAccess.getByte ( parent ); if (includeDefault || include || byvalue != 0 ) { serializeFieldName ( fieldName, builder ); long lvalue = fieldAccess.getLong ( parent ); if ( includeDefault || include || lvalue != 0 ) {
final String fieldName = fieldAccess.name(); final TypeType typeEnum = fieldAccess.typeEnum (); if (!fieldAccess.isViewActive( view ) ) { return false; int value = fieldAccess.getInt ( parent ); if (value !=0) { serializeFieldName ( fieldName, builder ); boolean bvalue = fieldAccess.getBoolean ( parent ); if ( bvalue ) { serializeFieldName ( fieldName, builder ); byte byvalue = fieldAccess.getByte ( parent ); if ( byvalue != 0 ) { serializeFieldName ( fieldName, builder ); long lvalue = fieldAccess.getLong ( parent ); if ( lvalue != 0 ) { serializeFieldName ( fieldName, builder ); double dvalue = fieldAccess.getDouble ( parent ); if ( dvalue != 0 ) { serializeFieldName ( fieldName, builder ); float fvalue = fieldAccess.getFloat ( parent ); if ( fvalue != 0 ) { serializeFieldName ( fieldName, builder );
final String fieldName = fieldAccess.name(); final TypeType typeEnum = fieldAccess.typeEnum (); switch ( typeEnum ) { case INT: int value = fieldAccess.getInt ( parent ); if (value !=0) { serializeFieldName ( fieldName, builder ); boolean bvalue = fieldAccess.getBoolean ( parent ); if ( bvalue ) { serializeFieldName ( fieldName, builder ); byte byvalue = fieldAccess.getByte ( parent ); if ( byvalue != 0 ) { serializeFieldName ( fieldName, builder ); long lvalue = fieldAccess.getLong ( parent ); if ( lvalue != 0 ) { serializeFieldName ( fieldName, builder ); double dvalue = fieldAccess.getDouble ( parent ); if ( dvalue != 0 ) { serializeFieldName ( fieldName, builder ); float fvalue = fieldAccess.getFloat ( parent ); if ( fvalue != 0 ) { serializeFieldName ( fieldName, builder ); short svalue = fieldAccess.getShort( parent );
String fieldName = access.name(); if (access.isStatic()) { continue; Object value = access.getValue(object); switch (access.typeEnum()) { case BYTE: case BYTE_WRAPPER: case ARRAY_STRING: case ARRAY_OBJECT: if (Typ.isBasicType( access.getComponentClass() )) { map.put(fieldName, value); } else { case SET: Collection<?> collection = ( Collection<?> ) value; Class<?> componentType = access.getComponentClass(); if ( Typ.isBasicType( componentType ) ) { map.put(fieldName, value);
private static void copySrcFieldToDestField( Object src, Object dst, FieldAccess dstField, FieldAccess srcField, Set<String> ignore ) { if ( srcField.isStatic() ) { return ; if ( srcField.isPrimitive() ) { dstField.setValue( dst, srcField.getValue( src ) ); return ; Object srcValue = srcField.getObject( src ); if ( !dstField.isPrimitive () ) { dstField.setObject(dst, null); if ( Typ.isBasicType( srcField.type() ) ) { Object value = srcField.getObject( src ); dstField.setValue( dst, value ); return ; if ( !(srcValue instanceof Collection ) && dstField.type() == srcValue.getClass() || Typ.isSuperType ( dstField.type(), srcValue.getClass () ) ) { dstField.setObject(dst, copy( srcField.getObject ( src ) )); return ; if ( srcValue instanceof Collection && dstField.getComponentClass() != null && Typ.isCollection ( dstField.type() ) ) { if (dstField.typeEnum () == TypeType.ABSTRACT || dstField.typeEnum () == TypeType.INTERFACE) {
field.setObject(newInstance, null); return; if(field.typeEnum() == INSTANCE) { field.setObject(newInstance, fromList((List) acollectionOfValues, field.type())); return; Class<?> componentClass = field.getComponentClass(); switch (field.typeEnum() ) { Collection<Object> newCollection = Conversions.createCollection( field.type(), collectionOfValues.size() ); field.setObject( newInstance, newCollection ); break; case ARRAY_STRING: case ARRAY_OBJECT: TypeType componentType = field.componentType(); int index = 0; field.setObject( newInstance, iarray); return; case SHORT: field.setObject( newInstance, sarray); return; case DOUBLE:
if ( field.ignore() ) { continue; value = ( ( Value ) value ).toValue(); } else { field.setFromValue( toObject, ( Value ) value ); continue; field.setObject( toObject, null ); continue; if ( value.getClass() == field.type() || field.type() == Object.class) { field.setValue(toObject, value); } else if ( Typ.isBasicType(value) ) { field.setValue(toObject, value); field.setValue( toObject, value );
ValueContainer.toObject(value); Class<?> clazz = field.type(); switch (field.typeEnum()) { field.setValue(newInstance, objValue); field.setValue(newInstance, null); break; Class keyType = (Class)field.getParameterizedType().getActualTypeArguments()[0]; Class valueType = (Class)field.getParameterizedType().getActualTypeArguments()[1]; field.setValue(newInstance, objValue); field.setFromValue(newInstance, value);
final FieldAccess field, final Collection<?> collection ) { final Class<?> fieldComponentClass = field.getComponentClass(); if (Typ.implementsInterface( collection.getClass(), field.type() )) { field.setValue(newInstance, collection); if (!field.typeEnum().isCollection()) { if (collection instanceof List) { try { Object value = fromList( (List) collection, field.getComponentClass()); field.setValue(newInstance, value); } catch (Exception ex) { field.setValue(newInstance, collection); field.setValue(newInstance, collection); Collection<Object> newCollection = Conversions.createCollection( field.type(), collection.size() ); field.setValue( newInstance, newCollection ); return; field.setValue(newInstance, newCollection);
try { if ( objectValue instanceof Map ) { Class<?> clazz = field.type(); if ( !clazz.isInterface() && !Typ.isAbstract( clazz ) ) { objectValue = fromValueMap( ( Map<String, Value> ) objectValue, field.type() ); } else { String className = (( Map<String, Value> ) objectValue) field.setValue(newInstance, objectValue); } else if ( objectValue instanceof Collection ) { handleCollectionOfValues( newInstance, field, ( Collection<Value> ) objectValue ); } else { field.setValue( newInstance, objectValue ); Exceptions.handle(Str.sputs("Problem handling non value case of fromValueMap", "field", field.name(), "fieldType", field.type().getName(), "object from map", objectValue), ex);
@Override public boolean serializeField(JsonSerializerInternal serializer, Object parent, FieldAccess fieldAccess, CharBuf builder) { // It only check parent class equality, doesn't work with inheritance if (parentClass == parent.getClass() && fieldName.equals(fieldAccess.name())) { Object value = fieldAccess.getValue(parent); serialize(serializer, parent, fieldAccess, value, builder); return true; } return false; }
private final Map<String, FieldAccess> doGetFields ( Class<? extends Object> aClass ) { Map<String, FieldAccess> fields = Maps.copy ( Reflection.getPropertyFieldAccessMapFieldFirstForSerializer ( aClass ) ); List<FieldAccess> removeFields = new ArrayList<>(); for (FieldAccess field : fields.values()) { if (field.isWriteOnly ()) { removeFields.add(field); } } for (FieldAccess fieldAccess : removeFields) { fields.remove(fieldAccess.name()); } return fields; }
public static float getPropertyFloat( final Object root, final String... properties ) { final String lastProperty = properties[ properties.length - 1 ]; if ( isDigits( lastProperty ) ) { return Conversions.toFloat(getPropertyValue(root, properties)); } Object object = baseForGetProperty( root, properties ); Map<String, FieldAccess> fields = getFieldsFromObject( object ); FieldAccess field = fields.get( lastProperty ); if ( field.type() == Typ.flt ) { return field.getFloat( object ); } else { return Conversions.toFloat( field.getValue( object ) ); } }
public static int getPropertyInt( final Object root, final String... properties ) { final String lastProperty = properties[ properties.length - 1 ]; if ( isDigits( lastProperty ) ) { return Conversions.toInt(getPropertyValue(root, properties)); } Object object = baseForGetProperty( root, properties ); Map<String, FieldAccess> fields = getFieldsFromObject(object); FieldAccess field = fields.get(lastProperty); if ( field.type() == Typ.intgr ) { return field.getInt( object ); } else { return Conversions.toInt(field.getValue(object)); } }
public static long getPropertyLong( final Object root, final String... properties ) { final String lastProperty = properties[ properties.length - 1 ]; if ( isDigits( lastProperty ) ) { return Conversions.toLong(getPropertyValue(root, properties)); } Object object = baseForGetProperty( root, properties ); Map<String, FieldAccess> fields = getFieldsFromObject( object ); FieldAccess field = fields.get( lastProperty ); if ( field.type() == Typ.lng ) { return field.getLong( object ); } else { return Conversions.toLong( field.getValue( object ) ); } }
public static double getPropertyDouble( final Object root, final String... properties ) { final String lastProperty = properties[ properties.length - 1 ]; if ( isDigits( lastProperty ) ) { return Conversions.toDouble(getPropertyValue(root, properties)); } Object object = baseForGetProperty( root, properties ); Map<String, FieldAccess> fields = getFieldsFromObject( object ); FieldAccess field = fields.get( lastProperty ); if ( field.type() == Typ.dbl ) { return field.getDouble( object ); } else { return Conversions.toDouble( field.getValue( object ) ); } }
private static String getPropertyString(Object root, String[] properties) { Object object = baseForGetProperty(root, properties); Map<String, FieldAccess> fields = getFieldsFromObject( object ); final String lastProperty = properties[ properties.length - 1 ]; FieldAccess field = fields.get( lastProperty ); if ( field.type() == Typ.string ) { return (String) field.getObject( object ); } else { return Conversions.toString(field.getValue(object)); } }