tyler.durden/snappy-java
1
0
Fork 0
mirror of https://github.com/xerial/snappy-java.git synced 2025-04-08 19:35:08 +02:00
Code Issues Packages Projects Releases Wiki Activity

Use SnappyNativeAPI as an interface to the native code

Browse Source
This commit is contained in:
Taro L. Saito 2011-06-27 10:29:58 +09:00
parent 06ba339352
commit 7134608206
12 changed files with 185 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/main/java/org/xerial/snappy/Snappy.java
View File

@ -36,15 +36,16 @@ import java.nio.ByteBuffer;
*/
public class Snappy
{
private static SnappyNativeAPI impl;
static {
SnappyLoader.load();
impl = SnappyLoader.load();
}
/**
* High-level API for compressing the input byte array. This method performs
* array copy to generate the result. If you want to save this cost, use
* {@link #compress(byte[], int, int, byte[], int)} or
* array copy to generate the result. If you want to reduce the memory copy
* cost, use {@link #compress(byte[], int, int, byte[], int)} or
* {@link #compress(ByteBuffer, ByteBuffer)}.
*
* @param input
@ -99,7 +100,7 @@ public class Snappy
// output: compressed
int uPos = uncompressed.position();
int uLen = uncompressed.remaining();
int compressedSize = SnappyNative.rawCompress(uncompressed, uPos, uLen, compressed, compressed.position());
int compressedSize = impl.rawCompress(uncompressed, uPos, uLen, compressed, compressed.position());
// pos limit
// [ ......BBBBBBB.........]
@ -152,7 +153,7 @@ public class Snappy
* @return native library version
*/
public static String getNativeLibraryVersion() {
return SnappyNative.nativeLibraryVersion();
return impl.nativeLibraryVersion();
}
/**
@ -164,7 +165,7 @@ public class Snappy
public static boolean isValidCompressedBuffer(byte[] input, int offset, int length) throws IOException {
if (input == null)
throw new NullPointerException("input is null");
return SnappyNative.isValidCompressedBuffer(input, offset, length);
return impl.isValidCompressedBuffer(input, offset, length);
}
/**
@ -184,7 +185,7 @@ public class Snappy
* factor of four faster than actual decompression.
*/
public static boolean isValidCompressedBuffer(ByteBuffer compressed) throws IOException {
return SnappyNative.isValidCompressedBuffer(compressed, compressed.position(), compressed.remaining());
return impl.isValidCompressedBuffer(compressed, compressed.position(), compressed.remaining());
}
/**
@ -196,7 +197,7 @@ public class Snappy
* @return maximum byte size of the compressed data
*/
public static int maxCompressedLength(int byteSize) {
return SnappyNative.maxCompressedLength(byteSize);
return impl.maxCompressedLength(byteSize);
}
/**
@ -210,7 +211,7 @@ public class Snappy
*/
public static byte[] rawCompress(Object data, int byteSize) {
byte[] buf = new byte[Snappy.maxCompressedLength(byteSize)];
int compressedByteSize = SnappyNative.rawCompress(data, 0, byteSize, buf, 0);
int compressedByteSize = impl.rawCompress(data, 0, byteSize, buf, 0);
byte[] result = new byte[compressedByteSize];
System.arraycopy(buf, 0, result, 0, compressedByteSize);
return result;
@ -238,7 +239,7 @@ public class Snappy
if (input == null || output == null)
throw new NullPointerException("input or output is null");
int compressedSize = SnappyNative.rawCompress(input, inputOffset, inputLength, output, outputOffset);
int compressedSize = impl.rawCompress(input, inputOffset, inputLength, output, outputOffset);
return compressedSize;
}
@ -269,7 +270,7 @@ public class Snappy
throws IOException {
if (input == null || output == null)
throw new NullPointerException("input or output is null");
return SnappyNative.rawUncompress(input, inputOffset, inputLength, output, outputOffset);
return impl.rawUncompress(input, inputOffset, inputLength, output, outputOffset);
}
/**
@ -341,8 +342,7 @@ public class Snappy
// pos limit
// [ ......UUUUUU.........]
int decompressedSize = SnappyNative
.rawUncompress(compressed, cPos, cLen, uncompressed, uncompressed.position());
int decompressedSize = impl.rawUncompress(compressed, cPos, cLen, uncompressed, uncompressed.position());
uncompressed.limit(uncompressed.position() + decompressedSize);
return decompressedSize;
@ -355,14 +355,14 @@ public class Snappy
public static char[] uncompressCharArray(byte[] input, int offset, int length) throws IOException {
int uncompressedLength = Snappy.uncompressedLength(input, offset, length);
char[] result = new char[uncompressedLength / 2];
int byteSize = SnappyNative.rawUncompress(input, offset, length, result, 0);
int byteSize = impl.rawUncompress(input, offset, length, result, 0);
return result;
}
public static double[] uncompressDoubleArray(byte[] input) throws IOException {
int uncompressedLength = Snappy.uncompressedLength(input, 0, input.length);
double[] result = new double[uncompressedLength / 8];
int byteSize = SnappyNative.rawUncompress(input, 0, input.length, result, 0);
int byteSize = impl.rawUncompress(input, 0, input.length, result, 0);
return result;
}
@ -377,7 +377,7 @@ public class Snappy
* {@link SnappyErrorCode#PARSING_ERROR}
*/
public static int uncompressedLength(byte[] input) throws IOException {
return SnappyNative.uncompressedLength(input, 0, input.length);
return impl.uncompressedLength(input, 0, input.length);
}
/**
@ -396,7 +396,7 @@ public class Snappy
if (input == null)
throw new NullPointerException("input is null");
return SnappyNative.uncompressedLength(input, offset, length);
return impl.uncompressedLength(input, offset, length);
}
public static class CompressedDataLength
@ -473,7 +473,7 @@ public class Snappy
if (!compressed.isDirect())
throw new SnappyError(SnappyErrorCode.NOT_A_DIRECT_BUFFER, "input is not a direct buffer");
return SnappyNative.uncompressedLength(compressed, compressed.position(), compressed.remaining());
return impl.uncompressedLength(compressed, compressed.position(), compressed.remaining());
}
public static float[] uncompressFloatArray(byte[] input) throws IOException {
@ -483,7 +483,7 @@ public class Snappy
public static float[] uncompressFloatArray(byte[] input, int offset, int length) throws IOException {
int uncompressedLength = Snappy.uncompressedLength(input, offset, length);
float[] result = new float[uncompressedLength / 4];
int byteSize = SnappyNative.rawUncompress(input, offset, length, result, 0);
int byteSize = impl.rawUncompress(input, offset, length, result, 0);
return result;
}
@ -494,7 +494,7 @@ public class Snappy
public static int[] uncompressIntArray(byte[] input, int offset, int length) throws IOException {
int uncompressedLength = Snappy.uncompressedLength(input, offset, length);
int[] result = new int[uncompressedLength / 4];
int byteSize = SnappyNative.rawUncompress(input, offset, length, result, 0);
int byteSize = impl.rawUncompress(input, offset, length, result, 0);
return result;
}
@ -505,7 +505,7 @@ public class Snappy
public static long[] uncompressLongArray(byte[] input, int offset, int length) throws IOException {
int uncompressedLength = Snappy.uncompressedLength(input, offset, length);
long[] result = new long[uncompressedLength / 8];
int byteSize = SnappyNative.rawUncompress(input, offset, length, result, 0);
int byteSize = impl.rawUncompress(input, offset, length, result, 0);
return result;
}
@ -516,7 +516,7 @@ public class Snappy
public static short[] uncompressShortArray(byte[] input, int offset, int length) throws IOException {
int uncompressedLength = Snappy.uncompressedLength(input, offset, length);
short[] result = new short[uncompressedLength / 2];
int byteSize = SnappyNative.rawUncompress(input, offset, length, result, 0);
int byteSize = impl.rawUncompress(input, offset, length, result, 0);
return result;
}

5
src/main/java/org/xerial/snappy/SnappyError.java
View File

@ -39,6 +39,11 @@ public class SnappyError extends Error
public final SnappyErrorCode errorCode;
public SnappyError(SnappyErrorCode code) {
super();
this.errorCode = code;
}
public SnappyError(SnappyErrorCode code, Error e) {
super(e);
this.errorCode = code;

2
src/main/java/org/xerial/snappy/SnappyErrorCode.java
View File

@ -32,7 +32,7 @@ package org.xerial.snappy;
*/
public enum SnappyErrorCode {
// DO NOT change the id of the error codes since these IDs are also used in SnappyNative.cpp
// DO NOT change these error code IDs because these numbers are used inside SnappyNative.cpp
UNKNOWN(0),
FAILED_TO_LOAD_NATIVE_LIBRARY(1),
PARSING_ERROR(2),

3
src/main/java/org/xerial/snappy/SnappyException.java
View File

@ -34,7 +34,7 @@ import java.io.IOException;
*
*/
@Deprecated
public class SnappyException extends Exception
public class SnappyException extends IOException
{
private static final long serialVersionUID = 1L;
@ -45,6 +45,7 @@ public class SnappyException extends Exception
}
public SnappyException(SnappyErrorCode errorCode) {
super();
this.errorCode = errorCode;
}

47
src/main/java/org/xerial/snappy/SnappyLoader.java
View File

@ -81,14 +81,15 @@ import java.util.Properties;
*/
public class SnappyLoader
{
private static boolean isInitialized = false;
private static boolean isLoaded = false;
private static boolean isInitialized = false;
private static boolean isLoaded = false;
private static SnappyNativeAPI api = null;
private static ClassLoader getAncestorClassLoader() {
private static ClassLoader getRootClassLoader() {
ClassLoader cl = SnappyLoader.class.getClassLoader();
// while (cl.getParent() != null) {
// cl = cl.getParent();
// }
while (cl.getParent() != null) {
cl = cl.getParent();
}
return cl;
}
@ -111,21 +112,22 @@ public class SnappyLoader
return isLoaded;
}
static void load() {
static SnappyNativeAPI load() {
if (isInitialized)
return;
return api;
isInitialized = true;
final String nativeLoaderClassName = "org.xerial.snappy.SnappyNativeLoader";
final String[] classesToPreload = new String[] { "org.xerial.snappy.SnappyNative",
"org.xerial.snappy.SnappyErrorCode" };
final String[] classesToPreload = new String[] { "org.xerial.snappy.SnappyNativeAPI",
"org.xerial.snappy.SnappyNative", "org.xerial.snappy.SnappyErrorCode" };
try {
Class.forName(nativeLoaderClassName);
Class< ? > c = Class.forName(nativeLoaderClassName);
// If this native loader class is already defined, it means that another class loader already loaded the native library of snappy
api = (SnappyNativeAPI) Class.forName("org.xerial.snappy.SnappyNative").newInstance();
isLoaded = true;
return;
return api;
}
catch (ClassNotFoundException e) {
try {
@ -142,18 +144,19 @@ public class SnappyLoader
Method defineClass = classLoader.getDeclaredMethod("defineClass", new Class[] { String.class,
byte[].class, int.class, int.class, ProtectionDomain.class });
ClassLoader systemClassLoader = getAncestorClassLoader();
// Use parent class loader to load SnappyNative, since Tomcat, which uses different class loaders for each webapps, cannot load JNI interface twice
ClassLoader systemClassLoader = getRootClassLoader();
ProtectionDomain pd = System.class.getProtectionDomain();
// ClassLoader.defineClass is a protected method, so we have to make it accessible
defineClass.setAccessible(true);
try {
// Create a new class using a ClassLoader#defineClass
defineClass.invoke(systemClassLoader, nativeLoaderClassName, byteCode, 0, byteCode.length,
System.class.getProtectionDomain());
defineClass.invoke(systemClassLoader, nativeLoaderClassName, byteCode, 0, byteCode.length, pd);
for (int i = 0; i < classesToPreload.length; ++i) {
byte[] b = preloadClassByteCode.get(i);
defineClass.invoke(systemClassLoader, classesToPreload[i], b, 0, b.length,
System.class.getProtectionDomain());
defineClass.invoke(systemClassLoader, classesToPreload[i], b, 0, b.length, pd);
}
}
finally {
@ -182,13 +185,23 @@ public class SnappyLoader
systemClassLoader.loadClass(each);
}
isLoaded = true;
api = (SnappyNativeAPI) Class.forName("org.xerial.snappy.SnappyNative").newInstance();
return api;
}
}
catch (ClassNotFoundException ee) {
throw new SnappyError(SnappyErrorCode.FAILED_TO_LOAD_NATIVE_LIBRARY, ee.getMessage());
}
catch (Exception e2) {
throw new SnappyError(SnappyErrorCode.FAILED_TO_LOAD_NATIVE_LIBRARY, e.getMessage());
}
}
catch (Exception e) {
throw new SnappyError(SnappyErrorCode.FAILED_TO_LOAD_NATIVE_LIBRARY, e.getMessage());
}
throw new SnappyError(SnappyErrorCode.FAILED_TO_LOAD_NATIVE_LIBRARY);
}
public static final String KEY_SNAPPY_LIB_PATH = "org.xerial.snappy.lib.path";

29
src/main/java/org/xerial/snappy/SnappyNative.cpp
View File

@ -17,17 +17,20 @@
#include <snappy.h>
#include "SnappyNative.h"
void throw_exception(JNIEnv *env, jclass self, int errorCode)
void throw_exception(JNIEnv *env, jobject self, int errorCode)
{
jmethodID mth_throwex = env->GetStaticMethodID(self, "throw_error", "(I)V");
jclass c = env->FindClass("Lorg/xerial/snappy/SnappyNative;");
if(c==0)
return;
jmethodID mth_throwex = env->GetMethodID(c, "throw_error", "(I)V");
if(mth_throwex == 0)
return;
env->CallStaticVoidMethod(self, mth_throwex, (jint) errorCode);
env->CallVoidMethod(self, mth_throwex, (jint) errorCode);
}
JNIEXPORT jstring JNICALL Java_org_xerial_snappy_SnappyNative_nativeLibraryVersion
(JNIEnv * env, jclass self)
(JNIEnv * env, jobject self)
{
return env->NewStringUTF("1.0.3");
}
@ -38,7 +41,7 @@ JNIEXPORT jstring JNICALL Java_org_xerial_snappy_SnappyNative_nativeLibraryVersi
* Signature: (Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)J
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2I
(JNIEnv* env, jclass self, jobject uncompressed, jint upos, jint ulen, jobject compressed, jint cpos)
(JNIEnv* env, jobject self, jobject uncompressed, jint upos, jint ulen, jobject compressed, jint cpos)
{
char* uncompressedBuffer = (char*) env->GetDirectBufferAddress(uncompressed);
char* compressedBuffer = (char*) env->GetDirectBufferAddress(compressed);
@ -54,7 +57,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_ni
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_lang_Object_2IILjava_lang_Object_2I
(JNIEnv * env, jclass self, jobject input, jint inputOffset, jint inputLen, jobject output, jint outputOffset)
(JNIEnv * env, jobject self, jobject input, jint inputOffset, jint inputLen, jobject output, jint outputOffset)
{
char* in = (char*) env->GetPrimitiveArrayCritical((jarray) input, 0);
char* out = (char*) env->GetPrimitiveArrayCritical((jarray) output, 0);
@ -74,7 +77,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_la
}
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_lang_Object_2IILjava_lang_Object_2I
(JNIEnv * env, jclass self, jobject input, jint inputOffset, jint inputLength, jobject output, jint outputOffset)
(JNIEnv * env, jobject self, jobject input, jint inputOffset, jint inputLength, jobject output, jint outputOffset)
{
char* in = (char*) env->GetPrimitiveArrayCritical((jarray) input, 0);
char* out = (char*) env->GetPrimitiveArrayCritical((jarray) output, 0);
@ -106,7 +109,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_
* Signature: (Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;)Z
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2I
(JNIEnv * env, jclass self, jobject compressed, jint cpos, jint clen, jobject decompressed, jint dpos)
(JNIEnv * env, jobject self, jobject compressed, jint cpos, jint clen, jobject decompressed, jint dpos)
{
char* compressedBuffer = (char*) env->GetDirectBufferAddress(compressed);
char* decompressedBuffer = (char*) env->GetDirectBufferAddress(decompressed);
@ -135,7 +138,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_maxCompressedLength
(JNIEnv *, jclass, jint size)
(JNIEnv *, jobject, jint size)
{
size_t l = snappy::MaxCompressedLength((size_t) size);
return (jint) l;
@ -147,7 +150,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_maxCompressedLength
* Signature: (Ljava/nio/ByteBuffer;)J
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__Ljava_nio_ByteBuffer_2II
(JNIEnv * env, jclass self, jobject compressed, jint cpos, jint clen)
(JNIEnv * env, jobject self, jobject compressed, jint cpos, jint clen)
{
char* compressedBuffer = (char*) env->GetDirectBufferAddress(compressed);
if(compressedBuffer == 0) {
@ -165,7 +168,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__L
}
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__Ljava_lang_Object_2II
(JNIEnv * env, jclass self, jobject input, jint offset, jint length)
(JNIEnv * env, jobject self, jobject input, jint offset, jint length)
{
char* in = (char*) env->GetPrimitiveArrayCritical((jarray) input, 0);
if(in == 0) {
@ -187,7 +190,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__L
}
JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressedBuffer__Ljava_nio_ByteBuffer_2II
(JNIEnv * env, jclass self, jobject compressed, jint cpos, jint clen)
(JNIEnv * env, jobject self, jobject compressed, jint cpos, jint clen)
{
char* compressedBuffer = (char*) env->GetDirectBufferAddress(compressed);
if(compressedBuffer == 0) {
@ -200,7 +203,7 @@ JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressed
JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressedBuffer__Ljava_lang_Object_2II
(JNIEnv * env, jclass self, jobject input, jint offset, jint length)
(JNIEnv * env, jobject self, jobject input, jint offset, jint length)
{
char* in = (char*) env->GetPrimitiveArrayCritical((jarray) input, 0);
if(in == 0) {

20
src/main/java/org/xerial/snappy/SnappyNative.h
View File

@ -13,7 +13,7 @@ extern "C" {
* Signature: ()Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_org_xerial_snappy_SnappyNative_nativeLibraryVersion
(JNIEnv *, jclass);
(JNIEnv *, jobject);
/*
* Class: org_xerial_snappy_SnappyNative
@ -21,7 +21,7 @@ JNIEXPORT jstring JNICALL Java_org_xerial_snappy_SnappyNative_nativeLibraryVersi
* Signature: (Ljava/nio/ByteBuffer;IILjava/nio/ByteBuffer;I)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2I
(JNIEnv *, jclass, jobject, jint, jint, jobject, jint);
(JNIEnv *, jobject, jobject, jint, jint, jobject, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -29,7 +29,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_ni
* Signature: (Ljava/lang/Object;IILjava/lang/Object;I)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_lang_Object_2IILjava_lang_Object_2I
(JNIEnv *, jclass, jobject, jint, jint, jobject, jint);
(JNIEnv *, jobject, jobject, jint, jint, jobject, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -37,7 +37,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawCompress__Ljava_la
* Signature: (Ljava/nio/ByteBuffer;IILjava/nio/ByteBuffer;I)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_nio_ByteBuffer_2IILjava_nio_ByteBuffer_2I
(JNIEnv *, jclass, jobject, jint, jint, jobject, jint);
(JNIEnv *, jobject, jobject, jint, jint, jobject, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -45,7 +45,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_
* Signature: (Ljava/lang/Object;IILjava/lang/Object;I)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_lang_Object_2IILjava_lang_Object_2I
(JNIEnv *, jclass, jobject, jint, jint, jobject, jint);
(JNIEnv *, jobject, jobject, jint, jint, jobject, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -53,7 +53,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_rawUncompress__Ljava_
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_maxCompressedLength
(JNIEnv *, jclass, jint);
(JNIEnv *, jobject, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -61,7 +61,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_maxCompressedLength
* Signature: (Ljava/nio/ByteBuffer;II)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__Ljava_nio_ByteBuffer_2II
(JNIEnv *, jclass, jobject, jint, jint);
(JNIEnv *, jobject, jobject, jint, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -69,7 +69,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__L
* Signature: (Ljava/lang/Object;II)I
*/
JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__Ljava_lang_Object_2II
(JNIEnv *, jclass, jobject, jint, jint);
(JNIEnv *, jobject, jobject, jint, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -77,7 +77,7 @@ JNIEXPORT jint JNICALL Java_org_xerial_snappy_SnappyNative_uncompressedLength__L
* Signature: (Ljava/nio/ByteBuffer;II)Z
*/
JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressedBuffer__Ljava_nio_ByteBuffer_2II
(JNIEnv *, jclass, jobject, jint, jint);
(JNIEnv *, jobject, jobject, jint, jint);
/*
* Class: org_xerial_snappy_SnappyNative
@ -85,7 +85,7 @@ JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressed
* Signature: (Ljava/lang/Object;II)Z
*/
JNIEXPORT jboolean JNICALL Java_org_xerial_snappy_SnappyNative_isValidCompressedBuffer__Ljava_lang_Object_2II
(JNIEnv *, jclass, jobject, jint, jint);
(JNIEnv *, jobject, jobject, jint, jint);
#ifdef __cplusplus
}

34
src/main/java/org/xerial/snappy/SnappyNative.java
View File

@ -28,47 +28,47 @@ import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Interface to access the native code of Snappy. Although the methods in this
* class are public, do not use them.
* JNI interface of the {@link SnappyNativeAPI} implementation. The native
* method in this class is defined in SnappyNative.h (genereted by javah) and
* SnappyNative.cpp
*
*
* @author leo
*
*/
public class SnappyNative
public class SnappyNative implements SnappyNativeAPI
{
public native static String nativeLibraryVersion();
public native String nativeLibraryVersion();
// ------------------------------------------------------------------------
// Generic compression/decompression routines.
// ------------------------------------------------------------------------
public native static int rawCompress(ByteBuffer input, int inputOffset, int inputLength, ByteBuffer compressed,
public native int rawCompress(ByteBuffer input, int inputOffset, int inputLength, ByteBuffer compressed,
int outputOffset) throws IOException;
public native static int rawCompress(Object input, int inputOffset, int inputByteLength, Object output,
int outputOffset);
public native int rawCompress(Object input, int inputOffset, int inputByteLength, Object output, int outputOffset);
public native static int rawUncompress(ByteBuffer compressed, int inputOffset, int inputLength,
ByteBuffer uncompressed, int outputOffset) throws IOException;
public native static int rawUncompress(Object input, int inputOffset, int inputLength, Object output,
public native int rawUncompress(ByteBuffer compressed, int inputOffset, int inputLength, ByteBuffer uncompressed,
int outputOffset) throws IOException;
public native int rawUncompress(Object input, int inputOffset, int inputLength, Object output, int outputOffset)
throws IOException;
// Returns the maximal size of the compressed representation of
// input data that is "source_bytes" bytes in length;
public native static int maxCompressedLength(int source_bytes);
public native int maxCompressedLength(int source_bytes);
// This operation takes O(1) time.
public native static int uncompressedLength(ByteBuffer compressed, int offset, int len) throws IOException;
public native int uncompressedLength(ByteBuffer compressed, int offset, int len) throws IOException;
public native static int uncompressedLength(Object input, int offset, int len) throws IOException;
public native int uncompressedLength(Object input, int offset, int len) throws IOException;
public native static boolean isValidCompressedBuffer(ByteBuffer compressed, int offset, int len) throws IOException;
public native boolean isValidCompressedBuffer(ByteBuffer compressed, int offset, int len) throws IOException;
public native static boolean isValidCompressedBuffer(Object input, int offset, int len) throws IOException;
public native boolean isValidCompressedBuffer(Object input, int offset, int len) throws IOException;
protected static void throw_error(int errorCode) throws IOException {
public void throw_error(int errorCode) throws IOException {
throw new IOException(String.format("%s(%d)", SnappyErrorCode.getErrorMessage(errorCode), errorCode));
}

71
src/main/java/org/xerial/snappy/SnappyNativeAPI.java Executable file
View File

@ -0,0 +1,71 @@
/*--------------------------------------------------------------------------
* Copyright 2011 Taro L. Saito
*
* 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.
*--------------------------------------------------------------------------*/
//--------------------------------------
// snappy-java Project
//
// SnappyNative.java
// Since: 2011/03/30
//
// $URL$
// $Author$
//--------------------------------------
package org.xerial.snappy;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Interface to access the native code of Snappy.
*
*
* @author leo
*
*/
public interface SnappyNativeAPI
{
public String nativeLibraryVersion();
// ------------------------------------------------------------------------
// Generic compression/decompression routines.
// ------------------------------------------------------------------------
public int rawCompress(ByteBuffer input, int inputOffset, int inputLength, ByteBuffer compressed, int outputOffset)
throws IOException;
public int rawCompress(Object input, int inputOffset, int inputByteLength, Object output, int outputOffset);
public int rawUncompress(ByteBuffer compressed, int inputOffset, int inputLength, ByteBuffer uncompressed,
int outputOffset) throws IOException;
public int rawUncompress(Object input, int inputOffset, int inputLength, Object output, int outputOffset)
throws IOException;
// Returns the maximal size of the compressed representation of
// input data that is "source_bytes" bytes in length;
public int maxCompressedLength(int source_bytes);
// This operation takes O(1) time.
public int uncompressedLength(ByteBuffer compressed, int offset, int len) throws IOException;
public int uncompressedLength(Object input, int offset, int len) throws IOException;
public boolean isValidCompressedBuffer(ByteBuffer compressed, int offset, int len) throws IOException;
public boolean isValidCompressedBuffer(Object input, int offset, int len) throws IOException;
public void throw_error(int errorCode) throws IOException;
}

BIN
src/main/resources/org/xerial/snappy/native/Windows/amd64/snappyjava.dll
View File

Binary file not shown.

BIN
src/main/resources/org/xerial/snappy/native/Windows/x86/snappyjava.dll
View File

Binary file not shown.

21
src/test/java/org/xerial/snappy/SnappyLoaderTest.java
View File

@ -42,6 +42,7 @@ import javassist.CtNewMethod;
import org.codehaus.plexus.classworlds.ClassWorld;
import org.codehaus.plexus.classworlds.realm.ClassRealm;
import org.junit.Ignore;
import org.junit.Test;
import org.xerial.util.FileResource;
import org.xerial.util.log.Logger;
@ -80,6 +81,7 @@ public class SnappyLoaderTest
}
}
@Ignore
@Test
public void loadFromSytemClassLoader() throws Exception {
@ -109,23 +111,22 @@ public class SnappyLoaderTest
//_logger.info(cl.getName());
//Class< ? > loaderClass = cl.toClass();
Class< ? > classLoader = Class.forName("java.lang.ClassLoader");
java.lang.reflect.Method defineClass = classLoader.getDeclaredMethod("defineClass", new Class[] { String.class,
byte[].class, int.class, int.class, ProtectionDomain.class });
defineClass.setAccessible(true);
defineClass.invoke(parent, cl.getName(), bytecode, 0, bytecode.length, System.class.getProtectionDomain());
Class< ? > forName = parent.loadClass("org.xerial.snappy.SnappyNativeLoader");
// Class< ? > classLoader = Class.forName("java.lang.ClassLoader");
// java.lang.reflect.Method defineClass = classLoader.getDeclaredMethod("defineClass", new Class[] { String.class,
// byte[].class, int.class, int.class, ProtectionDomain.class });
//
// defineClass.setAccessible(true);
// defineClass.invoke(parent, cl.getName(), bytecode, 0, bytecode.length, System.class.getProtectionDomain());
//
// Class< ? > forName = parent.loadClass("org.xerial.snappy.SnappyNativeLoader");
//Class< ? > snappyClass = L1.loadClass("org.xerial.snappy.Snappy"); // not found
//_logger.info(snappyClass.getName());
}
@Test
public void load() throws Exception {
SnappyLoader.load();
_logger.debug(Snappy.getNativeLibraryVersion());
_logger.info(Snappy.getNativeLibraryVersion());
}
}