/**

public static String __doc__ =

"Java implementation and optimization of the Python pickle module\n";

/**

public static String __version__ = "1.30";

/**

public static final String format_version = "2.0";

/**

public static final String[] compatible_formats =

new String[] { "1.0", "1.1", "1.2", "1.3", "2.0" };

/**

public static final int HIGHEST_PROTOCOL = 2;

public static String[] __depends__ = new String[] {

"copy_reg",

};

public static PyObject PickleError;

public static PyObject PicklingError;

public static PyObject UnpickleableError;

public static PyObject UnpicklingError;

public static PyObject BadPickleGet;

final static char MARK = '(';

final static char STOP = '.';

final static char POP = '0';

final static char POP_MARK = '1';

final static char DUP = '2';

final static char FLOAT = 'F';

final static char INT = 'I';

final static char BININT = 'J';

final static char BININT1 = 'K';

final static char LONG = 'L';

final static char BININT2 = 'M';

final static char NONE = 'N';

final static char PERSID = 'P';

final static char BINPERSID = 'Q';

final static char REDUCE = 'R';

final static char STRING = 'S';

final static char BINSTRING = 'T';

final static char SHORT_BINSTRING = 'U';

final static char UNICODE = 'V';

final static char BINUNICODE = 'X';

final static char APPEND = 'a';

final static char BUILD = 'b';

final static char GLOBAL = 'c';

final static char DICT = 'd';

final static char EMPTY_DICT = '}';

final static char APPENDS = 'e';

final static char GET = 'g';

final static char BINGET = 'h';

final static char INST = 'i';

final static char LONG_BINGET = 'j';

final static char LIST = 'l';

final static char EMPTY_LIST = ']';

final static char OBJ = 'o';

final static char PUT = 'p';

final static char BINPUT = 'q';

final static char LONG_BINPUT = 'r';

final static char SETITEM = 's';

final static char TUPLE = 't';

final static char EMPTY_TUPLE = ')';

final static char SETITEMS = 'u';

final static char BINFLOAT = 'G';

final static char PROTO = 0x80;

final static char NEWOBJ = 0x81;

final static char EXT1 = 0x82;

final static char EXT2 = 0x83;

final static char EXT4 = 0x84;

final static char TUPLE1 = 0x85;

final static char TUPLE2 = 0x86;

final static char TUPLE3 = 0x87;

final static char NEWTRUE = 0x88;

final static char NEWFALSE = 0x89;

final static char LONG1 = 0x8A;

final static char LONG4 = 0x8B;

private static PyDictionary dispatch_table;

private static PyDictionary extension_registry;

private static PyDictionary inverted_registry;

private static PyType BuiltinCallableType = PyType.fromClass(PyBuiltinCallable.class);

private static PyType ReflectedFunctionType = PyType.fromClass(PyReflectedFunction.class);

private static PyType ClassType = PyType.fromClass(PyClass.class);

private static PyType TypeType = PyType.fromClass(PyType.class);

private static PyType DictionaryType = PyType.fromClass(PyDictionary.class);

private static PyType StringMapType = PyType.fromClass(PyStringMap.class);

private static PyType FloatType = PyType.fromClass(PyFloat.class);

private static PyType FunctionType = PyType.fromClass(PyFunction.class);

private static PyType InstanceType = PyType.fromClass(PyInstance.class);

private static PyType IntType = PyType.fromClass(PyInteger.class);

private static PyType ListType = PyType.fromClass(PyList.class);

private static PyType LongType = PyType.fromClass(PyLong.class);

private static PyType NoneType = PyType.fromClass(PyNone.class);

private static PyType StringType = PyType.fromClass(PyString.class);

private static PyType UnicodeType = PyType.fromClass(PyUnicode.class);

private static PyType TupleType = PyType.fromClass(PyTuple.class);

private static PyType FileType = PyType.fromClass(PyFile.class);

private static PyType BoolType = PyType.fromClass(PyBoolean.class);

private static PyObject dict;

private static final int BATCHSIZE = 1024;

/**

public static void classDictInit(PyObject dict) {

cPickle.dict = dict;

// XXX: Hack for JPython 1.0.1. By default __builtin__ is not in

// sys.modules.

imp.importName("__builtin__", true);

PyModule copyreg = (PyModule)importModule("copy_reg");

dispatch_table = (PyDictionary)copyreg.__getattr__("dispatch_table");

extension_registry = (PyDictionary)copyreg.__getattr__("_extension_registry");

inverted_registry = (PyDictionary)copyreg.__getattr__("_inverted_registry");

PickleError = Py.makeClass("PickleError", Py.Exception, _PickleError());

PicklingError = Py.makeClass("PicklingError", PickleError, exceptionNamespace());

UnpickleableError = Py.makeClass("UnpickleableError", PicklingError, _UnpickleableError());

UnpicklingError = Py.makeClass("UnpicklingError", PickleError, exceptionNamespace());

BadPickleGet = Py.makeClass("BadPickleGet", UnpicklingError, exceptionNamespace());

}

public static PyObject exceptionNamespace() {

PyObject dict = new PyStringMap();

dict.__setitem__("__module__", new PyString("cPickle"));

return dict;

}

public static PyObject _PickleError() {

dict = exceptionNamespace();

dict.__setitem__("__str__", getJavaFunc("__str__", "_PickleError__str__"));

return dict;

}

public static PyString _PickleError__str__(PyObject self, PyObject[] args, String[] kwargs) {

PyObject selfArgs = self.__getattr__("args");

if (selfArgs.__len__() > 0 && selfArgs.__getitem__(0).__len__() > 0) {

return selfArgs.__getitem__(0).__str__();

} else {

return new PyString("(what)");

}

}

public static PyObject _UnpickleableError() {

dict = exceptionNamespace();

dict.__setitem__("__str__", getJavaFunc("__str__", "_UnpickleableError__str__"));

return dict;

}

public static PyString _UnpickleableError__str__(PyObject self, PyObject[] args,

String[] kwargs) {

PyObject selfArgs = self.__getattr__("args");

PyObject a = selfArgs.__len__() > 0 ? selfArgs.__getitem__(0) : new PyString("(what)");

return new PyString("Cannot pickle %s objects").__mod__(a).__str__();

}

/**

public static Pickler Pickler(PyObject file) {

return new Pickler(file, 0);

}

/**

public static Pickler Pickler(PyObject file, int protocol) {

return new Pickler(file, protocol);

}

/**

public static Unpickler Unpickler(PyObject file) {

return new Unpickler(file);

}

/**

public static void dump(PyObject object, PyObject file) {

dump(object, file, 0);

}

/**

public static void dump(PyObject object, PyObject file, int protocol) {

new Pickler(file, protocol).dump(object);

}

/**

public static PyString dumps(PyObject object) {

return dumps(object, 0);

}

/**

public static PyString dumps(PyObject object, int protocol) {

cStringIO.StringIO file = cStringIO.StringIO();

dump(object, file, protocol);

return file.getvalue();

}

/**

public static Object load(PyObject file) {

try {

return new Unpickler(file).load();

}

catch (ArrayIndexOutOfBoundsException e) {

// invalid data, bad stack

throw Py.IndexError(e.getMessage());

} catch (StringIndexOutOfBoundsException e) {

// short data

throw Py.EOFError(e.getMessage());

}

}

/**

public static Object loads(PyObject str) {

cStringIO.StringIO file = cStringIO.StringIO(str.toString());

return load(file);

}

// Factory for creating PyIOFile representation.

/**

static public class Pickler {

private PyIOFile file;

private int protocol;

/**

public boolean fast = false;

private PickleMemo memo = new PickleMemo();

/**

public PyObject persistent_id = null;

/**

public PyObject inst_persistent_id = null;

public Pickler(PyObject file, int protocol) {

this.file = PyIOFileFactory.createIOFile(file);

this.protocol = protocol;

}

/**

public void dump(PyObject object) {

if (protocol >= 2) {

file.write(PROTO);

file.write((char) protocol);

}

save(object);

file.write(STOP);

file.flush();

}

private static final int get_id(PyObject o) {

// we don't pickle Java instances so we don't have to consider that case

return System.identityHashCode(o);

}

// Save name as in pickle.py but semantics are slightly changed.

private void put(int i) {

if (protocol > 0) {

if (i < 256) {

file.write(BINPUT);

file.write((char)i);

return;

}

file.write(LONG_BINPUT);

file.write((char)( i & 0xFF));

file.write((char)((i >>> 8) & 0xFF));

file.write((char)((i >>> 16) & 0xFF));

file.write((char)((i >>> 24) & 0xFF));

return;

}

file.write(PUT);

file.write(String.valueOf(i));

file.write("\n");

}

// Same name as in pickle.py but semantics are slightly changed.

private void get(int i) {

if (protocol > 0) {

if (i < 256) {

file.write(BINGET);

file.write((char)i);

return;

}

file.write(LONG_BINGET);

file.write((char)( i & 0xFF));

file.write((char)((i >>> 8) & 0xFF));

file.write((char)((i >>> 16) & 0xFF));

file.write((char)((i >>> 24) & 0xFF));

return;

}

file.write(GET);

file.write(String.valueOf(i));

file.write("\n");

}

private void save(PyObject object) {

save(object, false);

}

private void save(PyObject object, boolean pers_save) {

if (!pers_save && persistent_id != null && save_pers(object, persistent_id)) {

return;

}

int d = get_id(object);

PyType t = object.getType();

if (t == TupleType && object.__len__() == 0) {

if (protocol > 0) {

save_empty_tuple(object);

} else {

save_tuple(object);

}

return;

}

int m = getMemoPosition(d, object);

if (m >= 0) {

get(m);

return;

}

if (save_type(object, t)) {

return;

}

if (!pers_save && inst_persistent_id != null && save_pers(object, inst_persistent_id)) {

return;

}

if (Py.isSubClass(t, PyType.TYPE)) {

save_global(object);

return;

}

PyObject tup = null;

PyObject reduce = dispatch_table.__finditem__(t);

if (reduce == null) {

reduce = object.__findattr__("__reduce_ex__");

if (reduce != null) {

tup = reduce.__call__(Py.newInteger(protocol));

} else {

reduce = object.__findattr__("__reduce__");

if (reduce == null) {

throw new PyException(UnpickleableError, object);

}

tup = reduce.__call__();

}

} else {

tup = reduce.__call__(object);

}

if (tup instanceof PyString) {

save_global(object, tup);

return;

}

if (!(tup instanceof PyTuple)) {

throw new PyException(PicklingError,

"Value returned by " + reduce.__repr__() +

" must be a tuple");

}

int l = tup.__len__();

if (l < 2 || l > 5) {

throw new PyException(PicklingError,

"tuple returned by " + reduce.__repr__() +

" must contain two to five elements");

}

PyObject callable = tup.__finditem__(0);

PyObject arg_tup = tup.__finditem__(1);

PyObject state = (l > 2) ? tup.__finditem__(2) : Py.None;

PyObject listitems = (l > 3) ? tup.__finditem__(3) : Py.None;

PyObject dictitems = (l > 4) ? tup.__finditem__(4) : Py.None;

if (!(arg_tup instanceof PyTuple) && arg_tup != Py.None) {

throw new PyException(PicklingError,

"Second element of tupe returned by " +

reduce.__repr__() + " must be a tuple");

}

save_reduce(callable, arg_tup, state, listitems, dictitems, object);

}

final private boolean save_pers(PyObject object, PyObject pers_func) {

PyObject pid = pers_func.__call__(object);

if (pid == Py.None) {

return false;

}

if (protocol == 0) {

if (!Py.isInstance(pid, PyString.TYPE)) {

throw new PyException(PicklingError, "persistent id must be string");

}

file.write(PERSID);

file.write(pid.toString());

file.write("\n");

} else {

save(pid, true);

file.write(BINPERSID);

}

return true;

}

final private void save_reduce(PyObject callable, PyObject arg_tup,

PyObject state, PyObject listitems, PyObject dictitems,

PyObject object)

{

PyObject callableName = callable.__findattr__("__name__");

if(protocol >= 2 && callableName != null

&& "__newobj__".equals(callableName.toString())) {

PyObject cls = arg_tup.__finditem__(0);

if(cls.__findattr__("__new__") == null) {

throw new PyException(PicklingError,

"args[0] from __newobj__ args has no __new__");

}

// TODO: check class

save(cls);

save(arg_tup.__getslice__(Py.One, Py.None));

file.write(NEWOBJ);

} else {

save(callable);

save(arg_tup);

file.write(REDUCE);

}

// Memoize

put(putMemo(get_id(object), object));

if (listitems != Py.None) {

batch_appends(listitems);

}

if (dictitems != Py.None) {

batch_setitems(dictitems);

}

if (state != Py.None) {

save(state);

file.write(BUILD);

}

}

final private boolean save_type(PyObject object, PyType type) {

//System.out.println("save_type " + object + " " + cls);

if (type == NoneType) {

save_none(object);

} else if (type == StringType) {

save_string(object);

} else if (type == UnicodeType) {

save_unicode(object);

} else if (type == IntType) {

save_int(object);

} else if (type == LongType) {

save_long(object);

} else if (type == FloatType) {

save_float(object);

} else if (type == TupleType) {

save_tuple(object);

} else if (type == ListType) {

save_list(object);

} else if (type == DictionaryType || type == StringMapType) {

save_dict(object);

} else if (type == InstanceType) {

save_inst((PyInstance)object);

} else if (type == ClassType) {

save_global(object);

} else if (type == TypeType) {

save_global(object);

} else if (type == FunctionType) {

save_global(object);

} else if (type == BuiltinCallableType) {

save_global(object);

} else if (type == ReflectedFunctionType) {

save_global(object);

} else if (type == BoolType) {

save_bool(object);

} else {

return false;

}

return true;

}

final private void save_none(PyObject object) {

file.write(NONE);

}

final private void save_int(PyObject object) {

if (protocol > 0) {

int l = ((PyInteger)object).getValue();

char i1 = (char)( l & 0xFF);

char i2 = (char)((l >>> 8 ) & 0xFF);

char i3 = (char)((l >>> 16) & 0xFF);

char i4 = (char)((l >>> 24) & 0xFF);

if (i3 == '\0' && i4 == '\0') {

if (i2 == '\0') {

file.write(BININT1);

file.write(i1);

return;

}

file.write(BININT2);

file.write(i1);

file.write(i2);

return;

}

file.write(BININT);

file.write(i1);

file.write(i2);

file.write(i3);

file.write(i4);

} else {

file.write(INT);

file.write(object.toString());

file.write("\n");

}

}

private void save_bool(PyObject object) {

int value = ((PyBoolean)object).getValue();

if(protocol >= 2) {

file.write(value != 0 ? NEWTRUE : NEWFALSE);

} else {

file.write(INT);

file.write(value != 0 ? "01" : "00");

file.write("\n");

}

}