Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  //================================================================================
  //Copyright (c) 2012, David Yu
  //All rights reserved.
  //--------------------------------------------------------------------------------
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are met:
  // 1. Redistributions of source code must retain the above copyright notice,
  //    this list of conditions and the following disclaimer.
  // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 // 3. Neither the name of protostuff nor the names of its contributors may be used
 //    to endorse or promote products derived from this software without
 //    specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // POSSIBILITY OF SUCH DAMAGE.
 //================================================================================
 
 package io.protostuff.runtime;
 
 import static io.protostuff.runtime.RuntimeFieldFactory.ID_THROWABLE;
 import static io.protostuff.runtime.RuntimeFieldFactory.STR_THROWABLE;
 
 
Used when the type is assignable from java.lang.Throwable.

Author(s):
David Yu
Created:
May 2, 2012
 
 public abstract class PolymorphicThrowableSchema extends PolymorphicSchema
 {
 
     static final java.lang.reflect.Field __cause;
 
     static
     {
         java.lang.reflect.Field cause;
         try
         {
             cause = Throwable.class.getDeclaredField("cause");
             cause.setAccessible(true);
         }
         catch (Exception e)
         {
             cause = null;
         }
          = cause;
     }
 
     static String name(int number)
     {
         return number ==  ?  : null;
     }
 
     static int number(String name)
     {
         return name.length() == 1 && name.charAt(0) == 'Z' ?  : 0;
     }
 
     protected final Pipe.Schema<ObjectpipeSchema = new Pipe.Schema<Object>(
             this)
     {
         @Override
         protected void transfer(Pipe pipeInput inputOutput output)
                 throws IOException
         {
             transferObject(thispipeinputoutput);
         }
     };
 
     public PolymorphicThrowableSchema(IdStrategy strategy)
     {
         super(strategy);
     }
 
     @Override
     public Pipe.Schema<ObjectgetPipeSchema()
     {
         return ;
    }
    @Override
    public String getFieldName(int number)
    {
        return name(number);
    }
    @Override
    public int getFieldNumber(String name)
    {
        return number(name);
    }
    @Override
    public String messageFullName()
    {
        return Throwable.class.getName();
    }
    @Override
    public String messageName()
    {
        return Throwable.class.getSimpleName();
    }
    @Override
    public void mergeFrom(Input inputObject ownerthrows IOException
    {
        setValue(readObjectFrom(inputthisowner), owner);
    }
    @Override
    public void writeTo(Output outputObject valuethrows IOException
    {
        writeObjectTo(outputvaluethis);
    }
    @SuppressWarnings("unchecked")
    static void writeObjectTo(Output outputObject value,
            Schema<?> currentSchemaIdStrategy strategythrows IOException
    {
        final Schema<Objectschema = strategy.writePojoIdTo(output,
                , (Class<Object>) value.getClass()).getSchema();
        if (output instanceof StatefulOutput)
        {
            // update using the derived schema.
            ((StatefulOutputoutput).updateLast(schemacurrentSchema);
        }
        if (tryWriteWithoutCause(outputvalueschema))
            return;
        schema.writeTo(outputvalue);
    }
    static boolean tryWriteWithoutCause(Output outputObject value,
            Schema<Objectschemathrows IOException
    {
        if (schema instanceof RuntimeSchema &&  != null)
        {
            // ignore the field "cause" if its references itself (cyclic)
            final RuntimeSchema<Objectms = (RuntimeSchema<Object>) schema;
            if (ms.getFieldCount() > 1 && ms.getFields().get(1)..equals("cause"))
            {
                final Object cause;
                try
                {
                    cause = .get(value);
                }
                catch (IllegalArgumentException | IllegalAccessException e)
                {
                    throw new RuntimeException(e);
                }
                if (cause == value)
                {
                    // its cyclic, skip the second field "cause"
                    ms.getFields().get(0).writeTo(outputvalue);
                    for (int i = 2, len = ms.getFieldCount(); i < leni++)
                        ms.getFields().get(i).writeTo(outputvalue);
                    return true;
                }
            }
        }
        return false;
    }
    static Object readObjectFrom(Input inputSchema<?> schemaObject owner,
            IdStrategy strategythrows IOException
    {
        final int number = input.readFieldNumber(schema);
        if (number != )
            throw new ProtostuffException("Corrupt input.");
        return readObjectFrom(inputschemaownerstrategynumber);
    }
    static Object readObjectFrom(Input inputSchema<?> schemaObject owner,
            IdStrategy strategyint numberthrows IOException
    {
        final Schema<ObjectderivedSchema = strategy.resolvePojoFrom(input,
                number).getSchema();
        final Object pojo = derivedSchema.newMessage();
        if (input instanceof GraphInput)
        {
            // update the actual reference.
            ((GraphInputinput).updateLast(pojoowner);
        }
        if ( != null)
        {
            final Object cause;
            try
            {
                cause = .get(pojo);
            }
            catch (IllegalArgumentException | IllegalAccessException e)
            {
                throw new RuntimeException(e);
            }
            if (cause == null)
            {
                // was not written because it was cyclic
                // so we set it here manually for correctness
                try
                {
                    .set(pojocause);
                }
                catch (IllegalArgumentException | IllegalAccessException e)
                {
                    throw new RuntimeException(e);
                }
            }
        }
        derivedSchema.mergeFrom(inputpojo);
        return pojo;
    }
    static void transferObject(Pipe.Schema<ObjectpipeSchemaPipe pipe,
            Input inputOutput outputIdStrategy strategythrows IOException
    {
        final int number = input.readFieldNumber(pipeSchema.wrappedSchema);
        if (number != )
            throw new ProtostuffException("Corrupt input.");
        transferObject(pipeSchemapipeinputoutputstrategynumber);
    }
    static void transferObject(Pipe.Schema<ObjectpipeSchemaPipe pipe,
            Input inputOutput outputIdStrategy strategyint number)
            throws IOException
    {
        final Pipe.Schema<ObjectderivedPipeSchema = strategy.transferPojoId(
                inputoutputnumber).getPipeSchema();
        if (output instanceof StatefulOutput)
        {
            // update using the derived schema.
            ((StatefulOutputoutput).updateLast(derivedPipeSchemapipeSchema);
        }
        Pipe.transferDirect(derivedPipeSchemapipeinputoutput);
    }
New to GrepCode? Check out our FAQ X