Patch for FlatBuffersTest for ivm-serialisers

FlatBuffers.java

package serializers.flatbuffers;

import com.google.flatbuffers.FlatBufferBuilder;

import data.media.MediaTransformer;
import serializers.*;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import serializers.flatbuffers.media.*;

public class FlatBuffers {
	static ByteBuffer bb = ByteBuffer.allocate(1024);
	static FlatBufferBuilder fbb;
    public static void register(TestGroups groups) {
    	if(fbb == null){
        	fbb = new FlatBufferBuilder(bb);
        }
        groups.media.add(new Transformer(), new FBSerializer(),
                new SerFeatures(
                        SerFormat.BIN_CROSSLANG,
                        SerGraph.FULL_GRAPH,
                        SerClass.CLASSES_KNOWN,
                        ""
                )
        );
    }

    static final class FBSerializer extends Serializer<MediaContent> {
	    

        public String getName() { return "flatbuffers"; }
        
        MediaContent mc = new MediaContent();
        @Override
        public MediaContent deserialize (byte[] array) throws Exception {
	        ByteBuffer bb = ByteBuffer.wrap(array);
            MediaContent.getRootAsMediaContent(bb, mc);
	        return mc;
        }
        
        int i = 0;
        @Override
        public byte[] serialize(MediaContent content) {
//        	fbb.init(bb);
//	        content.finishMediaContentBuffer(fbb, offset);
//        	return new byte[0];
        	byte[] result = fbb.sizedByteArray();
        	if (i == 0){
        		i++;
        		System.err.println("Size: " + result.length);
        	}
	        return result;
        }
        
        private static void forward(MediaContent mc, FlatBufferBuilder fbb) {
			int media = forwardMedia(mc.media(), fbb);
			int images[] = new int[mc.imagesLength()];
			for (int i = 0; i < mc.imagesLength(); i++) {
				images[i] = forwardImage(mc.images(i), fbb);
			}
			int image = MediaContent.createImagesVector(fbb, images);
			int offset = MediaContent.createMediaContent(fbb, image, media);
			MediaContent.finishMediaContentBuffer(fbb, offset);
		}

		private static int forwardMedia(Media media, FlatBufferBuilder fbb) {
			int uri = fbb.createString(media.uri());
			String titleS = media.title();
			int title = titleS != null ? fbb.createString(titleS) : 0;
			int format = fbb.createString(media.format());
			int[] persons = new int[media.personsLength()];
			for (int i = 0; i < media.personsLength(); i++) {
				persons[i] = fbb.createString(media.persons(i));
			}
			int person = Media.createPersonsVector(fbb, persons);
			byte player = media.player();
			String copyrightS = media.copyright();
			int copyright = copyrightS != null ? fbb.createString(copyrightS) : 0;
			return Media.createMedia(
					fbb,
					uri,
					title,
					media.width(),
					media.height(),
					format,
					media.duration(),
					media.size(),
					media.bitrate(),
					person,
					player,
					copyright);
		}

		private static int forwardImage(Image image, FlatBufferBuilder fbb) {
			int uri = fbb.createString(image.uri());
			String titleS = image.title();
			int title = titleS != null ? fbb.createString(titleS) : 0;
			byte size = image.size();
			return Image.createImage(fbb, uri, title, image.width(), image.height(), size);
		}
    }
    
    static final class Transformer extends MediaTransformer<MediaContent> {
    	
    	private MediaContent mc = new MediaContent();
    	private static Map<String,Integer> stringLookup = new HashMap<String, Integer>(); 
    	@Override
		public MediaContent forward(data.media.MediaContent a) {
    		stringLookup.clear();
    		fbb.init(bb);
    		int media = forwardMedia(a.media, fbb);
			int images[] = new int[a.images.size()];
			for (int i = 0; i < a.images.size(); i++) {
				images[i] = forwardImage(a.images.get(i), fbb);
			}
			int image = MediaContent.createImagesVector(fbb, images);
			int offset = MediaContent.createMediaContent(fbb, image, media);
			MediaContent.finishMediaContentBuffer(fbb, offset);
			return MediaContent.getRootAsMediaContent(bb, mc);
		}
    	
    	private static int forwardMedia(data.media.Media media, FlatBufferBuilder fbb) {
//			int uri = fbb.createString(media.uri);
    		int uri = putString(media.uri, fbb);
//			String titleS = media.title;
//			int title = titleS != null ? fbb.createString(titleS) : 0;
			int title = putString(media.title, fbb);
//			int format = fbb.createString(media.format);
			int format = putString(media.format, fbb);
			int[] persons = new int[media.persons.size()];
			for (int i = 0; i < media.persons.size(); i++) {
//				persons[i] = fbb.createString(media.persons.get(i));
				persons[i] = putString(media.persons.get(i), fbb);
			}
			int person = Media.createPersonsVector(fbb, persons);
			byte player = forwardPlayer(media.player);
//			String copyrightS = media.copyright;
//			int copyright = copyrightS != null ? fbb.createString(copyrightS) : 0;
			int copyright = putString(media.copyright, fbb);
			return Media.createMedia(
					fbb,
					uri,
					title,
					media.width,
					media.height,
					format,
					media.duration,
					media.size,
					media.bitrate,
					person,
					player,
					copyright);
		}
    	
    	private static int putString(String value, FlatBufferBuilder fbb){
    		if(value == null){
    			return 0;
    		}
    		Integer result = stringLookup.get(value);
    		if (result != null){
    			return result.intValue();
    		}
    		int offset = fbb.createString(value);
    		stringLookup.put(value, Integer.valueOf(offset));
    		return offset;
    	}

		private static int forwardImage(data.media.Image image, FlatBufferBuilder fbb) {
//			int uri = fbb.createString(image.uri);
			int uri = putString(image.uri, fbb);
//			String titleS = image.title;
//			int title = titleS != null ? fbb.createString(titleS) : 0;
			int title = putString(image.title, fbb);
			byte size = forwardSize(image.size);
			return Image.createImage(fbb, uri, title, image.width, image.height, size);
		}
		
		private static byte forwardPlayer(data.media.Media.Player p) {
			switch (p) {
				case JAVA: return Player.JAVA;
				case FLASH: return Player.FLASH;
				default:
					throw new AssertionError("invalid case: " + p);
			}
		}
		
		private static byte forwardSize(data.media.Image.Size s) {
			switch (s) {
				case SMALL: return Size.SMALL;
				case LARGE: return Size.LARGE;
				default:
					throw new AssertionError("invalid case: " + s);
			}
		}

		
		private Image image = new Image();
		@Override
		public data.media.MediaContent reverse(MediaContent a) {
			List<data.media.Image> images = new ArrayList<data.media.Image>(a.imagesLength());
			for (int i = 0; i < a.imagesLength(); i++) {
				images.add(reverseImage(a.images(image,i)));
			}
			return new data.media.MediaContent(reverseMedia(a.media()), images);
		}

		@Override
		public data.media.MediaContent shallowReverse(MediaContent a) {
			return new data.media.MediaContent(reverseMedia(a.media()), Collections.<data.media.Image>emptyList());
		}

		private static data.media.Media reverseMedia(Media media) {
			return new data.media.Media(
				media.uri(),
				media.title(),
				media.width(),
				media.height(),
				media.format(),
				media.duration(),
				media.size(),
				media.bitrate(),
				media.bitrate() != 0,
				reversePersons(media),
				reversePlayer(media.player()),
				media.copyright()
			);
		}

		private static data.media.Media.Player reversePlayer(byte p) {
			switch (p) {
				case Player.JAVA:  return data.media.Media.Player.JAVA;
				case Player.FLASH: return data.media.Media.Player.FLASH;
				default:
					throw new AssertionError("invalid case: " + p);
			}
		}
		
	    private static List<String> reversePersons(Media media) {
		    List<String> result = new ArrayList<>(media.personsLength());
		    for(int i = 0; i < media.personsLength(); i++) {
			    result.add(media.persons(i));
		    }
		    return result;
	    }

		private static data.media.Image reverseImage(Image image) {
			return new data.media.Image(
				image.uri(),
				image.title(),
				image.width(),
				image.height(),
				reverseSize(image.size()));
		}

		private static data.media.Image.Size reverseSize(byte s) {
			switch (s) {
				case Size.SMALL: return data.media.Image.Size.SMALL;
				case Size.LARGE: return data.media.Image.Size.LARGE;
				default:
					throw new AssertionError("invalid case: " + s);
			}
		}
    }
}