serializers/protobuf/src/main/java/org/apache/directmemory/serialization/protobuf/ProtobufSerializer.java

package org.apache.directmemory.serialization.protobuf;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import static java.lang.String.format;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;

import org.apache.directmemory.serialization.Serializer;

import com.google.protobuf.GeneratedMessage;
import com.google.protobuf.Message;

public final class ProtobufSerializer
    implements Serializer
{

    private static final String NEW_BUILDER_METHOD = "newBuilder";

    /**
     * {@inheritDoc}
     */
    @Override
    public <T> byte[] serialize( T obj )
        throws IOException
    {
        checkProtobufMessage( obj.getClass() );

        final ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try
        {
            ( (Message) obj ).writeTo( baos );
        }
        finally
        {
            try
            {
                baos.close();
            }
            catch ( Exception e )
            {
                // close quietly
            }
        }

        return baos.toByteArray();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public <T> T deserialize( byte[] source, Class<T> clazz )
        throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException
    {
        clazz = checkProtobufMessage( clazz );

        try
        {
            Method newBuilder = clazz.getMethod( NEW_BUILDER_METHOD );

            // fixme no idea ATM how to fix type inference here
            GeneratedMessage.Builder builder = (GeneratedMessage.Builder) newBuilder.invoke( clazz );

            @SuppressWarnings( "unchecked" ) // cast should be safe since it is driven by the type
            T deserialized = (T) builder.mergeFrom( source ).build();

            return deserialized;
        }
        catch ( Throwable t )
        {
            throw new IOException( t );
        }
    }

    private static <T> Class<T> checkProtobufMessage( Class<T> clazz )
    {
        if ( !Message.class.isAssignableFrom( clazz ) )
        {
            throw new IllegalArgumentException( format( "Class %s cannot be serialized via Google Protobuf, it is not a %s",
                                                        clazz.getName(),
                                                        Message.class.getName() ) );
        }
        return clazz;
    }

}