void saveUrl(String s) { SharedPreferences prefs = getSharedPreferences(getString(R.string.preference_file_key), Context.MODE_PRIVATE); ArrayList<String> urls = new ArrayList<String>(); try { urls = (ArrayList<String>) ObjectSerializer.deserialize( prefs.getString( getString(R.string.preference_file_key), ObjectSerializer.serialize(new ArrayList<String>()))); } catch (IOException e) { e.printStackTrace(); } if (!urls.contains(s)) urls.add(s); // save the url list to preferences SharedPreferences.Editor editor = prefs.edit(); try { editor.putString(getString(R.string.preference_file_key), ObjectSerializer.serialize(urls)); } catch (IOException e) { e.printStackTrace(); } editor.commit(); }
public void write(JSONSerializer serializer, Object object) throws IOException { SerializeWriter out = serializer.getWrier(); DataVO vo = (DataVO) object; if (vo == null) { out.append("null"); return; } try { String[] fields = vo.getFieldNames(); if (fields.length == 0) { out.append("{}"); return; } out.append('{'); boolean commaFlag = false; for (int i = 0; i < fields.length; ++i) { Object propertyValue = vo.getValue(fields[i]); if (propertyValue == null && (!serializer.isEnabled(SerializerFeature.WriteMapNullValue))) { continue; } List<PropertyFilter> propertyFilters = serializer.getPropertyFiltersDirect(); if (propertyFilters != null) { boolean apply = true; for (PropertyFilter propertyFilter : propertyFilters) { if (!propertyFilter.apply(object, fields[i], propertyValue)) { apply = false; break; } } if (!apply) { continue; } } if (commaFlag) { out.append(','); } commaFlag = true; if (propertyValue == null) { out.write(fields[i] + " : null "); continue; } ObjectSerializer objserializer = serializer.getObjectWriter(propertyValue.getClass()); out.write("\"".concat(fields[i]).concat("\":")); objserializer.write(serializer, propertyValue); } out.append('}'); } catch (Exception e) { throw new JSONException("write javaBean error", e); } }
@Override public void writeValue(JSONSerializer serializer, Object propertyValue) throws Exception { if (format != null) { serializer.writeWithFormat(propertyValue, format); return; } if (fieldSerializer == null) { if (propertyValue == null) { runtimeFieldClass = this.fieldInfo.getFieldClass(); } else { runtimeFieldClass = propertyValue.getClass(); } fieldSerializer = serializer.getObjectWriter(runtimeFieldClass); } if (propertyValue == null) { if (writeNumberAsZero && Number.class.isAssignableFrom(runtimeFieldClass)) { serializer.getWriter().write('0'); return; } else if (writeNullStringAsEmpty && String.class == runtimeFieldClass) { serializer.getWriter().write("\"\""); return; } else if (writeNullBooleanAsFalse && Boolean.class == runtimeFieldClass) { serializer.getWriter().write("false"); return; } else if (writeNullListAsEmpty && Collection.class.isAssignableFrom(runtimeFieldClass)) { serializer.getWriter().write("[]"); return; } fieldSerializer.write(serializer, null, fieldInfo.getName(), null); return; } if (writeEnumUsingToString == true && runtimeFieldClass.isEnum()) { serializer.getWriter().writeString(((Enum<?>) propertyValue).name()); return; } Class<?> valueClass = propertyValue.getClass(); if (valueClass == runtimeFieldClass) { fieldSerializer.write( serializer, propertyValue, fieldInfo.getName(), fieldInfo.getFieldType()); return; } ObjectSerializer valueSerializer = serializer.getObjectWriter(valueClass); valueSerializer.write(serializer, propertyValue, fieldInfo.getName(), fieldInfo.getFieldType()); }
public void write( JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException { SerializeWriter out = serializer.getWriter(); if (object == null) { if (out.isEnabled(SerializerFeature.WriteNullListAsEmpty)) { out.write("[]"); } else { out.writeNull(); } return; } Type elementType = null; if (serializer.isEnabled(SerializerFeature.WriteClassName)) { if (fieldType instanceof ParameterizedType) { ParameterizedType param = (ParameterizedType) fieldType; elementType = param.getActualTypeArguments()[0]; } } Enumeration<?> e = (Enumeration<?>) object; SerialContext context = serializer.getContext(); serializer.setContext(context, object, fieldName, 0); try { int i = 0; out.append('['); while (e.hasMoreElements()) { Object item = e.nextElement(); if (i++ != 0) { out.append(','); } if (item == null) { out.writeNull(); continue; } Class<?> clazz = item.getClass(); ObjectSerializer itemSerializer = serializer.getObjectWriter(clazz); itemSerializer.write(serializer, item, i - 1, elementType, 0); } out.append(']'); } finally { serializer.setContext(context); } }
/** * Verifies that the serializers in use by the history repository are in the correct modes. * * @throws Exception if an unexpected error occurs */ public void testSerializerModes() throws Exception { abstract class SerializerFactory { public abstract ObjectSerializer makeSerializer(); } SerializerFactory[] actions = new SerializerFactory[] { new SerializerFactory() { public ObjectSerializer makeSerializer() { return repository.makeAuStateSerializer(); } }, new SerializerFactory() { public ObjectSerializer makeSerializer() { return repository.makeDamagedNodeSetSerializer(); } }, new SerializerFactory() { public ObjectSerializer makeSerializer() { return repository.makeIdentityAgreementListSerializer(); } }, new SerializerFactory() { public ObjectSerializer makeSerializer() { return repository.makeNodeStateSerializer(); } }, new SerializerFactory() { public ObjectSerializer makeSerializer() { return repository.makePollHistoriesSerializer(); } }, }; // For each variant action... for (int action = 0; action < actions.length; ++action) { log.debug("Starting with action " + action); ObjectSerializer serializer = actions[action].makeSerializer(); assertEquals( ObjectSerializer.FAILED_DESERIALIZATION_RENAME, serializer.getFailedDeserializationMode()); // CASTOR: Which concrete class is returned may change over time assertTrue(serializer instanceof CXSerializer); CXSerializer cxSerializer = (CXSerializer) serializer; assertEquals( CXSerializer.getCompatibilityModeFromConfiguration(), cxSerializer.getCompatibilityMode()); } }
private static String train( SQLContext sqlContext, DataFrame positives, DataFrame negatives, String modelFileName) { // combine data sets DataFrame all = positives.unionAll(negatives); // split into training and test sets DataFrame[] split = all.randomSplit(new double[] {.80, .20}, 1); DataFrame training = split[0].cache(); DataFrame test = split[1].cache(); // fit logistic regression model PipelineModel model = fitLogisticRegressionModel(training); try { ObjectSerializer.serialize(model, modelFileName); } catch (IOException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } // predict on training data to evaluate goodness of fit DataFrame trainingResults = model.transform(training).cache(); // predict on test set to evaluate goodness of fit DataFrame testResults = model.transform(test).cache(); // predict on unassigned data mentions StringBuilder sb = new StringBuilder(); sb.append(getMetrics(trainingResults, "Training\n")); sb.append(getMetrics(testResults, "Testing\n")); return sb.toString(); }
private void compareSize(int[] data) { // Compare byte usage with ObjectSerializer. ByteBuffer optimizedBb = serializer.toByteBuffer(data); ByteBuffer objectBb = ObjectSerializer.get().toByteBuffer(data); System.out.printf( "Optimized size: %s, Default size: %s%n", optimizedBb.remaining(), objectBb.remaining()); Assert.assertTrue(optimizedBb.remaining() < objectBb.remaining()); }
public final void write( JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException { SerializeWriter out = serializer.getWriter(); if (object == null) { if (out.isEnabled(SerializerFeature.WriteNullListAsEmpty)) { out.write("[]"); } else { out.writeNull(); } return; } Object[] array = (Object[]) object; int size = array.length; int end = size - 1; if (end == -1) { out.append("[]"); return; } out.append('['); for (int i = 0; i < end; ++i) { Object item = array[i]; if (item == null) { out.append("null,"); } else { compObjectSerializer.write(serializer, item, null, null); out.append(','); } } Object item = array[end]; if (item == null) { out.append("null]"); } else { compObjectSerializer.write(serializer, item, null, null); out.append(']'); } }
@Test public void Write_Read_Map() { Mab mab = new Mab(); mab.primitives.put("123", 456); mab.primitives.put("null", null); KeyValue kv = new KeyValue(567); mab.objects.put(kv, kv); mab.objects.put(new KeyValue(789), new KeyValue(234)); mab.objects.put(new KeyValue(890), null); Map<PropertyPath, Object> map = serializer.toPropertyMap(mab); mab = serializer.fromPropertyMap(map); assertThat(mab.primitives, equalTo(map("123", 456, "null", null))); assertThat( mab.objects, equalTo(map(kv, kv, new KeyValue(789), new KeyValue(234), new KeyValue(890), null))); }
public final void serialize(JsonContext context, T keyValuePairs) { List<KeyValue<String, Object>> items = listItem(keyValuePairs); if (items == null) { context.context("{}"); return; } context.context('{'); int i = 0; for (KeyValue<String, Object> item : items) { String key = item.getKey(); Object value = item.getValue(); context.context('"'); context.context(JsonUtils.render(key.toString())); context.context('"'); context.context(':'); JsonSerializeConfigHolder.addPro(key); ObjectSerializer.getInstance().serialize(context, value); if (i++ != items.size() - 1) { context.context(","); } JsonSerializeConfigHolder.backPro(); } context.context('}'); }
public void writeValue(JSONSerializer serializer, Object propertyValue) throws Exception { if (runtimeInfo == null) { Class<?> runtimeFieldClass; if (propertyValue == null) { runtimeFieldClass = this.fieldInfo.fieldClass; } else { runtimeFieldClass = propertyValue.getClass(); } ObjectSerializer fieldSerializer; JSONField fieldAnnotation = fieldInfo.getAnnotation(); if (fieldAnnotation != null && fieldAnnotation.serializeUsing() != Void.class) { fieldSerializer = (ObjectSerializer) fieldAnnotation.serializeUsing().newInstance(); } else { fieldSerializer = serializer.getObjectWriter(runtimeFieldClass); } runtimeInfo = new RuntimeSerializerInfo(fieldSerializer, runtimeFieldClass); } final RuntimeSerializerInfo runtimeInfo = this.runtimeInfo; final int fieldFeatures = fieldInfo.serialzeFeatures; if (propertyValue == null) { Class<?> runtimeFieldClass = runtimeInfo.runtimeFieldClass; SerializeWriter out = serializer.out; if (Number.class.isAssignableFrom(runtimeFieldClass)) { out.writeNull(features, SerializerFeature.WriteNullNumberAsZero.mask); return; } else if (String.class == runtimeFieldClass) { out.writeNull(features, SerializerFeature.WriteNullStringAsEmpty.mask); return; } else if (Boolean.class == runtimeFieldClass) { out.writeNull(features, SerializerFeature.WriteNullBooleanAsFalse.mask); return; } else if (Collection.class.isAssignableFrom(runtimeFieldClass)) { out.writeNull(features, SerializerFeature.WriteNullListAsEmpty.mask); return; } ObjectSerializer fieldSerializer = runtimeInfo.fieldSerializer; if ((out.isEnabled(SerializerFeature.WRITE_MAP_NULL_FEATURES)) && fieldSerializer instanceof JavaBeanSerializer) { out.writeNull(); return; } fieldSerializer.write(serializer, null, fieldInfo.name, fieldInfo.fieldType, fieldFeatures); return; } if (fieldInfo.isEnum) { if (writeEnumUsingName) { serializer.out.writeString(((Enum<?>) propertyValue).name()); return; } if (writeEnumUsingToString) { serializer.out.writeString(((Enum<?>) propertyValue).toString()); return; } } Class<?> valueClass = propertyValue.getClass(); ObjectSerializer valueSerializer; if (valueClass == runtimeInfo.runtimeFieldClass) { valueSerializer = runtimeInfo.fieldSerializer; } else { valueSerializer = serializer.getObjectWriter(valueClass); } if (format != null) { if (valueSerializer instanceof ContextObjectSerializer) { ((ContextObjectSerializer) valueSerializer) .write(serializer, propertyValue, this.fieldContext); } else { serializer.writeWithFormat(propertyValue, format); } } else { valueSerializer.write( serializer, propertyValue, fieldInfo.name, fieldInfo.fieldType, fieldFeatures); } }
@SuppressWarnings({"rawtypes", "unchecked"}) public void write(PBSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException { SerializeWriter out = serializer.getWriter(); if (fieldName == null) { if (object instanceof ConcurrentHashMap) { out.getCodedOutputStream().writeRawByte(com.jd.glowworm.asm.Type.MAP_ConcurrentHashMap); } else if (object instanceof LinkedHashMap) { out.getCodedOutputStream().writeRawByte(com.jd.glowworm.asm.Type.MAP_LinkedHash); } else if (object instanceof HashMap) { out.getCodedOutputStream().writeRawByte(com.jd.glowworm.asm.Type.MAP_HASH); } else { out.getCodedOutputStream().writeRawByte(com.jd.glowworm.asm.Type.Unknown); } } Map<?, ?> map = (Map<?, ?>) object; try { int tmpMapSize = map.size(); out.writeInt(tmpMapSize); Class<?> preClazz = null; ObjectSerializer preWriter = null; for (Map.Entry entry : map.entrySet()) { Object entryKey = entry.getKey(); Object value = entry.getValue(); // if (entryKey == null || entryKey instanceof String) if (entryKey instanceof String) { String key = (String) entryKey; StringSerializer.instance.write(serializer, key, null, null); } else { serializer.write(entryKey); } if (value == null) { out.writeNull(); continue; } Class<?> clazz = value.getClass(); if (clazz == preClazz) { preWriter.write(serializer, value, null, null); } else { preClazz = clazz; preWriter = serializer.getObjectWriter(clazz); String tmpClassName = preWriter.getClass().getName(); if (tmpClassName.startsWith(ASMSerializerFactory.GenClassName_prefix)) { out.getCodedOutputStream().writeRawByte(com.jd.glowworm.asm.Type.OBJECT); out.writeString(clazz.getName()); } preWriter.write(serializer, value, null, clazz); } } } catch (Exception ex) { ex.printStackTrace(); } }
public final void write( JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException { SerializeWriter out = serializer.getWriter(); Object[] array = (Object[]) object; if (object == null) { if (out.isEnabled(SerializerFeature.WriteNullListAsEmpty)) { out.write("[]"); } else { out.writeNull(); } return; } int size = array.length; int end = size - 1; if (end == -1) { out.append("[]"); return; } SerialContext context = serializer.getContext(); serializer.setContext(context, object, fieldName, 0); try { Class<?> preClazz = null; ObjectSerializer preWriter = null; out.append('['); if (out.isEnabled(SerializerFeature.PrettyFormat)) { serializer.incrementIndent(); serializer.println(); for (int i = 0; i < size; ++i) { if (i != 0) { out.write(','); serializer.println(); } serializer.write(array[i]); } serializer.decrementIdent(); serializer.println(); out.write(']'); return; } for (int i = 0; i < end; ++i) { Object item = array[i]; if (item == null) { out.append("null,"); } else { if (serializer.containsReference(item)) { serializer.writeReference(item); } else { Class<?> clazz = item.getClass(); if (clazz == preClazz) { preWriter.write(serializer, item, null, null); } else { preClazz = clazz; preWriter = serializer.getObjectWriter(clazz); preWriter.write(serializer, item, null, null); } } out.append(','); } } Object item = array[end]; if (item == null) { out.append("null]"); } else { if (serializer.containsReference(item)) { serializer.writeReference(item); } else { serializer.writeWithFieldName(item, end); } out.append(']'); } } finally { serializer.setContext(context); } }