public static Object loadAnObjectXML(String path) throws FileNotFoundException {
    try {
        XMLDecoder decoder = new XMLDecoder(new BufferedInputStream(new FileInputStream(path)));
        Object obj = decoder.readobject();
        decoder.close();
        return obj;
    } catch (FileNotFoundException e) {
        e.printstacktrace();
        throw e;
    }
}

public Object read(java.io.Reader r) throws IOException,ClassNotFoundException {
    java.io.
    BufferedReader buf = new BufferedReader(r,4096);
    CharBuffer arr = CharBuffer.allocate(2048);
    buf.mark(arr.capacity());
    buf.read(arr);
    arr.flip();

    Matcher m = Pattern.compile("<java").matcher(arr);
    if (m.find()) {
        buf.reset();
        buf.skip(m.start());
    } else {
        buf.reset();
    }
    XMLDecoder d = new XMLDecoder(new ReaderInputStream(buf,"UTF-8"));
    return d.readobject();
}

/**
 * Decode a Java object,which is contained in the given XML
 * 
 * @param xml
 *            a XML string
 * @return a Java object
 * @throws BillingException
 *             if the XML decoding fails
 */
Object decodeXml(String xml) throws BillingException {

    if (xml != null) {
        try (XMLDecoder xmlDecoder = new XMLDecoder(
                new ByteArrayInputStream(
                        xml.getBytes(StandardCharsets.UTF_8)))) {
            return xmlDecoder.readobject();
        } catch (Exception e) {
            throw new BillingException(
                    "File application response decoding error.");
        }
    } else {
        return null;
    }
}

/** 
 * 读取由objSource指定的XML文件中的序列化保存的对象,返回的结果经过了List封装 
 * @param objSource 带全部文件路径的文件全名 
 * @return 由XML文件里面保存的对象构成的List列表(可能是一个或者多个的序列化保存的对象)   
 * @throws FileNotFoundException 指定的对象读取资源不存在 
 * @throws IOException 读取发生错误 
 * @throws Exception 其他运行时异常发生 
 */ 
public static List objectXmlDecoder(String objSource)  
 throws FileNotFoundException,IOException,Exception 
{ 
 List objList = new ArrayList();     
 File fin = new File(objSource); 
 FileInputStream fis = new FileInputStream(fin); 
 XMLDecoder decoder = new XMLDecoder(fis); 
 Object obj = null; 
 try 
 { 
  while( (obj = decoder.readobject()) != null) 
  { 
   objList.add(obj); 
  } 
 } 
 catch (Exception e) 
 { 
  // Todo Auto-generated catch block     
 } 
 fis.close(); 
 decoder.close();      
 return objList; 
}

static void test(AbstractTest object) {
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    XMLEncoder encoder = new XMLEncoder(output);
    encoder.setPersistenceDelegate(
            object.getClass(),new DefaultPersistenceDelegate(new String[] {"value"}));

    encoder.writeObject(object);
    encoder.close();

    System.out.print(output);

    ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
    XMLDecoder decoder = new XMLDecoder(input);
    AbstractTest result = (AbstractTest) decoder.readobject();
    decoder.close();

    if (object.getValue() != result.getValue())
        throw new Error("Should be " + object);
}

/**
 * This is entry point to start testing.
 *
 * @param security  use {@code true} to start
 *                  second pass in secure context
 */
final void test(boolean security) {
    byte[] array = getFieldValue("XML").getBytes(); // NON-NLS: the field name
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    validate(decoder);
    try {
        throw new Error("unexpected object" + decoder.readobject());
    } catch (Arrayindexoutofboundsexception exception) {
        // expected exception
    }
    decoder.close();
    if (security) {
        System.setSecurityManager(new SecurityManager());
        test(false);
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    Number[] numbers = getArray(Number.class,2,decoder.readobject());
    if (!numbers[0].equals(Byte.valueOf("-111"))) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected byte value");
    }
    if (!numbers[1].equals(Long.valueOf("1111"))) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected long value");
    }

    Object[] objects = getArray(Object.class,3,decoder.readobject());
    if (objects[0] != null) {
        throw new Error("unexpected first value");
    }
    if (!objects[1].equals("Hello,world!")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected string value");
    }
    if (objects[2] != null) {
        throw new Error("unexpected last value");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    JPanel panel = (JPanel) decoder.readobject();
    if (2 != panel.getComponents().length) {
        throw new Error("unexpected component count");
    }
    JButton button = (JButton) panel.getComponents()[0];
    if (!button.getText().equals("button")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected button text");
    }
    if (SwingConstants.CENTER != button.getVerticalAlignment()) {
        throw new Error("unexpected vertical alignment");
    }
    JLabel label = (JLabel) panel.getComponents()[1];
    if (!label.getText().equals("label")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected label text");
    }
    if (button != label.getLabelFor()) {
        throw new Error("unexpected component");
    }
}

static void test(AbstractTest object) {
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    XMLEncoder encoder = new XMLEncoder(output);
    encoder.setPersistenceDelegate(
            object.getClass(),new DefaultPersistenceDelegate(new String[] {"value"}));

    encoder.writeObject(object);
    encoder.close();

    System.out.print(output);

    ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
    XMLDecoder decoder = new XMLDecoder(input);
    AbstractTest result = (AbstractTest) decoder.readobject();
    decoder.close();

    if (object.getValue() != result.getValue())
        throw new Error("Should be " + object);
}

/**
 * This is entry point to start testing.
 *
 * @param security  use {@code true} to start
 *                  second pass in secure context
 */
final void test(boolean security) {
    byte[] array = getFieldValue("XML").getBytes(); // NON-NLS: the field name
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    validate(decoder);
    try {
        throw new Error("unexpected object" + decoder.readobject());
    } catch (Arrayindexoutofboundsexception exception) {
        // expected exception
    }
    decoder.close();
    if (security) {
        System.setSecurityManager(new SecurityManager());
        test(false);
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    Number[] numbers = getArray(Number.class,world!")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected string value");
    }
    if (objects[2] != null) {
        throw new Error("unexpected last value");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    JPanel panel = (JPanel) decoder.readobject();
    if (2 != panel.getComponents().length) {
        throw new Error("unexpected component count");
    }
    JButton button = (JButton) panel.getComponents()[0];
    if (!button.getText().equals("button")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected button text");
    }
    if (SwingConstants.CENTER != button.getVerticalAlignment()) {
        throw new Error("unexpected vertical alignment");
    }
    JLabel label = (JLabel) panel.getComponents()[1];
    if (!label.getText().equals("label")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected label text");
    }
    if (button != label.getLabelFor()) {
        throw new Error("unexpected component");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    JPanel panel = (JPanel) decoder.readobject();
    if (2 != panel.getComponents().length) {
        throw new Error("unexpected component count");
    }
    JButton button = (JButton) panel.getComponents()[0];
    if (!button.getText().equals("button")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected button text");
    }
    if (SwingConstants.CENTER != button.getVerticalAlignment()) {
        throw new Error("unexpected vertical alignment");
    }
    JLabel label = (JLabel) panel.getComponents()[1];
    if (!label.getText().equals("label")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected label text");
    }
    if (button != label.getLabelFor()) {
        throw new Error("unexpected component");
    }
}

/**
 * This is entry point to start testing.
 *
 * @param security  use {@code true} to start
 *                  second pass in secure context
 */
final void test(boolean security) {
    byte[] array = getFieldValue("XML").getBytes(); // NON-NLS: the field name
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    validate(decoder);
    try {
        throw new Error("unexpected object" + decoder.readobject());
    } catch (Arrayindexoutofboundsexception exception) {
        // expected exception
    }
    decoder.close();
    if (security) {
        System.setSecurityManager(new SecurityManager());
        test(false);
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    Number[] numbers = getArray(Number.class,world!")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected string value");
    }
    if (objects[2] != null) {
        throw new Error("unexpected last value");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    JPanel panel = (JPanel) decoder.readobject();
    if (2 != panel.getComponents().length) {
        throw new Error("unexpected component count");
    }
    JButton button = (JButton) panel.getComponents()[0];
    if (!button.getText().equals("button")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected button text");
    }
    if (SwingConstants.CENTER != button.getVerticalAlignment()) {
        throw new Error("unexpected vertical alignment");
    }
    JLabel label = (JLabel) panel.getComponents()[1];
    if (!label.getText().equals("label")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected label text");
    }
    if (button != label.getLabelFor()) {
        throw new Error("unexpected component");
    }
}

/**
 * To object.
 *
 * @param xml
 *            the xml
 * @return the object
 */
public static Object toObject(final String xml) {
    // XStream x = createXStream();
    // return x.fromXML(xml);
    // try {
    final ByteArrayInputStream out = new ByteArrayInputStream(xml.getBytes());
    final XMLDecoder encoder = new XMLDecoder(out);
    final Object object = encoder.readobject();
    //
    encoder.close();
    return object;
    // } catch (Exception e) {
    // System.err.println("Failed to decode object : \n" + xml);
    // return null;
    // }
    // return null;
}

public List<HttpPostForm> load() {
    final List<HttpPostForm> list = new ArrayList<>();

    final FileObject fo = getSaveFolder();
    final File fileFolder = FileUtil.toFile(fo);

    final File[] files = fileFolder.listFiles();
    for (int i = 0; i < files.length; i++) {
        final File aFile = files[i];

        try (FileInputStream fis = new FileInputStream(aFile)) {
            XMLDecoder xmlDec = new XMLDecoder(fis);
            HttpPostForm hpf = (HttpPostForm) xmlDec.readobject();

            list.add(hpf);
        } catch (IOException ex) {
            ErrorManager.getDefault().notify(ex);
        }
    }
    return list;
}

static void test(AbstractTest object) {
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    XMLEncoder encoder = new XMLEncoder(output);
    encoder.setPersistenceDelegate(
            object.getClass(),new DefaultPersistenceDelegate(new String[] {"value"}));

    encoder.writeObject(object);
    encoder.close();

    System.out.print(output);

    ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
    XMLDecoder decoder = new XMLDecoder(input);
    AbstractTest result = (AbstractTest) decoder.readobject();
    decoder.close();

    if (object.getValue() != result.getValue())
        throw new Error("Should be " + object);
}

/**
 * This is entry point to start testing.
 *
 * @param security  use {@code true} to start
 *                  second pass in secure context
 */
final void test(boolean security) {
    byte[] array = getFieldValue("XML").getBytes(); // NON-NLS: the field name
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    validate(decoder);
    try {
        throw new Error("unexpected object" + decoder.readobject());
    } catch (Arrayindexoutofboundsexception exception) {
        // expected exception
    }
    decoder.close();
    if (security) {
        System.setSecurityManager(new SecurityManager());
        test(false);
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    Number[] numbers = getArray(Number.class,world!")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected string value");
    }
    if (objects[2] != null) {
        throw new Error("unexpected last value");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    JPanel panel = (JPanel) decoder.readobject();
    if (2 != panel.getComponents().length) {
        throw new Error("unexpected component count");
    }
    JButton button = (JButton) panel.getComponents()[0];
    if (!button.getText().equals("button")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected button text");
    }
    if (SwingConstants.CENTER != button.getVerticalAlignment()) {
        throw new Error("unexpected vertical alignment");
    }
    JLabel label = (JLabel) panel.getComponents()[1];
    if (!label.getText().equals("label")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected label text");
    }
    if (button != label.getLabelFor()) {
        throw new Error("unexpected component");
    }
}

static void test(AbstractTest object) {
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    XMLEncoder encoder = new XMLEncoder(output);
    encoder.setPersistenceDelegate(
            object.getClass(),new DefaultPersistenceDelegate(new String[] {"value"}));

    encoder.writeObject(object);
    encoder.close();

    System.out.print(output);

    ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
    XMLDecoder decoder = new XMLDecoder(input);
    AbstractTest result = (AbstractTest) decoder.readobject();
    decoder.close();

    if (object.getValue() != result.getValue())
        throw new Error("Should be " + object);
}

public static CheckList read(File file) throws Exception {
    XMLDecoder decoder = new XMLDecoder(new FileInputStream(file));
    try {
        return (CheckList) decoder.readobject();
    } finally {
        decoder.close();
    }
}

@Override public void setText(String code) {
    ByteArrayInputStream stream = new ByteArrayInputStream(code.getBytes(StandardCharsets.UTF_8));
    XMLDecoder decoder = new XMLDecoder(stream);
    checklist = (CheckList) decoder.readobject();
    decoder.close();
    checkListView.setCheckListNode(new CheckListFormNode(checklist,Mode.EDIT));
}

@Test
public void getobjectFromXML_closeStream() throws Exception {
    // given
    ResultSet rs = mock(ResultSet.class);
    InputStream is = mock(InputStream.class);
    doReturn(is).when(rs).getBinaryStream(eq("value"));
    XMLDecoder decoder = mock(XMLDecoder.class);
    doReturn(decoder).when(dbtask).newXmlDecoder(any(InputStream.class));

    // when
    dbtask.getobjectFromXML(rs,String.class);

    // then
    verify(dbtask).closeStream(is);
}

@Override
public <E> E loadConfigFromFile(String fileName,Class<E> type) throws Exception {
    try(XMLDecoder xmlDecoder = new XMLDecoder(new BufferedInputStream(new FileInputStream(getFileForFilename(fileName))),null,type.getClassLoader())) {
        Object theObject = xmlDecoder.readobject();
        if(type.isinstance(theObject)) {
            return type.cast(theObject);
        } else {
            LOGGER.warn("UnkNown file format {}. Not {}.",fileName,type.getName());
            throw new Exception("UnkNown file format");
        }
    } catch (RuntimeException e) {
        throw new Exception(e);
    }
}

public ReadOnlyURLMapper() {

        if (LASTPLATFORMS_FILE.exists()) {
            try {
                XMLDecoder decoder = new XMLDecoder(new FileInputStream(LASTPLATFORMS_FILE));
                String[] last = (String[]) decoder.readobject();
                if (last != null) {
                    reference.set(last);
                }
            } catch (Exception ex) {
            }
        }

    }

/**
 * Returns the owner of the owner document handler
 * as a value of <java> element.
 *
 * @return the owner of the owner document handler
 */
private Object getValue() {
    Object owner = getowner().getowner();
    if ((this.type == null) || isValid(owner)) {
        return owner;
    }
    if (owner instanceof XMLDecoder) {
        XMLDecoder decoder = (XMLDecoder) owner;
        owner = decoder.getowner();
        if (isValid(owner)) {
            return owner;
        }
    }
    throw new IllegalStateException("Unexpected owner class: " + owner.getClass().getName());
}

/**
 * Returns the owner of the owner document handler
 * as a value of <java> element.
 *
 * @return the owner of the owner document handler
 */
private Object getValue() {
    Object owner = getowner().getowner();
    if ((this.type == null) || isValid(owner)) {
        return owner;
    }
    if (owner instanceof XMLDecoder) {
        XMLDecoder decoder = (XMLDecoder) owner;
        owner = decoder.getowner();
        if (isValid(owner)) {
            return owner;
        }
    }
    throw new IllegalStateException("Unexpected owner class: " + owner.getClass().getName());
}

private Object readobject(byte[] array) {
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    initialize(decoder);
    Object object = decoder.readobject();
    decoder.close();
    return object;
}

private Object decode(byte[] array) {
    ByteArrayInputStream in = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(in,this,this);
    Object object = decoder.readobject();
    validate(object);
    decoder.close();
    return object;
}

private static void test(Locale locale,byte[] data) {
    Locale.setDefault(locale);
    System.out.println("locale = " + locale);

    XMLDecoder decoder = new XMLDecoder(new ByteArrayInputStream(data));
    System.out.println("object = " + decoder.readobject());
    decoder.close();
}

public static void main(String[] args) {
    Test6338070 test = new Test6338070();
    InputStream stream = new ByteArrayInputStream(DATA.getBytes());
    new XMLDecoder(stream,test).close();
    if (test.message == null) {
        throw new Error("owner's method is not called");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    for (int i = 0; i < 3; i++) {
        if (decoder != decoder.readobject()) {
            throw new Error("decoder instance expected");
        }
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    validate(0,decoder.readobject());
    validate((int) Byte.MAX_VALUE,decoder.readobject());
    validate((int) Byte.MIN_VALUE,decoder.readobject());
    validate((int) Short.MAX_VALUE,decoder.readobject());
    validate((int) Short.MIN_VALUE,decoder.readobject());
    validate(Integer.MAX_VALUE,decoder.readobject());
    validate(Integer.MIN_VALUE,decoder.readobject());
}

@Override
protected void validate(XMLDecoder decoder) {
    validate(0.0f,decoder.readobject());
    validate(100.0f,decoder.readobject());
    validate(-1e15f,decoder.readobject());
    validate(100e-20f,decoder.readobject());
}

@Override
protected void validate(XMLDecoder decoder) {
    if (!Boolean.TRUE.equals(decoder.readobject())) {
        throw new Error("true expected");
    }
    if (!Boolean.FALSE.equals(decoder.readobject())) {
        throw new Error("false expected");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    decoder.setowner(this);
    if (this != decoder.readobject()) {
        throw new Error("owner should be the same");
    }
    if (this.message == null) {
        throw new Error("owner's method is not called");
    }
}

@Override
protected void validate(XMLDecoder decoder) {
    validate(decoder.readobject());
    validate(decoder.readobject(),null);
    validate(decoder.readobject(),"single");
    validate(decoder.readobject(),"first","second","third");
}

@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,BeanDescription beanDesc,BeanDeserializerBuilder builder) {
    for (BeanPropertyDeFinition propDef : beanDesc.findProperties()) {
        if (!propDef.hasGetter() || propDef.hasSetter()) {
            continue;
        }
        AnnotatedMember getter = propDef.getAccessor();
        if (!Keeper.class.equals(getter.getRawType())) {
            continue;
        }

        builder.addOrReplaceProperty(new CustomGetterBeanProperty(propDef,getter),true);
    }
    return builder;
}

/**
 * Creates a BeanDeserializerModifier that replaces the 
 * SettableBeanProperties in the BeanDeserializerBuilder with
 * ErrorReportingSettableBeanProperty instances that forward
 * information about errors when setting bean properties to the
 * given consumer. (Don't ask ... )  
 * 
 * @param jsonErrorConsumer The consumer for {@link JsonError}s.
 * If this is <code>null</code>,then no errors will be reported.
 * @return The modifier
 */
private static BeanDeserializerModifier 
    createErrorHandlingBeanDeserializerModifier(
        Consumer<? super JsonError> jsonErrorConsumer)
{
    return new BeanDeserializerModifier()
    {
        @Override
        public BeanDeserializerBuilder updateBuilder(
            DeserializationConfig config,BeanDeserializerBuilder builder)
        {
            Iterator<SettableBeanProperty> propertiesIterator =
                builder.getProperties();
            while (propertiesIterator.hasNext())
            {
                SettableBeanProperty property = propertiesIterator.next();
                SettableBeanProperty wrappedProperty =
                    new ErrorReportingSettableBeanProperty(
                        property,jsonErrorConsumer);
                builder.addOrReplaceProperty(wrappedProperty,true);
            }
            return builder;
        }
    };    
}

@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,BeanDeserializerBuilder builder) {
    if (!thinnables.contains(beanDesc.getBeanClass())) {
        return builder;
    }
    for (String ignore : ignorables) {
        builder.addIgnorable(ignore);
    }
    return builder;
}

@Override
public void setupModule(SetupContext context) {
    context.addBeanDeserializerModifier(new BeanDeserializerModifier(){
        @Override
        public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,BeanDeserializerBuilder builder) {
            //Todo: use clotho Value Instantiator (gets objects from pre-processing)
            builder.setValueInstantiator(null);
            return builder;
        }
    });
}

@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,BeanDeserializerBuilder builder) {
    Iterator<SettableBeanProperty> it = builder.getProperties();
    while (it.hasNext()) {
        SettableBeanProperty p = it.next();
        if (p.getAnnotation(JsonRawValue.class) != null) {
            builder.addOrReplaceProperty(p.withValueDeserializer(JsonAsstringDeserializer.INSTANCE),true);
        }
    }
    return builder;
}

@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,BeanDescription desc,BeanDeserializerBuilder deserializerBuilder) {
    return (this.canModify(desc) ? this.updateBuilderInternal(config,desc,deserializerBuilder) : super.updateBuilder(config,deserializerBuilder));
}

protected BeanDeserializerBuilder updateBuilderInternal(DeserializationConfig config,BeanDeserializerBuilder deserializerBuilder) {
    return super.updateBuilder(config,deserializerBuilder);
}

/**
 * 获取ObjectMapper反序列化枚举使用的module
 * 支持忽略大小写
 * @return
 */
public static SimpleModule getEnumSimpleModule() {
//枚举转换，支持忽略大小写的匹配
    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config,final JavaType type,BeanDescription beanDesc,final JsonDeserializer<?> deserializer) {
            return new JsonDeserializer<Enum>() {
                @Override
                public Enum deserialize(JsonParser jp,DeserializationContext ctxt) throws IOException {
                    Class rawClass =  type.getRawClass();

                    return getEnum(jp.getValueAsstring(),rawClass);
                }
            };
        }
    });

    return module;
}

private static ObjectMapper configureObjectMapper(
        ObjectMapper objectMapper,boolean shouldIncludeRawResponses) {
    if (shouldIncludeRawResponses) {
        SimpleModule module = new SimpleModule();
        module.setDeserializerModifier(new BeanDeserializerModifier() {
            @Override
            public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,JsonDeserializer<?> deserializer) {
                if (Response.class.isAssignableFrom(beanDesc.getBeanClass())) {
                    return new RawResponseDeserializer(deserializer);
                }

                return deserializer;
            }
        });

        objectMapper.registerModule(module);
    }

    objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES,true);
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNowN_PROPERTIES,false);

    return objectMapper;
}

@Override
public void setupModule(final SetupContext context) {
    super.setupModule(context);
    context.addBeanDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<?> modifyCollectionDeserializer(final DeserializationConfig config,final CollectionType type,final BeanDescription beanDesc,final JsonDeserializer<?> deserializer) {
            if (deserializer instanceof CollectionDeserializer) {
                return new ListDeserializer((CollectionDeserializer) deserializer);
            } else {
                return super.modifyCollectionDeserializer(config,type,beanDesc,deserializer);
            }
        }
    });
}

@Bean
public ObjectMapper objectMapper() {
    ObjectMapper mapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier( new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer( DeserializationConfig config,final JsonDeserializer<?> deserializer ) {
            return new JsonDeserializer<Enum>() {
                @Override
                public Enum deserialize( JsonParser jp,DeserializationContext ctxt ) throws IOException {
                    Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass();
                    return Enum.valueOf( rawClass,jp.getValueAsstring().toupperCase() );
                }
            };
        }
    } );

    module.addDeserializer( Expression.class,new ExpressionDeserializer( expressionParser() ) );
    module.addDeserializer( Range.class,new RangeDeserializer() );
    mapper.registerModule( module );

    return mapper;
}

public ObjectMapperResolver() {
    mapper = new ObjectMapper();

    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config,DeserializationContext ctxt) throws IOException {
                    Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass();
                    return Enum.valueOf(rawClass,jp.getValueAsstring().toupperCase());
                }
            };
        }
    });
    module.addSerializer(Enum.class,new StdSerializer<Enum>(Enum.class) {
        @Override
        public void serialize(Enum value,JsonGenerator jgen,SerializerProvider provider) throws IOException {
            jgen.writeString(value.name().toLowerCase());
        }
    });
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mapper.registerModule(module);
}

@SuppressWarnings("unchecked")
public CommonModule() {
    super("common",new Version(0,1,null,null));

    setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config,jp.getValueAsstring().toupperCase());
                }
            };
        }
    });

    addSerializer(Enum.class,SerializerProvider provider) throws IOException {
            jgen.writeString(value.name().toLowerCase());
        }
    });

    addDeserializer(String.class,new RawValueDeserializer());
}

/**
 * Gets a module wrapping this serializer as an adapter for the Jackson
 * ObjectMapper.
 *
 * @param mapper the object mapper for default deserializations
 * @return a simple module to be plugged onto Jackson ObjectMapper.
 */
public static SimpleModule getModule(final ObjectMapper mapper) {
    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,JsonDeserializer<?> deserializer) {
            if (beanDesc.getBeanClass().getAnnotation(JsonFlatten.class) != null) {
                return new FlatteningDeserializer(beanDesc.getBeanClass(),deserializer,mapper);
            }
            return deserializer;
        }
    });
    return module;
}

/**
 * Creates a BeanDeserializerModifier that replaces the 
 * SettableBeanProperties in the BeanDeserializerBuilder with
 * ErrorReportingSettableBeanProperty instances that forward
 * information about errors when setting bean properties to the
 * given consumer. (Don't ask ... )  
 * 
 * @param jsonErrorConsumer The consumer for {@link JsonError}s.
 * If this is <code>null</code>,then no errors will be reported.
 * @return The modifier
 */
private static BeanDeserializerModifier 
    createErrorHandlingBeanDeserializerModifier(
        Consumer<? super JsonError> jsonErrorConsumer)
{
    return new BeanDeserializerModifier()
    {
        @Override
        public BeanDeserializerBuilder updateBuilder(
            DeserializationConfig config,BeanDeserializerBuilder builder)
        {
            Iterator<SettableBeanProperty> propertiesIterator =
                builder.getProperties();
            while (propertiesIterator.hasNext())
            {
                SettableBeanProperty property = propertiesIterator.next();
                SettableBeanProperty wrappedProperty =
                    new ErrorReportingSettableBeanProperty(
                        property,jsonErrorConsumer);
                builder.addOrReplaceProperty(wrappedProperty,true);
            }
            return builder;
        }
    };    
}

public ObjectMapperResolver() {
    mapper = new GraviteeMapper();

    //because Permissions are represented as char[]
    mapper.enable(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS);

    // register filter provider
    registerFilterProvider();

    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config,SerializerProvider provider) throws IOException {
            jgen.writeString(value.name().toLowerCase());
        }
    });
    mapper.registerModule(module);
}

/**
 * Register Jackson module that maps enums as lowercase. Per http://stackoverflow.com/a/24173645.
 */
@SuppressWarnings("rawtypes")
private static void registerEnumModule(ObjectMapper mapper) {
    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config,DeserializationContext ctxt) throws IOException {
                    @SuppressWarnings("unchecked") Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass();
                    return Enum.valueOf(rawClass,SerializerProvider provider) throws IOException {
            jgen.writeString(value.name().toLowerCase());
        }
    });
    mapper.registerModule(module);
}

@Override
public void setupModule(SetupContext context) {
    context.addBeanDeserializerModifier(new BeanDeserializerModifier(){
        @Override
        public BeanDeserializerBuilder updateBuilder(DeserializationConfig config,BeanDeserializerBuilder builder) {
            //Todo: use clotho Value Instantiator (gets objects from pre-processing)
            builder.setValueInstantiator(null);
            return builder;
        }
    });
}

protected DeserializerFactoryConfig(Deserializers[] paramArrayOfDeserializers,KeyDeserializers[] paramArrayOfKeyDeserializers,BeanDeserializerModifier[] paramArrayOfBeanDeserializerModifier,AbstractTypeResolver[] paramArrayOfAbstractTypeResolver,ValueInstantiators[] paramArrayOfValueInstantiators)
{
  Deserializers[] arrayOfDeserializers;
  if (paramArrayOfDeserializers == null)
    arrayOfDeserializers = NO_DESERIALIZERS;
  else
    arrayOfDeserializers = paramArrayOfDeserializers;
  this._additionalDeserializers = arrayOfDeserializers;
  KeyDeserializers[] arrayOfKeyDeserializers;
  if (paramArrayOfKeyDeserializers == null)
    arrayOfKeyDeserializers = DEFAULT_KEY_DESERIALIZERS;
  else
    arrayOfKeyDeserializers = paramArrayOfKeyDeserializers;
  this._additionalKeyDeserializers = arrayOfKeyDeserializers;
  BeanDeserializerModifier[] arrayOfBeanDeserializerModifier;
  if (paramArrayOfBeanDeserializerModifier == null)
    arrayOfBeanDeserializerModifier = NO_MODIFIERS;
  else
    arrayOfBeanDeserializerModifier = paramArrayOfBeanDeserializerModifier;
  this._modifiers = arrayOfBeanDeserializerModifier;
  AbstractTypeResolver[] arrayOfAbstractTypeResolver;
  if (paramArrayOfAbstractTypeResolver == null)
    arrayOfAbstractTypeResolver = NO_ABSTRACT_TYPE_RESOLVERS;
  else
    arrayOfAbstractTypeResolver = paramArrayOfAbstractTypeResolver;
  this._abstractTypeResolvers = arrayOfAbstractTypeResolver;
  ValueInstantiators[] arrayOfValueInstantiators;
  if (paramArrayOfValueInstantiators == null)
    arrayOfValueInstantiators = NO_VALUE_INSTANTIATORS;
  else
    arrayOfValueInstantiators = paramArrayOfValueInstantiators;
  this._valueInstantiators = arrayOfValueInstantiators;
}

public DeserializerFactoryConfig withDeserializerModifier(BeanDeserializerModifier paramBeanDeserializerModifier)
{
  if (paramBeanDeserializerModifier == null)
    throw new IllegalArgumentException("Can not pass null modifier");
  BeanDeserializerModifier[] arrayOfBeanDeserializerModifier = (BeanDeserializerModifier[])ArrayBuilders.insertInListNoDup(this._modifiers,paramBeanDeserializerModifier);
  return new DeserializerFactoryConfig(this._additionalDeserializers,this._additionalKeyDeserializers,arrayOfBeanDeserializerModifier,this._abstractTypeResolvers,this._valueInstantiators);
}

@Override
public void setupModule(SetupContext context) {
    context.addBeanDeserializerModifier(new BeanDeserializerModifier() {

        @Override
        public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,JsonDeserializer<?> deserializer) {
            if(deserializer instanceof BeanDeserializer) {
             return new MigrationBeanDeserializer((BeanDeserializerBase) deserializer,migrationCurrentStack);
         }
         return deserializer;
        }
    });
}

@Inject
@SuppressWarnings({ "unchecked","rawtypes" })
public MergerServiceImpl() {
    JacksonXmlModule module = new JacksonXmlModule();

    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<Enum> modifyEnumDeserializer(
                DeserializationConfig config,DeserializationContext ctxt)
                        throws IOException {
                    Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass();
                    return Enum.valueOf(rawClass,new StdSerializer<Enum>(Enum.class) {
        private static final long serialVersionUID = 4951133737173200158L;

        @Override
        public void serialize(Enum value,SerializerProvider provider)
                throws IOException {
            jgen.writeString(StringUtils.capitalize(value.name().toLowerCase()));
        }
    });

    // Extra non-JAXB annotations are needed to process abstract classes.
    module.setMixInAnnotation(AbstractSourceT.class,AbstractMixIn.class);

    mapper = new XmlMapper(module);

    AnnotationIntrospector primary = new JacksonAnnotationIntrospector();
    AnnotationIntrospector secondary = new JaxbAnnotationIntrospector(mapper.getTypeFactory());

    AnnotationIntrospector pair = AnnotationIntrospectorPair.create(primary,secondary);
    mapper.setAnnotationIntrospector(pair);

    SimpleDateFormat sdf = new SimpleDateFormat(Utils.LONG_DATE_FORMAT);
    mapper.setDateFormat(sdf);

    // Serialization options
    mapper.configure(SerializationFeature.INDENT_OUTPUT,true);
    mapper.setSerializationInclusion(Include.NON_NULL);
}

public DeserializerModule(BeanDeserializerModifier deserializerModifier) {
    super("DeserializerModule",Version.unkNownVersion());
    this.deserializerModifier = deserializerModifier;
}

public void setBeanDeserializerModifiers(List<BeanDeserializerModifier> beanDeserializerModifiers) {
    this.beanDeserializerModifiers = beanDeserializerModifiers;
}

@SuppressWarnings("unchecked")
@postconstruct
private void initJsonMapper() {
    final SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<?> modifyDeserializer(final DeserializationConfig config,final JsonDeserializer<?> deserializer) {
            if (ConfiguredBean.class.isAssignableFrom(beanDesc.getBeanClass())) {
                return new ConfiguredBeanDeserializer(deserializer);
            }
            return deserializer;
        }
    });
    jsonMapper.registerModule(module);
    if (postconstructors != null) {
        for (final Beanpostconstructor<?> bpc : postconstructors) {
            mappedPostConstrucors.put(bpc.getClass(),bpc);
        }
    }

    // Register sub beans
    final ClasspathScanningCandidateComponentProvider scanner = new ClasspathScanningCandidateComponentProvider(
            false);
    final AssignableTypeFilter filter4configBenas = new AssignableTypeFilter(ConfiguredBean.class);
    scanner.addIncludeFilter(filter4configBenas);

    for (final BeanDeFinition bd : scanner.findCandidateComponents("com.logsniffer")) {
        try {
            final Class<? extends ConfiguredBean> clazz = (Class<? extends ConfiguredBean>) Class
                    .forName(bd.getBeanClassName());
            final JsonTypeName jsonNameAnnotation = clazz.getAnnotation(JsonTypeName.class);
            final List<String> names = new ArrayList<String>();
            configBeanNames.put(clazz,names);
            if (jsonNameAnnotation != null) {
                names.add(jsonNameAnnotation.value());
                if (jsonNameAnnotation.deprecated() != null) {
                    for (final String dep : jsonNameAnnotation.deprecated()) {
                        names.add(dep);
                    }
                }
            }
            names.add(clazz.getSimpleName());
            logger.debug("Registered JSON type {} for following names: {}",clazz,names);
        } catch (final ClassNotFoundException e) {
            logger.warn("Failed to register JSON type name for " + bd.getBeanClassName(),e);
        }
    }
}

public Iterable<BeanDeserializerModifier> deserializerModifiers()
{
  return ArrayBuilders.arrayAsIterable(this._modifiers);
}

public SimpleModule setDeserializerModifier(BeanDeserializerModifier paramBeanDeserializerModifier)
{
  this._deserializerModifier = paramBeanDeserializerModifier;
  return this;
}

/**
 * Method that module can use to register additional modifier objects to
 * customize configuration and construction of bean deserializers.
 * 
 * @param mod Modifier to register
 */
public void addBeanDeserializerModifier(BeanDeserializerModifier mod);

public abstract void addBeanDeserializerModifier(BeanDeserializerModifier paramBeanDeserializerModifier);

public EntityDeserializer(
        Class<? extends AbstractEntity> entityClass,BeanDeserializer defaultDeserializer,Dao generalDao) {
    super(defaultDeserializer);

    this.entityClass = entityClass;
    this.defaultDeserializer = defaultDeserializer;
    this.generalDao = generalDao;
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,BeanDescription beanDesc,JsonDeserializer<?> deserializer) {
    if (deserializer instanceof BeanDeserializer) {
        BeanDeserializer beanDeserializer = (BeanDeserializer) deserializer;
        return new EntityBeanDeserializer(beanDeserializer,deserializer.getobjectIdReader());
    }
    return super.modifyDeserializer(config,beanDesc,deserializer);
}

@Override
public void setupModule(SetupContext context) {
    context.addBeanDeserializerModifier(new BeanDeserializerModifier() {

        @Override
        public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,JsonDeserializer<?> deserializer) {
            if(deserializer instanceof BeanDeserializer) {
             return new MigrationBeanDeserializer((BeanDeserializerBase) deserializer,migrationCurrentStack);
         }
         return deserializer;
        }
    });
}

public ThrowableDeserializer(BeanDeserializer paramBeanDeserializer)
{
  super(paramBeanDeserializer);
  this._vanillaProcessing = false;
}

protected ThrowableDeserializer(BeanDeserializer paramBeanDeserializer,NameTransformer paramNameTransformer)
{
  super(paramBeanDeserializer,paramNameTransformer);
}

public ExtensibleObjectDeserializer(BeanDeserializer src) {
  super(src);
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,JsonDeserializer<?> deserializer) {
  return deserializer instanceof BeanDeserializer ? new ExtensibleObjectDeserializer((BeanDeserializer) deserializer) : deserializer;
}

public ThrowableDeserializer(BeanDeserializer baseDeserializer)
{
    super(baseDeserializer);
    // need to disable this,since we do post-processing
    _vanillaProcessing = false;
}

/**
 * Alternative constructor used when creating "unwrapping" deserializers
 */
protected ThrowableDeserializer(BeanDeserializer src,NameTransformer unwrapper)
{
    super(src,unwrapper);
}

@Override
public BeanSerializerBuilder updateBuilder(SerializationConfig config,BeanDescription beanDesc,BeanSerializerBuilder builder) {

    for (BeanPropertyWriter writer : builder.getProperties()) {

        JavaType propertyType = writer.getMember().getType();
        Class<?> type = propertyType.getRawClass();
        List<BeanPropertyDeFinition> properties = getProperties(propertyType,config);

        Optional.ofNullable(AnnotationUtils.findAnnotation(type,ValueObject.class))//
                .filter(it -> properties.size() == 1)//
                .flatMap(it -> properties.stream().findFirst())//
                .ifPresent(it -> writer.assignSerializer(new PropertyAccessingSerializer(it)));
    }

    return builder;
}

public BeanSerializerBase(JavaType paramJavaType,BeanSerializerBuilder paramBeanSerializerBuilder,BeanPropertyWriter[] paramArrayOfBeanPropertyWriter1,BeanPropertyWriter[] paramArrayOfBeanPropertyWriter2)
{
  super(paramJavaType);
  this._props = paramArrayOfBeanPropertyWriter1;
  this._filteredProps = paramArrayOfBeanPropertyWriter2;
  BeanSerializerBase localBeanSerializerBase;
  JsonFormat.Shape localShape;
  if (paramBeanSerializerBuilder == null)
  {
    this._typeId = null;
    this._anyGetterWriter = null;
    this._propertyFilterId = null;
    this._objectIdWriter = null;
    localBeanSerializerBase = this;
    localShape = null;
  }
  else
  {
    this._typeId = paramBeanSerializerBuilder.getTypeId();
    this._anyGetterWriter = paramBeanSerializerBuilder.getAnyGetter();
    this._propertyFilterId = paramBeanSerializerBuilder.getFilterId();
    this._objectIdWriter = paramBeanSerializerBuilder.getobjectIdWriter();
    JsonFormat.Value localValue = paramBeanSerializerBuilder.getBeanDescription().findExpectedFormat(null);
    localBeanSerializerBase = this;
    if (localValue == null)
      localShape = null;
    else
      localShape = localValue.getShape();
  }
  localBeanSerializerBase._serializationShape = localShape;
}

public ModelSerializer(JavaType type,BeanSerializerBuilder builder,BeanPropertyWriter[] properties,BeanPropertyWriter[] filteredProperties) {
    super(type,builder,properties,filteredProperties);
}

@Override
public BeanSerializerBuilder updateBuilder(SerializationConfig config,BeanDescription desc,BeanSerializerBuilder serializerBuilder) {
    return (this.canModify(desc) ? this.updateBuilderInternal(config,desc,serializerBuilder) : super.updateBuilder(config,serializerBuilder));
}

protected BeanSerializerBuilder updateBuilderInternal(SerializationConfig config,BeanSerializerBuilder serializerBuilder) {
    return super.updateBuilder(config,serializerBuilder);
}