com.larswerkman.boxer.wrappers.android.ParcelWrapper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of boxer Show documentation
Show all versions of boxer Show documentation
Annotation based serialization for java and Android
/*
* Copyright 2014 Lars Werkman
*
* Licensed 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.
*/
package com.larswerkman.boxer.wrappers.android;
import android.os.Bundle;
import android.os.Parcel;
import com.larswerkman.boxer.Boxable;
import com.larswerkman.boxer.Boxer;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.List;
/**
*
* ParcelWrapper defines how the Boxer class should write to a {@link android.os.Parcel}
*
* ParcelWrapper should only be used when you don't
* change the order you read and write to it.
*/
public class ParcelWrapper extends Boxer {
Parcel parcel;
public ParcelWrapper(Parcel object){
super(object);
parcel = object;
}
@Override
public void add(String key, Object value) {
this.parcel.writeBundle(serialize(new BundleWrapper(new Bundle()), value));
}
@Override
public void addArray(String key, Object[] value) {
this.parcel.writeInt(value.length);
for(Object boxable : value) {
this.parcel.writeBundle(serialize(new BundleWrapper(new Bundle()), boxable));
}
}
@Override
public void addList(String key, List value) {
addArray(key, value.toArray());
}
@Override
public void addBoxable(String key, T value) {
this.parcel.writeBundle(serializeBoxable(new BundleWrapper(new Bundle()), value));
}
@Override
public void addBoxableArray(String key, T[] value) {
this.parcel.writeInt(value.length);
for(T boxable : value) {
this.parcel.writeBundle(serializeBoxable(new BundleWrapper(new Bundle()), boxable));
}
}
@Override
public void addBoxableList(String key, List value) {
this.parcel.writeInt(value.size());
for(T boxable : value) {
this.parcel.writeBundle(serializeBoxable(new BundleWrapper(new Bundle()), boxable));
}
}
@Override
public void addEnum(String key, Enum value) {
this.parcel.writeString(value.name());
}
@Override
public void addEnumArray(String key, Enum[] value) {
String[] strings = new String[value.length];
for(int i = 0; i < value.length; i++){
strings[i] = value[i].name();
}
this.parcel.writeStringArray(strings);
}
@Override
public void addEnumList(String key, List value) {
String[] strings = new String[value.size()];
for(int i = 0; i < value.size(); i++){
strings[i] = value.get(i).name();
}
this.parcel.writeStringArray(strings);
}
@Override
public void addString(String key, String value) {
this.parcel.writeString(value);
}
@Override
public void addStringArray(String key, String[] value) {
this.parcel.writeStringArray(value);
}
@Override
public void addStringList(String key, List value) {
this.parcel.writeStringList(value);
}
@Override
public void addBoolean(String key, boolean value) {
this.parcel.writeByte(value ? Byte.MAX_VALUE : Byte.MIN_VALUE);
}
@Override
public void addBooleanArray(String key, boolean[] value) {
this.parcel.writeBooleanArray(value);
}
@Override
public void addBooleanList(String key, List value) {
boolean[] bools = new boolean[value.size()];
for(int i = 0; i < value.size(); i++){
bools[i] = value.get(i);
}
this.parcel.writeBooleanArray(bools);
}
@Override
public void addByte(String key, byte value) {
this.parcel.writeByte(value);
}
@Override
public void addByteArray(String key, byte[] value) {
this.parcel.writeByteArray(value);
}
@Override
public void addByteList(String key, List value) {
byte[] bytes = new byte[value.size()];
for(int i = 0; i < value.size(); i++){
bytes[i] = value.get(i);
}
this.parcel.writeByteArray(bytes);
}
@Override
public void addChar(String key, char value) {
this.parcel.writeString(String.valueOf(value));
}
@Override
public void addCharArray(String key, char[] value) {
this.parcel.writeCharArray(value);
}
@Override
public void addCharList(String key, List value) {
char[] chars = new char[value.size()];
for(int i = 0; i < value.size(); i++){
chars[i] = value.get(i);
}
this.parcel.writeCharArray(chars);
}
@Override
public void addShort(String key, short value) {
this.parcel.writeInt((int) value);
}
@Override
public void addShortArray(String key, short[] value) {
int[] shorts = new int[value.length];
for(int i = 0; i < value.length; i++){
shorts[i] = (int) value[i];
}
this.parcel.writeIntArray(shorts);
}
@Override
public void addShortList(String key, List value) {
int[] shorts = new int[value.size()];
for(int i = 0; i < value.size(); i++){
shorts[i] = (int) value.get(i);
}
this.parcel.writeIntArray(shorts);
}
@Override
public void addInt(String key, int value) {
this.parcel.writeInt(value);
}
@Override
public void addIntArray(String key, int[] value) {
this.parcel.writeIntArray(value);
}
@Override
public void addIntList(String key, List value) {
int[] ints = new int[value.size()];
for(int i = 0; i < value.size(); i++){
ints[i] = value.get(i);
}
this.parcel.writeIntArray(ints);
}
@Override
public void addLong(String key, long value) {
this.parcel.writeLong(value);
}
@Override
public void addLongArray(String key, long[] value) {
this.parcel.writeLongArray(value);
}
@Override
public void addLongList(String key, List value) {
long[] longs = new long[value.size()];
for(int i = 0; i < value.size(); i++){
longs[i] = value.get(i);
}
this.parcel.writeLongArray(longs);
}
@Override
public void addDouble(String key, double value) {
this.parcel.writeDouble(value);
}
@Override
public void addDoubleArray(String key, double[] value) {
this.parcel.writeDoubleArray(value);
}
@Override
public void addDoubleList(String key, List value) {
double[] doubles = new double[value.size()];
for(int i = 0; i < value.size(); i++){
doubles[i] = value.get(i);
}
this.parcel.writeDoubleArray(doubles);
}
@Override
public void addFloat(String key, float value) {
this.parcel.writeFloat(value);
}
@Override
public void addFloatArray(String key, float[] value) {
this.parcel.writeFloatArray(value);
}
@Override
public void addFloatList(String key, List value) {
float[] floats = new float[value.size()];
for(int i = 0; i < value.size(); i++){
floats[i] = value.get(i);
}
this.parcel.writeFloatArray(floats);
}
@Override
public T get(String key, Class clazz) {
Bundle bundle = this.parcel.readBundle();
if(bundle == null || bundle.isEmpty()){
return null;
}
return deserialize(new BundleWrapper(bundle), clazz);
}
@Override
public T[] getArray(String key, Class clazz) {
int size = this.parcel.readInt();
if(size == 0){
return null;
}
T[] boxables = (T[]) Array.newInstance(clazz, size);
for(int i = 0; i < size; i++){
boxables[i] = deserialize(new BundleWrapper(this.parcel.readBundle()), clazz);
}
return boxables;
}
@Override
public > E getList(String key, Class clazz, Class listtype) {
int size = this.parcel.readInt();
if(size == 0){
return null;
}
E boxables = null;
try {
boxables = listtype.newInstance();
for (int i = 0; i < size; i++) {
boxables.add(deserialize(new BundleWrapper(this.parcel.readBundle()), clazz));
}
} catch (Exception e){};
return boxables;
}
@Override
public T getBoxable(String key, Class clazz) {
Bundle bundle = this.parcel.readBundle();
if(bundle.isEmpty()){
return null;
}
return deserializeBoxable(new BundleWrapper(bundle), clazz);
}
@Override
public T[] getBoxableArray(String key, Class clazz) {
int size = this.parcel.readInt();
if(size == 0){
return null;
}
T[] boxables = (T[]) Array.newInstance(clazz, size);
for(int i = 0; i < size; i++){
boxables[i] = deserializeBoxable(new BundleWrapper(this.parcel.readBundle()), clazz);
}
return boxables;
}
@Override
public > E getBoxableList(String key, Class clazz, Class listtype) {
int size = this.parcel.readInt();
if(size == 0){
return null;
}
E boxables = null;
try {
boxables = listtype.newInstance();
for (int i = 0; i < size; i++) {
boxables.add(deserializeBoxable(new BundleWrapper(this.parcel.readBundle()), clazz));
}
} catch (Exception e){};
return boxables;
}
public T retrieveEnum(String value, Class clazz){
T en = null;
try{
Method method = clazz.getMethod("valueOf", String.class);
en = (T) method.invoke(null, value);
} catch (Exception e){}
return en;
}
@Override
public T getEnum(String key, Class clazz) {
return retrieveEnum(this.parcel.readString(), clazz);
}
@Override
public T[] getEnumArray(String key, Class clazz) {
String[] values = this.parcel.createStringArray();
if(values.length == 0){
return null;
}
T[] enums = (T[]) Array.newInstance(clazz, values.length);
for(int i = 0; i < values.length; i++){
enums[i] = retrieveEnum(values[i], clazz);
}
return enums;
}
@Override
public > E getEnumList(String key, Class clazz, Class listtype) {
String[] values = this.parcel.createStringArray();
if(values.length == 0){
return null;
}
E enums = null;
try {
enums = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
enums.add(retrieveEnum(values[i], clazz));
}
} catch (Exception e){};
return enums;
}
@Override
public String getString(String key) {
return this.parcel.readString();
}
@Override
public String[] getStringArray(String key) {
String[] values = this.parcel.createStringArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getStringList(String key, Class listtype) {
T list = null;
try {
list = listtype.newInstance();
} catch (Exception e){}
this.parcel.readStringList(list);
if(list == null || list.size() == 0){
return null;
}
return list;
}
@Override
public boolean getBoolean(String key) {
byte bytes = parcel.readByte();
return bytes > Byte.MIN_VALUE && bytes != 0;
}
@Override
public boolean[] getBooleanArray(String key) {
boolean[] values = this.parcel.createBooleanArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getBooleanList(String key, Class listtype) {
boolean[] values = this.parcel.createBooleanArray();
if(values.length == 0){
return null;
}
T booleans = null;
try {
booleans = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
booleans.add(values[i]);
}
} catch (Exception e){};
return booleans;
}
@Override
public byte getByte(String key) {
return this.parcel.readByte();
}
@Override
public byte[] getByteArray(String key) {
byte[] values = this.parcel.createByteArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getByteList(String key, Class listtype) {
byte[] values = this.parcel.createByteArray();
if(values.length == 0){
return null;
}
T bytes = null;
try {
bytes = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
bytes.add(values[i]);
}
} catch (Exception e){};
return bytes;
}
@Override
public char getChar(String key) {
String value = this.parcel.readString();
if(value == null){
return 0;
}
return value.charAt(0);
}
@Override
public char[] getCharArray(String key) {
char[] values = this.parcel.createCharArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getCharList(String key, Class listtype) {
char[] values = this.parcel.createCharArray();
if(values.length == 0){
return null;
}
T chars = null;
try {
chars = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
chars.add(values[i]);
}
} catch (Exception e){};
return chars;
}
@Override
public short getShort(String key) {
return (short) this.parcel.readInt();
}
@Override
public short[] getShortArray(String key) {
int[] values = this.parcel.createIntArray();
if(values.length == 0){
return null;
}
short[] shorts = new short[values.length];
for(int i = 0; i < values.length; i++){
shorts[i] = (short) values[i];
}
return shorts;
}
@Override
public > T getShortList(String key, Class listtype) {
int[] values = this.parcel.createIntArray();
if(values.length == 0){
return null;
}
T shorts = null;
try {
shorts = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
shorts.add((short) values[i]);
}
} catch (Exception e){};
return shorts;
}
@Override
public int getInt(String key) {
return this.parcel.readInt();
}
@Override
public int[] getIntArray(String key) {
int[] values = this.parcel.createIntArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getIntList(String key, Class listtype) {
int[] values = this.parcel.createIntArray();
if(values.length == 0){
return null;
}
T ints = null;
try {
ints = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
ints.add(values[i]);
}
} catch (Exception e){};
return ints;
}
@Override
public long getLong(String key) {
return this.parcel.readLong();
}
@Override
public long[] getLongArray(String key) {
long[] values = this.parcel.createLongArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getLongList(String key, Class listtype) {
long[] values = this.parcel.createLongArray();
if(values.length == 0){
return null;
}
T longs = null;
try {
longs = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
longs.add(values[i]);
}
} catch (Exception e){};
return longs;
}
@Override
public double getDouble(String key) {
return this.parcel.readDouble();
}
@Override
public double[] getDoubleArray(String key) {
double[] values = this.parcel.createDoubleArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getDoubleList(String key, Class listtype) {
double[] values = this.parcel.createDoubleArray();
if(values.length == 0){
return null;
}
T doubles = null;
try {
doubles = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
doubles.add(values[i]);
}
} catch (Exception e){};
return doubles;
}
@Override
public float getFloat(String key) {
return this.parcel.readFloat();
}
@Override
public float[] getFloatArray(String key) {
float[] values = this.parcel.createFloatArray();
if(values.length == 0){
return null;
}
return values;
}
@Override
public > T getFloatList(String key, Class listtype) {
float[] values = this.parcel.createFloatArray();
if(values.length == 0){
return null;
}
T floats = null;
try {
floats = listtype.newInstance();
for (int i = 0; i < values.length; i++) {
floats.add(values[i]);
}
} catch (Exception e){};
return floats;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy