generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-03-19 13:02:13 +01:00
Code Issues Projects Releases Wiki Activity

MessagePack for Java was moved to https://github.com/msgpack/msgpack-java.

Browse Source
This commit is contained in:
Muga Nishizawa 2012-02-09 02:21:43 +09:00
parent ae1b06f20b
commit 748236fef0
146 changed files with 1 additions and 28524 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
java/AUTHORS
View File

@ -1 +0,0 @@
FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

103
java/CHANGES.txt
View File

@ -1,103 +0,0 @@
Release 0.5.2 - 2011/04/23
NEW FEATURES
MSGPACK-6 Added TemplatePrecompiler program
Added built-in templates of BigDecimal and Date classes.
Added @MessagePackBeans annotation that enables you to serialize/deserialize
JavaBeans.
BUG FIXES
MSGPACK-4 Fixes the deserialization routine of Long value
IMPROVEMENTS
#35 Improves handling of ClassLoader on Javassist template builder.
MSGPACK-7 Improves compatibility with Java 1.5. Now it runs on JRE 5.
It is tested on Jenkins CI: http://ci.msgpack.org/job/java-jre5/
Release 0.5.1 - 2010/12/14
BUG FIXES
Fixes cast error on GenericArrayType
Throws MessagePackException instead of NullPointerException if target is null
on pack method.
Release 0.5.0 - 2010/12/09
NEW FEATURES
Dynamic template builder is rewritten. New ReflectionTemplateBuilder
supports DalvikVM.
Some optimization for dynamic code generator.
@MessagePackMessage accepts default filed option.
Added new field annotations: @Ignore, @Requred and @Index.
Supported pack/unpack/convertion of arrays including multidimensional arrays.
Added native pack/unpack routine of ByteBuffer. It will be zero-copy optimized
under a specific condition.
Release 0.4.3 - 2010/11/10
NEW FEATURES
Added FieldList class and MessagePack.register(Class<T>, FieldList) method
to specify optional/nullable options on runtime without annotations.
Changed annotation name: @MessagePackNullable -> @Nullable
Changed annotation name: @MessagePackOptional -> @Optional
Supported pack/unpack/convertion of enums.
Added MessagePack.unpack(buffer, T to) and MessagePackObject.convert(T to)
methods. They can unpack/convert buffer/object into existing object and
eliminate re-allocation overhead.
Release 0.4.2 - 2010/11/09
NEW FEATURES
Added MessagePackNullable annotation and Tempalte.tNullable(Template)
method.
Added <T> T MessagePackObject.unpack(Class<T>) method.
Release 0.4.1 - 2010/11/05
BUG FIXES
Fixed dynamic code generation of unpack methods
Release 0.4.0 - 2010/10/25
NEW FEATURES
Added MessagePackObject class and org.msgpack.object package that
represent unpacked (=dynamically typed) objects.
Unpacker.unpack method returns MessagePackObject instead of Object.
Added Templates class and org.msgpack.template package that provide
type conversion feature.
User-defined classes annotated with MessagePackMessage can be
pack/unpack/converted.
User-defined classes registered with MessagePack.register(Class) can be
pack/unpack/converted.
Added dynamic code generation feature for user-defined classes.
Added MessagePackOptional annotation.
Added MessagePack class that implements typical useful methods.
Release 0.3 - 2010/05/23
NEW FEATURES
Added Unbuffered API + Direct Conversion API to the Unpacker.
BUG FIXES
Zero-length Array and Map is deserialized as List and Map, instead of the
array of the Object.
fixed the bug around Packer.packByte().

202
java/LICENSE.txt
View File

@ -1,202 +0,0 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.

24
java/Makefile
View File

@ -1,24 +0,0 @@
.PHONY: compile test eclipse clean package
all:
compile
package:
mvn package
install:
mvn install
compile:
mvn compile
test:
mvn test
# generate .project and .classpath file for Eclipse
eclipse:
mvn eclipse:eclipse
clean:
mvn clean

29
java/README
View File

@ -1,28 +1 @@
To build the JAR file of Message Pack, you need to install Maven (http://maven.apache.org), then type the following command:
$ mvn package
To locally install the project, type
$ mvn install
To generate project files (.project, .classpath) for Eclipse, do
$ mvn eclipse:eclipse
then import the folder from your Eclipse.
Next, open the preference page in Eclipse and add the CLASSPATH variable:
M2_REPO = $HOME/.m2/repository
where $HOME is your home directory. In Windows XP, $HOME is:
C:/Documents and Settings/(user name)/.m2/repository
# How to release the project (compile, test, tagging, deploy)
$ mvn release:prepare
$ mvn release:perform
MessagePack for Java was moved to https://github.com/msgpack/msgpack-java.

303
java/build.xml
View File

@ -1,303 +0,0 @@
<project name="MessagePack for Java" default="jar"
xmlns:ivy="antlib:org.apache.ivy.ant"
xmlns:mvn="urn:maven-artifact-ant">
<property name="Name" value="MessagePack"/>
<property name="name" value="msgpack"/>
<property name="version" value="0.0.1"/>
<property name="fullname" value="${name}-${version}"/>
<property name="year" value="2010"/>
<!-- Load user's default properties. -->
<property file="${user.home}/build.properties" />
<property name="src.dir" value="${basedir}/src/main/java"/>
<property name="java.src.dir" value="${src.dir}/"/>
<property name="build.dir" value="${basedir}/build"/>
<property name="lib.dir" value="${basedir}/lib"/>
<property name="dist.dir" value="${basedir}/dist"/>
<property name="build.classes" value="${build.dir}/classes"/>
<property name="build.doc" value="${build.dir}/doc"/>
<property name="build.javadoc" value="${build.doc}/api/"/>
<property name="build.javadoc.log" value="${build.dir}/javadoc.log"/>
<property name="test.count" value="100"/>
<property name="test.junit.output.format" value="plain"/>
<property name="test.java.src.dir" value="${basedir}/src/test/java"/>
<property name="test.java.build.dir" value="${build.dir}/test"/>
<property name="test.java.classes" value="${test.java.build.dir}/classes"/>
<property name="test.java.include" value="Test*"/>
<property name="javac.encoding" value="ISO-8859-1"/>
<property name="javac.debug" value="on"/>
<property name="javac.optimize" value="on"/>
<property name="javac.deprecation" value="off"/>
<property name="javac.version" value="1.6"/>
<property name="javac.args" value=""/>
<property name="javac.args.warnings" value="-Xlint:unchecked"/>
<property name="javadoc.link.java"
value="http://java.sun.com/javase/6/docs/api/"/>
<property name="javadoc.packages" value="org.${name}.*"/>
<!-- ivy settings -->
<property name="ivy.version" value="2.1.0"/>
<property name="ivy.url"
value="http://repo2.maven.org/maven2/org/apache/ivy/ivy" />
<property name="ivy.home" value="${user.home}/.ant" />
<property name="ivy.lib" value="${build.dir}/lib"/>
<property name="ivy.test.lib" value="${build.dir}/test/lib"/>
<property name="mvn.repo"
value="https://repository.apache.org/content/repositories/snapshots"/>
<!-- the normal classpath -->
<path id="libs">
<fileset dir="${ivy.lib}">
<include name="**/*.jar" />
</fileset>
</path>
<path id="java.classpath">
<pathelement location="${build.classes}"/>
<fileset dir="${lib.dir}">
<include name="**/*.jar" />
<exclude name="**/excluded/" />
</fileset>
<fileset dir="${ant.home}/lib">
<include name="ant.jar" />
</fileset>
<path refid="libs" />
</path>
<path id="test.libs">
<fileset dir="${ivy.test.lib}">
<include name="**/*.jar" />
</fileset>
</path>
<path id="test.java.classpath">
<pathelement location="${test.java.classes}" />
<path refid="java.classpath"/>
<path refid="test.libs"/>
</path>
<!-- init & clean -->
<target name="init">
<mkdir dir="${build.dir}" />
<mkdir dir="${lib.dir}" />
<mkdir dir="${build.classes}" />
<mkdir dir="${test.java.build.dir}"/>
<mkdir dir="${test.java.classes}"/>
<mkdir dir="${ivy.lib}"/>
<mkdir dir="${ivy.test.lib}"/>
<condition property="ivy.jar.exists">
<available file="${lib.dir}/ivy-${ivy.version}.jar"/>
</condition>
</target>
<target name="clean">
<delete dir="${build.dir}" />
</target>
<!-- ivy targets -->
<target name="ivy-download" unless="ivy.jar.exists" depends="init">
<delete dir="${lib.dir}"
includes="ivy-*.jar" excludes="ivy-${ivy.version}.jar"/>
<get src="${ivy.url}/${ivy.version}/ivy-${ivy.version}.jar"
dest="${lib.dir}/ivy-${ivy.version}.jar" usetimestamp="true"/>
</target>
<target name="ivy-init" depends="ivy-download" unless="ivy.initialized">
<taskdef resource="org/apache/ivy/ant/antlib.xml"
uri="antlib:org.apache.ivy.ant" classpathref="java.classpath"/>
<!-- ensure that ivy taskdef is only run once, otw ant will error -->
<property name="ivy.initialized" value="true"/>
</target>
<target name="ivy-retrieve-build" depends="init,ivy-init">
<ivy:retrieve type="jar" conf="build"
pattern="${ivy.lib}/[artifact]-[revision].[ext]"/>
</target>
<target name="ivy-retrieve-test" depends="init,ivy-init">
<ivy:retrieve type="jar" conf="test"
pattern="${ivy.test.lib}/[artifact]-[revision].[ext]"/>
</target>
<!-- compiler -->
<macrodef name="java-compiler">
<attribute name="dest" default="${build.classes}"/>
<attribute name="includes" default="**/*.java"/>
<attribute name="excludes" default=""/>
<attribute name="classpath" default="java.classpath"/>
<element name="src" implicit="yes"/>
<sequential>
<javac
destdir="@{dest}"
includes="@{includes}"
excludes="@{excludes}"
encoding="${javac.encoding}"
debug="${javac.debug}"
optimize="${javac.optimize}"
target="${javac.version}"
source="${javac.version}"
deprecation="${javac.deprecation}">
<compilerarg line="${javac.args} ${javac.args.warnings}" />
<classpath refid="@{classpath}"/>
<src />
</javac>
</sequential>
</macrodef>
<!-- compile -->
<target name="compile" depends="init,ivy-retrieve-build">
<java-compiler>
<src path="${java.src.dir}"/>
</java-compiler>
</target>
<!-- test -->
<macrodef name="test-runner">
<attribute name="files.location" />
<attribute name="tests.pattern" />
<attribute name="test.dir" default="${test.java.build.dir}" />
<sequential>
<junit showoutput="yes"
printsummary="withOutAndErr"
haltonfailure="no"
fork="yes" forkMode="once"
errorProperty="tests.failed" failureProperty="tests.failed">
<sysproperty key="test.count" value="${test.count}"/>
<sysproperty key="test.dir" value="@{test.dir}"/>
<classpath refid="test.java.classpath"/>
<formatter type="${test.junit.output.format}"/>
<batchtest todir="${test.java.build.dir}" unless="testcase">
<fileset dir="@{files.location}"
includes="@{tests.pattern}"
excludes="**/${test.java.exclude}.java" />
</batchtest>
<batchtest todir="${test.java.build.dir}" if="testcase">
<fileset dir="@{files.location}" includes="**/${testcase}.java"/>
</batchtest>
</junit>
<fail if="tests.failed">Tests Failed!</fail>
</sequential>
</macrodef>
<target name="compile-test" depends="ivy-retrieve-test,compile">
<java-compiler dest="${test.java.classes}"
classpath="test.java.classpath">
<src path="${test.java.src.dir}/org" />
</java-compiler>
</target>
<target name="test" depends="init,compile-test">
<test-runner files.location="${test.java.src.dir}"
tests.pattern="**/${test.java.include}.java"/>
</target>
<!-- jar -->
<target name="jar" depends="compile">
<jar jarfile="${build.dir}/${name}-${version}.jar" basedir="${build.classes}" >
<manifest>
<section name="org/${name}">
<attribute name="Implementation-Title" value="${Name}"/>
<attribute name="Implementation-Version" value="${version}"/>
</section>
</manifest>
</jar>
</target>
<!-- javadoc -->
<target name="javadoc" depends="compile" description="Generate javadoc">
<mkdir dir="${build.javadoc}"/>
<record name="${build.javadoc.log}" action="start"/>
<javadoc
Locale="en_US"
packagenames="org.${org}.${name}.*"
destdir="${build.javadoc}"
encoding="UTF-8"
docencoding="UTF-8"
author="true"
version="true"
use="true"
windowtitle="${Name} ${version} API"
doctitle="${Name} ${version} API"
bottom="Copyright &amp;copy; ${year} The ${Name} Project"
>
<packageset dir="${java.src.dir}"/>
<link href="${javadoc.link.java}"/>
<classpath >
<path refid="java.classpath" />
</classpath>
</javadoc>
<record name="${build.javadoc.log}" action="stop"/>
<condition property="javadoc.warnings">
<isfileselected file="${build.javadoc.log}">
<contains text=": warning - "/>
</isfileselected>
</condition>
<fail if="javadoc.warnings">Javadoc warnings!</fail>
</target>
<target name="javadoc-jar" depends="javadoc">
<jar jarfile="${build.dir}/${fullname}-javadoc.jar">
<fileset dir="${build.javadoc}" includes="**/*"/>
</jar>
</target>
<!-- sources -->
<target name="source">
<jar jarfile="${build.dir}/${fullname}-sources.jar">
<fileset dir="${java.src.dir}" includes="**/*.java"/>
</jar>
</target>
<!-- pom -->
<target name="pom" depends="ivy-init">
<ivy:makepom ivyfile="${basedir}/ivy.xml"
pomfile="${dist.dir}/${fullname}.pom">
<mapping conf="default" scope="compile"/>
<mapping conf="test" scope="test"/>
</ivy:makepom>
</target>
<!-- dist -->
<target name="dist" depends="jar, pom, source, javadoc-jar"
description="Build distribution">
<mkdir dir="${dist.dir}"/>
<copy todir="${dist.dir}">
<fileset file="${build.dir}/${fullname}.jar"/>
<fileset file="${build.dir}/${fullname}-sources.jar"/>
<fileset file="${build.dir}/${fullname}-javadoc.jar"/>
</copy>
</target>
<!-- maven: install msgpack into local m2 cache -->
<target name="mvn-install" depends="jar, pom, source, javadoc-jar"
description="Installs msgpack to local m2 cache">
<typedef resource="org/apache/maven/artifact/ant/antlib.xml"
uri="urn:maven-artifact-ant"
classpathref="java.classpath"/>
<mvn:pom file="${dist.dir}/${fullname}.pom" id="msgpack"/>
<mvn:install file="${build.dir}/${fullname}.jar">
<attach file="${build.dir}/${fullname}-sources.jar"
classifier="sources" />
<attach file="${build.dir}/${fullname}-javadoc.jar"
classifier="javadoc" />
<pom refid="msgpack"/>
</mvn:install>
</target>
<!-- maven: create local repository into ${basedir}/maven2 -->
<target name="mvn-deploy" depends="jar, pom, source, javadoc-jar"
description="Deploys MessagePack to Maven repo.">
<typedef resource="org/apache/maven/artifact/ant/antlib.xml"
uri="urn:maven-artifact-ant"
classpathref="java.classpath"/>
<mvn:pom file="${dist.dir}/${fullname}.pom" id="msgpack"/>
<mvn:deploy file="${build.dir}/${fullname}.jar">
<remoteRepository url="file://localhost/${basedir}/maven2/"/>
<attach file="${build.dir}/${fullname}-sources.jar"
classifier="sources" />
<attach file="${build.dir}/${fullname}-javadoc.jar"
classifier="javadoc" />
<pom refid="msgpack"/>
</mvn:deploy>
</target>
</project>

21
java/ivy.xml
View File

@ -1,21 +0,0 @@
<ivy-module version="2.0"
xmlns:e="http://ant.apache.org/ivy/extra">
<info organisation="org"
module="${name}" revision="${version}">
<ivyauthor name="MessagePack Project" url="http://msgpack.org/"/>
<description>MessagePack</description>
</info>
<configurations defaultconfmapping="default">
<conf name="default"/> <!-- "runtime" configuration -->
<conf name="test"/>
<conf name="build" extends="default"/>
</configurations>
<dependencies>
<dependency org="junit" name="junit" rev="4.8.1" conf="test->default"/>
<dependency org="javassist" name="javassist" rev="3.12.1.GA"/>
<dependency org="org.slf4j" name="slf4j-api" rev="1.4.3"/>
</dependencies>
</ivy-module>

17
java/msgpack.iml
View File

@ -1,17 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_6" inherit-compiler-output="false">
<output url="file://$MODULE_DIR$/target/classes" />
<output-test url="file://$MODULE_DIR$/target/test-classes" />
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
<sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
<excludeFolder url="file://$MODULE_DIR$/target" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.8.1" level="project" />
</component>
</module>

188
java/pom.xml
View File

@ -1,188 +0,0 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.msgpack</groupId>
<artifactId>msgpack</artifactId>
<version>0.5.2-devel</version>
<description>MessagePack for Java</description>
<name>MessagePack for Java</name>
<url>http://msgpack.org/</url>
<licenses>
<license>
<name>The Apache Software License, Version 2.0</name>
<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
<distribution>repo</distribution>
</license>
</licenses>
<scm>
<connection>scm:git:git://github.com/msgpack/msgpack.git</connection>
<url>scm:git:git://github.com/msgpack/msgpack.git</url>
</scm>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.12.1.GA</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
</resources>
<testResources>
<testResource>
<directory>src/test/resources</directory>
</testResource>
</testResources>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.5.1</version>
</plugin>
<plugin>
<artifactId>maven-release-plugin</artifactId>
<configuration>
<!-- do not run site-deploy goal, which is included in the default setting -->
<goals>deploy</goals>
<connectionUrl>scm:git://github.com/msgpack/msgpack.git</connectionUrl>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<reporting>
<plugins>
<!-- Generating JavaDoc -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<configuration>
<doctitle>${project.name} ${project.version} API</doctitle>
<aggregate>true</aggregate>
<locale>en_US</locale>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jxr-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-report-plugin</artifactId>
</plugin>
</plugins>
</reporting>
<repositories>
<repository>
<id>msgpack.org</id>
<name>MessagePack Maven2 Repository</name>
<url>http://msgpack.org/maven2</url>
</repository>
<repository>
<id>repository.jboss.org</id>
<url>https://repository.jboss.org/nexus/content/groups/public/</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
<distributionManagement>
<repository>
<uniqueVersion>false</uniqueVersion>
<id>msgpack.org</id>
<name>Repository at msgpack.org</name>
<url>file://${project.build.directory}/website/maven2/</url>
</repository>
<snapshotRepository>
<uniqueVersion>true</uniqueVersion>
<id>msgpack.org</id>
<name>Repository at msgpack.org</name>
<url>file://${project.build.directory}/website/maven2/</url>
</snapshotRepository>
<!--<repository>
<uniqueVersion>false</uniqueVersion>
<id>deploy.release</id>
<name>Repository for release</name>
<url>${deploy-release-url}</url>
</repository>
<snapshotRepository>
<uniqueVersion>true</uniqueVersion>
<id>deploy.snapshot</id>
<name>Repository for snapshot</name>
<url>${deploy-snapshot-url}</url>
</snapshotRepository>-->
</distributionManagement>
<profiles>
<profile>
<id>release</id>
<build>
<plugins>
<plugin>
<inherited>true</inherited>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.4</version>
<configuration>
<updateReleaseInfo>true</updateReleaseInfo>
</configuration>
</plugin>
</plugins>
</build>
</profile>
</profiles>
</project>

26
java/src/main/java/org/msgpack/AbstractTemplate.java
View File

@ -1,26 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
public abstract class AbstractTemplate implements Template {
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return convert(pac.unpackObject(), to);
}
}

457
java/src/main/java/org/msgpack/BufferedUnpackerImpl.java
View File

@ -1,457 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.math.BigInteger;
abstract class BufferedUnpackerImpl extends UnpackerImpl {
int offset = 0;
int filled = 0;
byte[] buffer = null;
boolean bufferReferenced = false; // TODO zero-copy buffer
private ByteBuffer castBuffer = ByteBuffer.allocate(8);
abstract boolean fill() throws IOException;
final boolean next(UnpackResult result) throws IOException, UnpackException {
if(filled == 0) {
if(!fill()) {
return false;
}
}
do {
int noffset = super.execute(buffer, offset, filled);
if(noffset <= offset) {
if(!fill()) {
return false;
}
continue;
}
offset = noffset;
} while(!super.isFinished());
MessagePackObject obj = super.getData();
super.reset();
result.done(obj);
return true;
}
private final void more(int require) throws IOException, UnpackException {
while(filled - offset < require) {
if(!fill()) {
// FIXME
throw new UnpackException("insufficient buffer");
}
}
}
private final boolean tryMore(int require) throws IOException, UnpackException {
while(filled - offset < require) {
if(!fill()) {
return false;
}
}
return true;
}
private final void advance(int length) {
offset += length;
}
final byte unpackByte() throws IOException, MessageTypeException {
int o = unpackInt();
if(0x7f < o || o < -0x80) {
throw new MessageTypeException();
}
return (byte)o;
}
final short unpackShort() throws IOException, MessageTypeException {
int o = unpackInt();
if(0x7fff < o || o < -0x8000) {
throw new MessageTypeException();
}
return (short)o;
}
final int unpackInt() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
if((b & 0x80) == 0 || (b & 0xe0) == 0xe0) { // Fixnum
advance(1);
return (int)b;
}
switch(b & 0xff) {
case 0xcc: // unsigned int 8
more(2);
advance(2);
return (int)((short)(buffer[offset-1]) & 0xff);
case 0xcd: // unsigned int 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (int)((int)castBuffer.getShort(0) & 0xffff);
case 0xce: // unsigned int 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
{
int o = castBuffer.getInt(0);
if(o < 0) {
throw new MessageTypeException();
}
advance(5);
return o;
}
case 0xcf: // unsigned int 64
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
{
long o = castBuffer.getLong(0);
if(o < 0 || o > 0x7fffffffL) {
throw new MessageTypeException();
}
advance(9);
return (int)o;
}
case 0xd0: // signed int 8
more(2);
advance(2);
return (int)buffer[offset-1];
case 0xd1: // signed int 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (int)castBuffer.getShort(0);
case 0xd2: // signed int 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
return (int)castBuffer.getInt(0);
case 0xd3: // signed int 64
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
{
long o = castBuffer.getLong(0);
if(0x7fffffffL < o || o < -0x80000000L) {
throw new MessageTypeException();
}
advance(9);
return (int)o;
}
default:
throw new MessageTypeException();
}
}
final long unpackLong() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
if((b & 0x80) == 0 || (b & 0xe0) == 0xe0) { // Fixnum
advance(1);
return (long)b;
}
switch(b & 0xff) {
case 0xcc: // unsigned int 8
more(2);
advance(2);
return (long)((short)(buffer[offset-1]) & 0xff);
case 0xcd: // unsigned int 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (long)((int)castBuffer.getShort(0) & 0xffff);
case 0xce: // unsigned int 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
return ((long)castBuffer.getInt(0) & 0xffffffffL);
case 0xcf: // unsigned int 64
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
{
long o = castBuffer.getLong(0);
if(o < 0) {
throw new MessageTypeException();
}
advance(9);
return o;
}
case 0xd0: // signed int 8
more(2);
advance(2);
return (long)buffer[offset-1];
case 0xd1: // signed int 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (long)castBuffer.getShort(0);
case 0xd2: // signed int 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
return (long)castBuffer.getInt(0);
case 0xd3: // signed int 64
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
advance(9);
return (long)castBuffer.getLong(0);
default:
throw new MessageTypeException();
}
}
final BigInteger unpackBigInteger() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
if((b & 0xff) != 0xcf) {
return BigInteger.valueOf(unpackLong());
}
// unsigned int 64
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
advance(9);
long o = castBuffer.getLong(0);
if(o < 0) {
return new BigInteger(1, castBuffer.array());
} else {
return BigInteger.valueOf(o);
}
}
final float unpackFloat() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
switch(b & 0xff) {
case 0xca: // float
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
return castBuffer.getFloat(0);
case 0xcb: // double
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
advance(9);
// FIXME overflow check
return (float)castBuffer.getDouble(0);
default:
throw new MessageTypeException();
}
}
final double unpackDouble() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
switch(b & 0xff) {
case 0xca: // float
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
return (double)castBuffer.getFloat(0);
case 0xcb: // double
more(9);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 8);
advance(9);
return castBuffer.getDouble(0);
default:
throw new MessageTypeException();
}
}
final Object unpackNull() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset] & 0xff;
if(b != 0xc0) { // nil
throw new MessageTypeException();
}
advance(1);
return null;
}
final boolean tryUnpackNull() throws IOException {
if(!tryMore(1)) {
return false;
}
int b = buffer[offset] & 0xff;
if(b != 0xc0) { // nil
return false;
}
advance(1);
return true;
}
final boolean unpackBoolean() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset] & 0xff;
if(b == 0xc2) { // false
advance(1);
return false;
} else if(b == 0xc3) { // true
advance(1);
return true;
} else {
throw new MessageTypeException();
}
}
final int unpackArray() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
if((b & 0xf0) == 0x90) { // FixArray
advance(1);
return (int)(b & 0x0f);
}
switch(b & 0xff) {
case 0xdc: // array 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (int)castBuffer.getShort(0) & 0xffff;
case 0xdd: // array 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
// FIXME overflow check
return castBuffer.getInt(0) & 0x7fffffff;
default:
throw new MessageTypeException();
}
}
final int unpackMap() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
if((b & 0xf0) == 0x80) { // FixMap
advance(1);
return (int)(b & 0x0f);
}
switch(b & 0xff) {
case 0xde: // map 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (int)castBuffer.getShort(0) & 0xffff;
case 0xdf: // map 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
// FIXME overflow check
return castBuffer.getInt(0) & 0x7fffffff;
default:
throw new MessageTypeException();
}
}
final int unpackRaw() throws IOException, MessageTypeException {
more(1);
int b = buffer[offset];
if((b & 0xe0) == 0xa0) { // FixRaw
advance(1);
return (int)(b & 0x1f);
}
switch(b & 0xff) {
case 0xda: // raw 16
more(3);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 2);
advance(3);
return (int)castBuffer.getShort(0) & 0xffff;
case 0xdb: // raw 32
more(5);
castBuffer.rewind();
castBuffer.put(buffer, offset+1, 4);
advance(5);
// FIXME overflow check
return castBuffer.getInt(0) & 0x7fffffff;
default:
throw new MessageTypeException();
}
}
final byte[] unpackRawBody(int length) throws IOException {
more(length);
byte[] bytes = new byte[length];
System.arraycopy(buffer, offset, bytes, 0, length);
advance(length);
return bytes;
}
final byte[] unpackByteArray() throws IOException, MessageTypeException {
int length = unpackRaw();
byte[] body = unpackRawBody(length);
return body;
}
final ByteBuffer unpackByteBuffer() throws IOException, MessageTypeException {
// TODO zero-copy buffer
int length = unpackRaw();
more(length);
ByteBuffer buf = ByteBuffer.wrap(buffer, offset, length);
bufferReferenced = true; // TODO fix magical code
advance(length);
return buf;
}
final String unpackString() throws IOException, MessageTypeException {
int length = unpackRaw();
more(length);
String s;
try {
s = new String(buffer, offset, length, "UTF-8");
} catch (Exception e) {
throw new MessageTypeException();
}
advance(length);
return s;
}
final MessagePackObject unpackObject() throws IOException {
UnpackResult result = new UnpackResult();
if(!next(result)) {
super.reset();
throw new UnpackException("insufficient buffer");
}
return result.getData();
}
}

23
java/src/main/java/org/msgpack/MessageConvertable.java
View File

@ -1,23 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
public interface MessageConvertable {
public void messageConvert(MessagePackObject obj) throws MessageTypeException;
}

23
java/src/main/java/org/msgpack/MessageConverter.java
View File

@ -1,23 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
public interface MessageConverter {
Object convert(MessagePackObject from, Object to) throws MessageTypeException;
}

160
java/src/main/java/org/msgpack/MessagePack.java
View File

@ -1,160 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.OutputStream;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.msgpack.template.TemplateRegistry;
import org.msgpack.template.FieldList;
public class MessagePack {
public static byte[] pack(Object obj) {
ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
try {
new Packer(out).pack(obj);
} catch (IOException e) {
throw new RuntimeException(e);
}
return out.toByteArray();
}
public static void pack(OutputStream out, Object obj) throws IOException {
new Packer(out).pack(obj);
}
public static byte[] pack(Object obj, Template tmpl) throws MessageTypeException {
ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
try {
new Packer(out).pack(obj, tmpl);
} catch (IOException e) {
throw new RuntimeException(e);
}
return out.toByteArray();
}
public static void pack(OutputStream out, Object obj, Template tmpl) throws IOException, MessageTypeException {
new Packer(out).pack(obj, tmpl);
}
public static MessagePackObject unpack(byte[] buffer) throws MessageTypeException {
Unpacker pac = new Unpacker();
pac.wrap(buffer);
try {
return pac.unpackObject();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static Object unpack(byte[] buffer, Template tmpl) throws MessageTypeException {
Unpacker pac = new Unpacker();
pac.wrap(buffer);
try {
return pac.unpack(tmpl);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static <T> T unpack(byte[] buffer, Template tmpl, T to) throws MessageTypeException {
Unpacker pac = new Unpacker();
pac.wrap(buffer);
try {
return pac.unpack(tmpl, to);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static <T> T unpack(byte[] buffer, Class<T> klass) throws MessageTypeException {
Unpacker pac = new Unpacker();
pac.wrap(buffer);
try {
return pac.unpack(klass);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static <T> T unpack(byte[] buffer, T to) throws MessageTypeException {
Unpacker pac = new Unpacker();
pac.wrap(buffer);
try {
return pac.unpack(to);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static MessagePackObject unpack(InputStream in) throws IOException {
Unpacker pac = new Unpacker(in);
return pac.unpackObject();
}
public static Object unpack(InputStream in, Template tmpl) throws IOException, MessageTypeException {
Unpacker pac = new Unpacker(in);
try {
return pac.unpack(tmpl);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static <T> T unpack(InputStream in, Template tmpl, T to) throws IOException, MessageTypeException {
Unpacker pac = new Unpacker(in);
try {
return pac.unpack(tmpl, to);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static <T> T unpack(InputStream in, Class<T> klass) throws IOException, MessageTypeException {
Unpacker pac = new Unpacker(in);
try {
return pac.unpack(klass);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static <T> T unpack(InputStream in, T to) throws IOException, MessageTypeException {
Unpacker pac = new Unpacker(in);
try {
return pac.unpack(to);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void register(Class<?> target) {
TemplateRegistry.register(target);
}
public static void register(Class<?> target, FieldList flist) throws NoSuchFieldException {
TemplateRegistry.register(target, flist);
}
public static void register(Class<?> target, Template tmpl) {
TemplateRegistry.register(target, tmpl);
}
}

160
java/src/main/java/org/msgpack/MessagePackObject.java
View File

@ -1,160 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.util.List;
import java.util.Set;
import java.util.Map;
import java.math.BigInteger;
import org.msgpack.template.TemplateRegistry;
public abstract class MessagePackObject implements Cloneable, MessagePackable {
public boolean isNil() {
return false;
}
public boolean isBooleanType() {
return false;
}
public boolean isIntegerType() {
return false;
}
public boolean isFloatType() {
return false;
}
public boolean isArrayType() {
return false;
}
public boolean isMapType() {
return false;
}
public boolean isRawType() {
return false;
}
public boolean asBoolean() {
throw new MessageTypeException("type error");
}
public byte asByte() {
throw new MessageTypeException("type error");
}
public short asShort() {
throw new MessageTypeException("type error");
}
public int asInt() {
throw new MessageTypeException("type error");
}
public long asLong() {
throw new MessageTypeException("type error");
}
public BigInteger asBigInteger() {
throw new MessageTypeException("type error");
}
public float asFloat() {
throw new MessageTypeException("type error");
}
public double asDouble() {
throw new MessageTypeException("type error");
}
public byte[] asByteArray() {
throw new MessageTypeException("type error");
}
public String asString() {
throw new MessageTypeException("type error");
}
public MessagePackObject[] asArray() {
throw new MessageTypeException("type error");
}
public List<MessagePackObject> asList() {
throw new MessageTypeException("type error");
}
public Map<MessagePackObject, MessagePackObject> asMap() {
throw new MessageTypeException("type error");
}
public byte byteValue() {
throw new MessageTypeException("type error");
}
public short shortValue() {
throw new MessageTypeException("type error");
}
public int intValue() {
throw new MessageTypeException("type error");
}
public long longValue() {
throw new MessageTypeException("type error");
}
public BigInteger bigIntegerValue() {
throw new MessageTypeException("type error");
}
public float floatValue() {
throw new MessageTypeException("type error");
}
public double doubleValue() {
throw new MessageTypeException("type error");
}
abstract public Object clone();
public Object convert(Template tmpl) throws MessageTypeException {
return convert(tmpl, null);
}
public <T> T convert(Template tmpl, T to) throws MessageTypeException {
return (T)tmpl.convert(this, to);
}
public <T> T convert(Class<T> klass) throws MessageTypeException {
return convert(klass, null);
}
public <T> T convert(T to) throws MessageTypeException {
return convert((Class<T>)to.getClass(), to);
}
public <T> T convert(Class<T> klass, T to) throws MessageTypeException {
if(isNil()) {
return null;
}
return (T)convert(TemplateRegistry.lookup(klass), to);
}
}

22
java/src/main/java/org/msgpack/MessagePackTemplateProvider.java
View File

@ -1,22 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack;
public interface MessagePackTemplateProvider {
Template getTemplate();
}

25
java/src/main/java/org/msgpack/MessagePackable.java
View File

@ -1,25 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
public interface MessagePackable {
public void messagePack(Packer pk) throws IOException;
}

25
java/src/main/java/org/msgpack/MessagePacker.java
View File

@ -1,25 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
public interface MessagePacker {
void pack(Packer pk, Object target) throws IOException;
}

35
java/src/main/java/org/msgpack/MessageTypeException.java
View File

@ -1,35 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
public class MessageTypeException extends RuntimeException {
public MessageTypeException() { }
public MessageTypeException(String s) {
super(s);
}
public MessageTypeException(String s, Throwable t) {
super(s, t);
}
public MessageTypeException(Throwable t) {
super(t);
}
}

25
java/src/main/java/org/msgpack/MessageUnpackable.java
View File

@ -1,25 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
public interface MessageUnpackable {
public void messageUnpack(Unpacker pac) throws IOException, MessageTypeException;
}

25
java/src/main/java/org/msgpack/MessageUnpacker.java
View File

@ -1,25 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
public interface MessageUnpacker {
Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException;
}

541
java/src/main/java/org/msgpack/Packer.java
View File

@ -1,541 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.OutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Set;
import java.util.Map;
import java.util.Collection;
import java.math.BigInteger;
import org.msgpack.template.TemplateRegistry;
/**
* Packer enables you to serialize objects into OutputStream.
*
* <pre>
* // create a packer with output stream
* Packer pk = new Packer(System.out);
*
* // store an object with pack() method.
* pk.pack(1);
*
* // you can store String, List, Map, byte[] and primitive types.
* pk.pack(new ArrayList());
* </pre>
*
* You can serialize objects that implements {@link MessagePackable} interface.
*/
public class Packer {
public static void load() { }
protected byte[] castBytes = new byte[9];
//protected ByteBuffer castBuffer = ByteBuffer.wrap(castBytes);
protected OutputStream out;
public Packer(OutputStream out) {
this.out = out;
}
public Packer packByte(byte d) throws IOException {
if(d < -(1<<5)) {
castBytes[0] = (byte)0xd0;
castBytes[1] = d;
out.write(castBytes, 0, 2);
} else {
out.write(d);
}
return this;
}
public Packer packShort(short d) throws IOException {
if(d < -(1<<5)) {
if(d < -(1<<7)) {
// signed 16
castBytes[0] = (byte)0xd1;
// castBuffer.putShort(1, d);
castBytes[1] = (byte)(d >> 8);
castBytes[2] = (byte)(d >> 0);
out.write(castBytes, 0, 3);
} else {
// signed 8
castBytes[0] = (byte)0xd0;
castBytes[1] = (byte)d;
out.write(castBytes, 0, 2);
}
} else if(d < (1<<7)) {
// fixnum
out.write((byte)d);
} else {
if(d < (1<<8)) {
// unsigned 8
castBytes[0] = (byte)0xcc;
castBytes[1] = (byte)d;
out.write(castBytes, 0, 2);
} else {
// unsigned 16
castBytes[0] = (byte)0xcd;
// castBuffer.putShort(1, d);
castBytes[1] = (byte)(d >> 8);
castBytes[2] = (byte)(d >> 0);
out.write(castBytes, 0, 3);
}
}
return this;
}
public Packer packInt(int d) throws IOException {
if(d < -(1<<5)) {
if(d < -(1<<15)) {
// signed 32
castBytes[0] = (byte)0xd2;
// castBuffer.putInt(1, d);
castBytes[1] = (byte)(d >> 24);
castBytes[2] = (byte)(d >> 16);
castBytes[3] = (byte)(d >> 8);
castBytes[4] = (byte)(d >> 0);
out.write(castBytes, 0, 5);
} else if(d < -(1<<7)) {
// signed 16
castBytes[0] = (byte)0xd1;
// castBuffer.putShort(1, (short)d);
castBytes[1] = (byte)(d >> 8);
castBytes[2] = (byte)(d >> 0);
out.write(castBytes, 0, 3);
} else {
// signed 8
castBytes[0] = (byte)0xd0;
castBytes[1] = (byte)d;
out.write(castBytes, 0, 2);
}
} else if(d < (1<<7)) {
// fixnum
out.write((byte)d);
} else {
if(d < (1<<8)) {
// unsigned 8
castBytes[0] = (byte)0xcc;
castBytes[1] = (byte)d;
out.write(castBytes, 0, 2);
} else if(d < (1<<16)) {
// unsigned 16
castBytes[0] = (byte)0xcd;
// castBuffer.putShort(1, (short)d);
castBytes[1] = (byte)(d >> 8);
castBytes[2] = (byte)(d >> 0);
out.write(castBytes, 0, 3);
} else {
// unsigned 32
castBytes[0] = (byte)0xce;
// castBuffer.putInt(1, d);
castBytes[1] = (byte)(d >> 24);
castBytes[2] = (byte)(d >> 16);
castBytes[3] = (byte)(d >> 8);
castBytes[4] = (byte)(d >> 0);
out.write(castBytes, 0, 5);
}
}
return this;
}
public Packer packLong(long d) throws IOException {
if(d < -(1L<<5)) {
if(d < -(1L<<15)) {
if(d < -(1L<<31)) {
// signed 64
castBytes[0] = (byte)0xd3;
// castBuffer.putLong(1, d);
castBytes[1] = (byte)(d >> 56);
castBytes[2] = (byte)(d >> 48);
castBytes[3] = (byte)(d >> 40);
castBytes[4] = (byte)(d >> 32);
castBytes[5] = (byte)(d >> 24);
castBytes[6] = (byte)(d >> 16);
castBytes[7] = (byte)(d >> 8);
castBytes[8] = (byte)(d >> 0);
out.write(castBytes, 0, 9);
} else {
// signed 32
castBytes[0] = (byte)0xd2;
// castBuffer.putInt(1, (int)d);
castBytes[1] = (byte)(d >> 24);
castBytes[2] = (byte)(d >> 16);
castBytes[3] = (byte)(d >> 8);
castBytes[4] = (byte)(d >> 0);
out.write(castBytes, 0, 5);
}
} else {
if(d < -(1<<7)) {
// signed 16
castBytes[0] = (byte)0xd1;
// castBuffer.putShort(1, (short)d);
castBytes[1] = (byte)(d >> 8);
castBytes[2] = (byte)(d >> 0);
out.write(castBytes, 0, 3);
} else {
// signed 8
castBytes[0] = (byte)0xd0;
castBytes[1] = (byte)d;
out.write(castBytes, 0, 2);
}
}
} else if(d < (1<<7)) {
// fixnum
out.write((byte)d);
} else {
if(d < (1L<<16)) {
if(d < (1<<8)) {
// unsigned 8
castBytes[0] = (byte)0xcc;
castBytes[1] = (byte)d;
out.write(castBytes, 0, 2);
} else {
// unsigned 16
castBytes[0] = (byte)0xcd;
// castBuffer.putShort(1, (short)d);
castBytes[1] = (byte)((d & 0x0000ff00) >> 8);
castBytes[2] = (byte)((d & 0x000000ff) >> 0);
out.write(castBytes, 0, 3);
//System.out.println("pack uint 16 "+(short)d);
}
} else {
if(d < (1L<<32)) {
// unsigned 32
castBytes[0] = (byte)0xce;
// castBuffer.putInt(1, (int)d);
castBytes[1] = (byte)((d & 0xff000000) >> 24);
castBytes[2] = (byte)((d & 0x00ff0000) >> 16);
castBytes[3] = (byte)((d & 0x0000ff00) >> 8);
castBytes[4] = (byte)((d & 0x000000ff) >> 0);
out.write(castBytes, 0, 5);
} else {
// unsigned 64
castBytes[0] = (byte)0xcf;
// castBuffer.putLong(1, d);
castBytes[1] = (byte)(d >> 56);
castBytes[2] = (byte)(d >> 48);
castBytes[3] = (byte)(d >> 40);
castBytes[4] = (byte)(d >> 32);
castBytes[5] = (byte)(d >> 24);
castBytes[6] = (byte)(d >> 16);
castBytes[7] = (byte)(d >> 8);
castBytes[8] = (byte)(d >> 0);
out.write(castBytes, 0, 9);
}
}
}
return this;
}
public Packer packBigInteger(BigInteger d) throws IOException {
if(d.bitLength() <= 63) {
return packLong(d.longValue());
} else if(d.bitLength() <= 64 && d.signum() >= 0) {
castBytes[0] = (byte)0xcf;
byte[] barray = d.toByteArray();
castBytes[1] = barray[barray.length-8];
castBytes[2] = barray[barray.length-7];
castBytes[3] = barray[barray.length-6];
castBytes[4] = barray[barray.length-5];
castBytes[5] = barray[barray.length-4];
castBytes[6] = barray[barray.length-3];
castBytes[7] = barray[barray.length-2];
castBytes[8] = barray[barray.length-1];
out.write(castBytes, 0, 9);
return this;
} else {
throw new MessageTypeException("can't pack BigInteger larger than 0xffffffffffffffff");
}
}
public Packer packFloat(float d) throws IOException {
castBytes[0] = (byte)0xca;
// castBuffer.putFloat(1, d);
int f = Float.floatToRawIntBits(d);
castBytes[1] = (byte)(f >> 24);
castBytes[2] = (byte)(f >> 16);
castBytes[3] = (byte)(f >> 8);
castBytes[4] = (byte)(f >> 0);
out.write(castBytes, 0, 5);
return this;
}
public Packer packDouble(double d) throws IOException {
castBytes[0] = (byte)0xcb;
// castBuffer.putDouble(1, d);
long f = Double.doubleToRawLongBits(d);
castBytes[1] = (byte)(f >> 56);
castBytes[2] = (byte)(f >> 48);
castBytes[3] = (byte)(f >> 40);
castBytes[4] = (byte)(f >> 32);
castBytes[5] = (byte)(f >> 24);
castBytes[6] = (byte)(f >> 16);
castBytes[7] = (byte)(f >> 8);
castBytes[8] = (byte)(f >> 0);
out.write(castBytes, 0, 9);
return this;
}
public Packer packNil() throws IOException {
out.write((byte)0xc0);
return this;
}
public Packer packTrue() throws IOException {
out.write((byte)0xc3);
return this;
}
public Packer packFalse() throws IOException {
out.write((byte)0xc2);
return this;
}
public Packer packBoolean(boolean d) throws IOException {
return d ? packTrue() : packFalse();
}
public Packer packArray(int n) throws IOException {
if(n < 16) {
final int d = 0x90 | n;
out.write((byte)d);
} else if(n < 65536) {
castBytes[0] = (byte)0xdc;
// castBuffer.putShort(1, (short)n);
castBytes[1] = (byte)(n >> 8);
castBytes[2] = (byte)(n >> 0);
out.write(castBytes, 0, 3);
} else {
castBytes[0] = (byte)0xdd;
// castBuffer.putInt(1, n);
castBytes[1] = (byte)(n >> 24);
castBytes[2] = (byte)(n >> 16);
castBytes[3] = (byte)(n >> 8);
castBytes[4] = (byte)(n >> 0);
out.write(castBytes, 0, 5);
}
return this;
}
public Packer packMap(int n) throws IOException {
if(n < 16) {
final int d = 0x80 | n;
out.write((byte)d);
} else if(n < 65536) {
castBytes[0] = (byte)0xde;
// castBuffer.putShort(1, (short)n);
castBytes[1] = (byte)(n >> 8);
castBytes[2] = (byte)(n >> 0);
out.write(castBytes, 0, 3);
} else {
castBytes[0] = (byte)0xdf;
// castBuffer.putInt(1, n);
castBytes[1] = (byte)(n >> 24);
castBytes[2] = (byte)(n >> 16);
castBytes[3] = (byte)(n >> 8);
castBytes[4] = (byte)(n >> 0);
out.write(castBytes, 0, 5);
}
return this;
}
public Packer packRaw(int n) throws IOException {
if(n < 32) {
final int d = 0xa0 | n;
out.write((byte)d);
} else if(n < 65536) {
castBytes[0] = (byte)0xda;
// castBuffer.putShort(1, (short)n);
castBytes[1] = (byte)(n >> 8);
castBytes[2] = (byte)(n >> 0);
out.write(castBytes, 0, 3);
} else {
castBytes[0] = (byte)0xdb;
// castBuffer.putInt(1, n);
castBytes[1] = (byte)(n >> 24);
castBytes[2] = (byte)(n >> 16);
castBytes[3] = (byte)(n >> 8);
castBytes[4] = (byte)(n >> 0);
out.write(castBytes, 0, 5);
}
return this;
}
public Packer packRawBody(byte[] b) throws IOException {
out.write(b);
return this;
}
public Packer packRawBody(byte[] b, int off, int length) throws IOException {
out.write(b, off, length);
return this;
}
public Packer packByteArray(byte[] b) throws IOException {
packRaw(b.length);
return packRawBody(b, 0, b.length);
}
public Packer packByteArray(byte[] b, int off, int length) throws IOException {
packRaw(length);
return packRawBody(b, off, length);
}
public Packer packByteBuffer(ByteBuffer buf) throws IOException {
packRaw(buf.remaining());
return packRawBody(buf.array(), buf.arrayOffset() + buf.position(), buf.remaining());
}
public Packer packString(String s) throws IOException {
byte[] b = ((String)s).getBytes("UTF-8");
packRaw(b.length);
return packRawBody(b);
}
public Packer pack(boolean o) throws IOException {
if(o) {
return packTrue();
} else {
return packFalse();
}
}
public Packer pack(byte o) throws IOException {
return packByte(o);
}
public Packer pack(short o) throws IOException {
return packShort(o);
}
public Packer pack(int o) throws IOException {
return packInt(o);
}
public Packer pack(long o) throws IOException {
return packLong(o);
}
public Packer pack(float o) throws IOException {
return packFloat(o);
}
public Packer pack(double o) throws IOException {
return packDouble(o);
}
public Packer pack(Boolean o) throws IOException {
if(o == null) { return packNil(); }
if(o) {
return packTrue();
} else {
return packFalse();
}
}
public Packer pack(Byte o) throws IOException {
if(o == null) { return packNil(); }
return packByte(o);
}
public Packer pack(Short o) throws IOException {
if(o == null) { return packNil(); }
return packShort(o);
}
public Packer pack(Integer o) throws IOException {
if(o == null) { return packNil(); }
return packInt(o);
}
public Packer pack(Long o) throws IOException {
if(o == null) { return packNil(); }
return packLong(o);
}
public Packer pack(BigInteger o) throws IOException {
if(o == null) { return packNil(); }
return packBigInteger(o);
}
public Packer pack(Float o) throws IOException {
if(o == null) { return packNil(); }
return packFloat(o);
}
public Packer pack(Double o) throws IOException {
if(o == null) { return packNil(); }
return packDouble(o);
}
public Packer pack(String o) throws IOException {
if(o == null) { return packNil(); }
return packString(o);
}
public Packer pack(byte[] o) throws IOException {
if(o == null) { return packNil(); }
packRaw(o.length);
return packRawBody(o);
}
public Packer pack(ByteBuffer o) throws IOException {
if (o == null) { return packNil(); }
packRaw(o.remaining());
return packRawBody(o.array(), o.arrayOffset() + o.position(), o.remaining());
}
public Packer pack(List o) throws IOException {
if(o == null) { return packNil(); }
packArray(o.size());
for(Object i : o) { pack(i); }
return this;
}
public Packer pack(Map o) throws IOException {
if(o == null) { return packNil(); }
packMap(o.size());
for(Map.Entry<Object,Object> e : ((Map<Object,Object>)o).entrySet()) {
pack(e.getKey());
pack(e.getValue());
}
return this;
}
public Packer pack(MessagePackable o) throws IOException {
if(o == null) { return packNil(); }
o.messagePack(this);
return this;
}
public Packer pack(Object o) throws IOException {
if(o == null) { return packNil(); }
TemplateRegistry.lookup(o.getClass()).pack(this, o);
return this;
}
public Packer pack(Object o, Template tmpl) throws IOException {
tmpl.pack(this, o);
return this;
}
}

21
java/src/main/java/org/msgpack/Template.java
View File

@ -1,21 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack;
public interface Template extends MessagePacker, MessageUnpacker, MessageConverter {
}

119
java/src/main/java/org/msgpack/Templates.java
View File

@ -1,119 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import org.msgpack.template.*;
public class Templates {
public static Template tNullable(Template elementTemplate) {
return new NullableTemplate(elementTemplate);
}
public static final Template TAny = AnyTemplate.getInstance();
public static Template tAny() {
return TAny;
}
public static Template tList(Template elementTemplate) {
return new ListTemplate(elementTemplate);
}
public static Template tMap(Template keyTemplate, Template valueTemplate) {
return new MapTemplate(keyTemplate, valueTemplate);
}
public static Template tCollection(Template elementTemplate) {
return new CollectionTemplate(elementTemplate);
}
public static Template tClass(Class target) {
Template tmpl = TemplateRegistry.lookup(target);
if(tmpl == null) {
// FIXME
}
return tmpl;
}
public static final Template TByte = ByteTemplate.getInstance();
public static Template tByte() {
return TByte;
}
public static final Template TShort = ShortTemplate.getInstance();
public static Template tShort() {
return TShort;
}
public static final Template TInteger = IntegerTemplate.getInstance();
public static Template tInteger() {
return TInteger;
}
public static final Template TLong = LongTemplate.getInstance();
public static Template tLong() {
return TLong;
}
public static final Template TBigInteger = BigIntegerTemplate.getInstance();
public static Template tBigInteger() {
return TBigInteger;
}
public static final Template TBigDecimal = BigDecimalTemplate.getInstance();
public static Template tBigDecimal() {
return TBigDecimal;
}
public static final Template TFloat = FloatTemplate.getInstance();
public static Template tFloat() {
return TFloat;
}
public static final Template TDouble = DoubleTemplate.getInstance();
public static Template tDouble() {
return TDouble;
}
public static final Template TBoolean = BooleanTemplate.getInstance();
public static Template tBoolean() {
return TBoolean;
}
public static final Template TString = StringTemplate.getInstance();
public static Template tString() {
return TString;
}
public static final Template TByteArray = ByteArrayTemplate.getInstance();
public static Template tByteArray() {
return TByteArray;
}
public static final Template TByteBuffer = ByteBufferTemplate.getInstance();
public static Template tByteBuffer() {
return TByteBuffer;
}
public static final Template TDate = DateTemplate.getInstance();
public static Template tDate() {
return TDate;
}
}

29
java/src/main/java/org/msgpack/UnpackException.java
View File

@ -1,29 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
public class UnpackException extends IOException {
public UnpackException() { }
public UnpackException(String s) {
super(s);
}
}

53
java/src/main/java/org/msgpack/UnpackIterator.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.io.IOException;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class UnpackIterator extends UnpackResult implements Iterator<MessagePackObject> {
private Unpacker pac;
UnpackIterator(Unpacker pac) {
super();
this.pac = pac;
}
public boolean hasNext() {
if(finished) { return true; }
try {
return pac.next(this);
} catch (IOException e) {
return false;
}
}
public MessagePackObject next() {
if(!finished && !hasNext()) {
throw new NoSuchElementException();
}
finished = false;
return data;
}
public void remove() {
throw new UnsupportedOperationException();
}
}

42
java/src/main/java/org/msgpack/UnpackResult.java
View File

@ -1,42 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
public class UnpackResult {
protected boolean finished = false;
protected MessagePackObject data = null;
public boolean isFinished() {
return finished;
}
public MessagePackObject getData() {
return data;
}
public void reset() {
finished = false;
data = null;
}
void done(MessagePackObject obj) {
finished = true;
data = obj;
}
}

610
java/src/main/java/org/msgpack/Unpacker.java
View File

@ -1,610 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.lang.Iterable;
import java.io.InputStream;
import java.io.IOException;
import java.util.Iterator;
import java.nio.ByteBuffer;
import java.math.BigInteger;
import org.msgpack.template.TemplateRegistry;
/**
* Unpacker enables you to deserialize objects from stream.
*
* Unpacker provides Buffered API, Unbuffered API and
* Direct Conversion API.
*
* Buffered API uses the internal buffer of the Unpacker.
* Following code uses Buffered API with an InputStream:
* <pre>
* // create an unpacker with input stream
* Unpacker pac = new Unpacker(System.in);
*
* // take a object out using next() method, or ...
* UnpackResult result = pac.next();
*
* // use an iterator.
* for(MessagePackObject obj : pac) {
* // use MessageConvertable interface to convert the
* // the generic object to the specific type.
* }
* </pre>
*
* Following code doesn't use the input stream and feeds buffer
* using {@link feed(byte[])} method. This is useful to use
* special stream like zlib or event-driven I/O library.
* <pre>
* // create an unpacker without input stream
* Unpacker pac = new Unpacker();
*
* // feed buffer to the internal buffer.
* pac.feed(input_bytes);
*
* // use next() method or iterators.
* for(MessagePackObject obj : pac) {
* // ...
* }
* </pre>
*
* The combination of {@link reserveBuffer()}, {@link getBuffer()},
* {@link getBufferOffset()}, {@link getBufferCapacity()} and
* {@link bufferConsumed()} is useful to omit copying.
* <pre>
* // create an unpacker without input stream
* Unpacker pac = new Unpacker();
*
* // reserve internal buffer at least 1024 bytes.
* pac.reserveBuffer(1024);
*
* // feed buffer to the internal buffer upto pac.getBufferCapacity() bytes.
* System.in.read(pac.getBuffer(), pac.getBufferOffset(), pac.getBufferCapacity());
*
* // use next() method or iterators.
* for(MessagePackObject obj : pac) {
* // ...
* }
* </pre>
*
* Unbuffered API doesn't initialize the internal buffer.
* You can manage the buffer manually.
* <pre>
* // create an unpacker with input stream
* Unpacker pac = new Unpacker(System.in);
*
* // manage the buffer manually.
* byte[] buffer = new byte[1024];
* int filled = System.in.read(buffer);
* int offset = 0;
*
* // deserialize objects using execute() method.
* int nextOffset = pac.execute(buffer, offset, filled);
*
* // take out object if deserialized object is ready.
* if(pac.isFinished()) {
* MessagePackObject obj = pac.getData();
* // ...
* }
* </pre>
*/
public class Unpacker implements Iterable<MessagePackObject> {
// buffer:
// +---------------------------------------------+
// | [object] | [obje| unparsed ... | unused ...|
// +---------------------------------------------+
// ^ parsed
// ^ offset
// ^ filled
// ^ buffer.length
private static final int DEFAULT_BUFFER_SIZE = 32*1024;
protected int parsed;
protected int bufferReserveSize;
protected InputStream stream;
final class BufferedUnpackerMixin extends BufferedUnpackerImpl {
boolean fill() throws IOException {
if(stream == null) {
return false;
}
reserveBuffer(bufferReserveSize);
int rl = stream.read(buffer, filled, buffer.length - filled);
// equals: stream.read(getBuffer(), getBufferOffset(), getBufferCapacity());
if(rl <= 0) {
return false;
}
bufferConsumed(rl);
return true;
}
};
final BufferedUnpackerMixin impl = new BufferedUnpackerMixin();
/**
* Calls {@link Unpacker(DEFAULT_BUFFER_SIZE)}
*/
public Unpacker() {
this(DEFAULT_BUFFER_SIZE);
}
/**
* Calls {@link Unpacker(null, bufferReserveSize)}
*/
public Unpacker(int bufferReserveSize) {
this(null, bufferReserveSize);
}
/**
* Calls {@link Unpacker(stream, DEFAULT_BUFFER_SIZE)}
*/
public Unpacker(InputStream stream) {
this(stream, DEFAULT_BUFFER_SIZE);
}
/**
* Constructs the unpacker.
* The stream is used to fill the buffer when more buffer is required by {@link next()} or {@link UnpackIterator#hasNext()} method.
* @param stream input stream to fill the buffer
* @param bufferReserveSize threshold size to expand the size of buffer
*/
public Unpacker(InputStream stream, int bufferReserveSize) {
this.parsed = 0;
this.bufferReserveSize = bufferReserveSize/2;
this.stream = stream;
}
/**
* Gets the input stream.
* @return the input stream. it may be null.
*/
public InputStream getStream() {
return this.stream;
}
/**
* Sets the input stream.
* @param stream the input stream to set.
*/
public void setStream(InputStream stream) {
this.stream = stream;
}
/**
* Fills the buffer with the specified buffer.
*/
public void feed(byte[] buffer) {
feed(buffer, 0, buffer.length);
}
/**
* Fills the buffer with the specified buffer.
*/
public void feed(byte[] buffer, int offset, int length) {
reserveBuffer(length);
System.arraycopy(buffer, offset, impl.buffer, impl.offset, length);
bufferConsumed(length);
}
/**
* Fills the buffer with the specified buffer.
*/
public void feed(ByteBuffer buffer) {
int length = buffer.remaining();
if (length == 0) return;
reserveBuffer(length);
buffer.get(impl.buffer, impl.offset, length);
bufferConsumed(length);
}
/**
* Swaps the internal buffer with the specified buffer.
* This method doesn't copy the buffer and the its contents will be rewritten by {@link fill()} or {@link feed(byte[])} method.
*/
public void wrap(byte[] buffer) {
wrap(buffer, 0, buffer.length);
}
/**
* Swaps the internal buffer with the specified buffer.
* This method doesn't copy the buffer and the its contents will be rewritten by {@link fill()} or {@link feed(byte[])} method.
*/
public void wrap(byte[] buffer, int offset, int length) {
impl.buffer = buffer;
impl.offset = offset;
impl.filled = length;
impl.bufferReferenced = false; // TODO zero-copy buffer
}
/**
* Fills the internal using the input stream.
* @return false if the stream is null or stream.read returns <= 0.
*/
public boolean fill() throws IOException {
return impl.fill();
}
/**
* Returns the iterator that calls {@link next()} method repeatedly.
*/
public Iterator<MessagePackObject> iterator() {
return new UnpackIterator(this);
}
/**
* Deserializes one object and returns it.
* @return {@link UnpackResult#isFinished()} returns false if the buffer is insufficient to deserialize one object.
*/
public UnpackResult next() throws IOException, UnpackException {
UnpackResult result = new UnpackResult();
impl.next(result);
return result;
}
/**
* Deserializes one object and returns it.
* @return false if the buffer is insufficient to deserialize one object.
*/
public boolean next(UnpackResult result) throws IOException, UnpackException {
return impl.next(result);
}
/**
* Reserve free space of the internal buffer at least specified size and expands {@link getBufferCapacity()}.
*/
public void reserveBuffer(int require) {
if(impl.buffer == null) {
int nextSize = (bufferReserveSize < require) ? require : bufferReserveSize;
impl.buffer = new byte[nextSize];
impl.bufferReferenced = false; // TODO zero-copy buffer
return;
}
if(!impl.bufferReferenced) { // TODO zero-copy buffer
if(impl.filled <= impl.offset) {
// rewind the buffer
impl.filled = 0;
impl.offset = 0;
}
}
if(impl.buffer.length - impl.filled >= require) {
return;
}
int nextSize = impl.buffer.length * 2;
int notParsed = impl.filled - impl.offset;
while(nextSize < require + notParsed) {
nextSize *= 2;
}
byte[] tmp = new byte[nextSize];
System.arraycopy(impl.buffer, impl.offset, tmp, 0, impl.filled - impl.offset);
impl.buffer = tmp;
impl.filled = notParsed;
impl.offset = 0;
impl.bufferReferenced = false; // TODO zero-copy buffer
}
/**
* Returns the internal buffer.
*/
public byte[] getBuffer() {
return impl.buffer;
}
/**
* Returns the size of free space of the internal buffer.
*/
public int getBufferCapacity() {
return impl.buffer.length - impl.filled;
}
/**
* Returns the offset of free space in the internal buffer.
*/
public int getBufferOffset() {
return impl.filled;
}
/**
* Moves front the offset of the free space in the internal buffer.
* Call this method after fill the buffer manually using {@link reserveBuffer()}, {@link getBuffer()}, {@link getBufferOffset()} and {@link getBufferCapacity()} methods.
*/
public void bufferConsumed(int size) {
impl.filled += size;
}
/**
* Deserializes one object upto the offset of the internal buffer.
* Call {@link reset()} method before calling this method again.
* @return true if one object is deserialized. Use {@link getData()} to get the deserialized object.
*/
public boolean execute() throws UnpackException {
int noffset = impl.execute(impl.buffer, impl.offset, impl.filled);
if(noffset <= impl.offset) {
return false;
}
parsed += noffset - impl.offset;
impl.offset = noffset;
return impl.isFinished();
}
/**
* Deserializes one object over the specified buffer.
* This method doesn't use the internal buffer.
* Use {@link isFinished()} method to known a object is ready to get.
* Call {@link reset()} method before calling this method again.
* @return offset position that is parsed.
*/
public int execute(byte[] buffer) throws UnpackException {
return execute(buffer, 0, buffer.length);
}
/**
* Deserializes one object over the specified buffer.
* This method doesn't use the internal buffer.
* Use {@link isFinished()} method to known a object is ready to get.
* Call {@link reset()} method before calling this method again.
* @return offset position that is parsed.
*/
public int execute(byte[] buffer, int offset, int length) throws UnpackException {
int noffset = impl.execute(buffer, offset, length);
if(impl.isFinished()) {
impl.resetState();
}
return noffset;
}
/**
* Gets the object deserialized by {@link execute(byte[])} method.
*/
public MessagePackObject getData() {
return impl.getData();
}
/**
* Returns true if an object is ready to get with {@link getData()} method.
*/
public boolean isFinished() {
return impl.isFinished();
}
/**
* Resets the internal state of the unpacker.
*/
public void reset() {
impl.reset();
}
public int getMessageSize() {
return parsed - impl.offset + impl.filled;
}
public int getParsedSize() {
return parsed;
}
public int getNonParsedSize() {
return impl.filled - impl.offset;
}
public void skipNonparsedBuffer(int size) {
impl.offset += size;
}
public void removeNonparsedBuffer() {
impl.filled = impl.offset;
}
/**
* Gets one {@code byte} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code byte}.
*/
public byte unpackByte() throws IOException, MessageTypeException {
return impl.unpackByte();
}
/**
* Gets one {@code short} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code short}.
*/
public short unpackShort() throws IOException, MessageTypeException {
return impl.unpackShort();
}
/**
* Gets one {@code int} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code int}.
*/
public int unpackInt() throws IOException, MessageTypeException {
return impl.unpackInt();
}
/**
* Gets one {@code long} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code long}.
*/
public long unpackLong() throws IOException, MessageTypeException {
return impl.unpackLong();
}
/**
* Gets one {@code BigInteger} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code BigInteger}.
*/
public BigInteger unpackBigInteger() throws IOException, MessageTypeException {
return impl.unpackBigInteger();
}
/**
* Gets one {@code float} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code float}.
*/
public float unpackFloat() throws IOException, MessageTypeException {
return impl.unpackFloat();
}
/**
* Gets one {@code double} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code double}.
*/
public double unpackDouble() throws IOException, MessageTypeException {
return impl.unpackDouble();
}
/**
* Gets one {@code null} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code null}.
*/
public Object unpackNull() throws IOException, MessageTypeException {
return impl.unpackNull();
}
/**
* Gets one {@code boolean} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code boolean}.
*/
public boolean unpackBoolean() throws IOException, MessageTypeException {
return impl.unpackBoolean();
}
/**
* Gets one array header from the buffer.
* This method calls {@link fill()} method if needed.
* @return the length of the map. There are {@code retval} objects to get.
* @throws MessageTypeException the first value of the buffer is not a array.
*/
public int unpackArray() throws IOException, MessageTypeException {
return impl.unpackArray();
}
/**
* Gets one map header from the buffer.
* This method calls {@link fill()} method if needed.
* @return the length of the map. There are {@code retval * 2} objects to get.
* @throws MessageTypeException the first value of the buffer is not a map.
*/
public int unpackMap() throws IOException, MessageTypeException {
return impl.unpackMap();
}
/**
* Gets one raw header from the buffer.
* This method calls {@link fill()} method if needed.
* @return the length of the raw bytes. There are {@code retval} bytes to get.
* @throws MessageTypeException the first value of the buffer is not a raw bytes.
*/
public int unpackRaw() throws IOException, MessageTypeException {
return impl.unpackRaw();
}
/**
* Gets one raw body from the buffer.
* This method calls {@link fill()} method if needed.
*/
public byte[] unpackRawBody(int length) throws IOException {
return impl.unpackRawBody(length);
}
/**
* Gets one raw object (header + body) from the buffer.
* This method calls {@link fill()} method if needed.
*/
public byte[] unpackByteArray() throws IOException {
return impl.unpackByteArray();
}
/**
* Gets one raw object (header + body) from the buffer.
* This method calls {@link fill()} method if needed.
*/
public ByteBuffer unpackByteBuffer() throws IOException {
return impl.unpackByteBuffer();
}
/**
* Gets one {@code String} value from the buffer.
* This method calls {@link fill()} method if needed.
* @throws MessageTypeException the first value of the buffer is not a {@code String}.
*/
final public String unpackString() throws IOException, MessageTypeException {
return impl.unpackString();
}
/**
* Gets one {@code Object} value from the buffer.
* This method calls {@link fill()} method if needed.
*/
final public MessagePackObject unpackObject() throws IOException {
return impl.unpackObject();
}
final public boolean tryUnpackNull() throws IOException {
return impl.tryUnpackNull();
}
final public void unpack(MessageUnpackable obj) throws IOException, MessageTypeException {
obj.messageUnpack(this);
}
//final public MessagePackObject unpack() throws IOException {
// return unpackObject();
//}
final public <T> T unpack(T to) throws IOException, MessageTypeException {
return unpack((Class<T>)to.getClass(), to);
}
final public <T> T unpack(Class<T> klass) throws IOException, MessageTypeException {
return unpack(klass, null);
}
final public <T> T unpack(Class<T> klass, T to) throws IOException, MessageTypeException {
if(tryUnpackNull()) { return null; }
return (T)TemplateRegistry.lookup(klass).unpack(this, to);
}
final public Object unpack(Template tmpl) throws IOException, MessageTypeException {
return unpack(tmpl, null);
}
final public <T> T unpack(Template tmpl, T to) throws IOException, MessageTypeException {
return (T)tmpl.unpack(this, to);
}
}

473
java/src/main/java/org/msgpack/UnpackerImpl.java
View File

@ -1,473 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack;
import java.nio.ByteBuffer;
import java.math.BigInteger;
import org.msgpack.object.*;
public class UnpackerImpl {
static final int CS_HEADER = 0x00;
static final int CS_FLOAT = 0x0a;
static final int CS_DOUBLE = 0x0b;
static final int CS_UINT_8 = 0x0c;
static final int CS_UINT_16 = 0x0d;
static final int CS_UINT_32 = 0x0e;
static final int CS_UINT_64 = 0x0f;
static final int CS_INT_8 = 0x10;
static final int CS_INT_16 = 0x11;
static final int CS_INT_32 = 0x12;
static final int CS_INT_64 = 0x13;
static final int CS_RAW_16 = 0x1a;
static final int CS_RAW_32 = 0x1b;
static final int CS_ARRAY_16 = 0x1c;
static final int CS_ARRAY_32 = 0x1d;
static final int CS_MAP_16 = 0x1e;
static final int CS_MAP_32 = 0x1f;
static final int ACS_RAW_VALUE = 0x20;
static final int CT_ARRAY_ITEM = 0x00;
static final int CT_MAP_KEY = 0x01;
static final int CT_MAP_VALUE = 0x02;
static final int MAX_STACK_SIZE = 32;
private int cs;
private int trail;
private int top;
private int[] stack_ct = new int[MAX_STACK_SIZE];
private int[] stack_count = new int[MAX_STACK_SIZE];
private Object[] stack_obj = new Object[MAX_STACK_SIZE];
private int top_ct;
private int top_count;
private Object top_obj;
private ByteBuffer castBuffer = ByteBuffer.allocate(8);
private boolean finished = false;
private MessagePackObject data = null;
public UnpackerImpl()
{
reset();
}
public final MessagePackObject getData()
{
return data;
}
public final boolean isFinished()
{
return finished;
}
public final void resetState() {
cs = CS_HEADER;
top = -1;
top_ct = 0;
top_count = 0;
top_obj = null;
}
public final void reset()
{
resetState();
finished = false;
data = null;
}
@SuppressWarnings("unchecked")
public final int execute(byte[] src, int off, int length) throws UnpackException
{
if(off >= length) { return off; }
int limit = length;
int i = off;
int count;
Object obj = null;
_out: do {
_header_again: {
//System.out.println("while i:"+i+" limit:"+limit);
int b = src[i];
_push: {
_fixed_trail_again:
if(cs == CS_HEADER) {
if((b & 0x80) == 0) { // Positive Fixnum
//System.out.println("positive fixnum "+b);
obj = IntegerType.create((byte)b);
break _push;
}
if((b & 0xe0) == 0xe0) { // Negative Fixnum
//System.out.println("negative fixnum "+b);
obj = IntegerType.create((byte)b);
break _push;
}
if((b & 0xe0) == 0xa0) { // FixRaw
trail = b & 0x1f;
if(trail == 0) {
obj = RawType.create(new byte[0]);
break _push;
}
cs = ACS_RAW_VALUE;
break _fixed_trail_again;
}
if((b & 0xf0) == 0x90) { // FixArray
if(top >= MAX_STACK_SIZE) {
throw new UnpackException("parse error");
}
count = b & 0x0f;
//System.out.println("fixarray count:"+count);
obj = new MessagePackObject[count];
if(count == 0) {
obj = ArrayType.create((MessagePackObject[])obj);
break _push;
}
++top;
stack_obj[top] = top_obj;
stack_ct[top] = top_ct;
stack_count[top] = top_count;
top_obj = obj;
top_ct = CT_ARRAY_ITEM;
top_count = count;
break _header_again;
}
if((b & 0xf0) == 0x80) { // FixMap
if(top >= MAX_STACK_SIZE) {
throw new UnpackException("parse error");
}
count = b & 0x0f;
obj = new MessagePackObject[count*2];
if(count == 0) {
obj = MapType.create((MessagePackObject[])obj);
break _push;
}
//System.out.println("fixmap count:"+count);
++top;
stack_obj[top] = top_obj;
stack_ct[top] = top_ct;
stack_count[top] = top_count;
top_obj = obj;
top_ct = CT_MAP_KEY;
top_count = count;
break _header_again;
}
switch(b & 0xff) { // FIXME
case 0xc0: // nil
obj = NilType.create();
break _push;
case 0xc2: // false
obj = BooleanType.create(false);
break _push;
case 0xc3: // true
obj = BooleanType.create(true);
break _push;
case 0xca: // float
case 0xcb: // double
case 0xcc: // unsigned int 8
case 0xcd: // unsigned int 16
case 0xce: // unsigned int 32
case 0xcf: // unsigned int 64
case 0xd0: // signed int 8
case 0xd1: // signed int 16
case 0xd2: // signed int 32
case 0xd3: // signed int 64
trail = 1 << (b & 0x03);
cs = b & 0x1f;
//System.out.println("a trail "+trail+" cs:"+cs);
break _fixed_trail_again;
case 0xda: // raw 16
case 0xdb: // raw 32
case 0xdc: // array 16
case 0xdd: // array 32
case 0xde: // map 16
case 0xdf: // map 32
trail = 2 << (b & 0x01);
cs = b & 0x1f;
//System.out.println("b trail "+trail+" cs:"+cs);
break _fixed_trail_again;
default:
//System.out.println("unknown b "+(b&0xff));
throw new UnpackException("parse error");
}
} // _fixed_trail_again
do {
_fixed_trail_again: {
if(limit - i <= trail) { break _out; }
int n = i + 1;
i += trail;
switch(cs) {
case CS_FLOAT:
castBuffer.rewind();
castBuffer.put(src, n, 4);
obj = FloatType.create( castBuffer.getFloat(0) );
//System.out.println("float "+obj);
break _push;
case CS_DOUBLE:
castBuffer.rewind();
castBuffer.put(src, n, 8);
obj = FloatType.create( castBuffer.getDouble(0) );
//System.out.println("double "+obj);
break _push;
case CS_UINT_8:
//System.out.println(n);
//System.out.println(src[n]);
//System.out.println(src[n+1]);
//System.out.println(src[n-1]);
obj = IntegerType.create( (short)((src[n]) & 0xff) );
//System.out.println("uint8 "+obj);
break _push;
case CS_UINT_16:
//System.out.println(src[n]);
//System.out.println(src[n+1]);
castBuffer.rewind();
castBuffer.put(src, n, 2);
obj = IntegerType.create( ((int)castBuffer.getShort(0)) & 0xffff );
//System.out.println("uint 16 "+obj);
break _push;
case CS_UINT_32:
castBuffer.rewind();
castBuffer.put(src, n, 4);
obj = IntegerType.create( ((long)castBuffer.getInt(0)) & 0xffffffffL );
//System.out.println("uint 32 "+obj);
break _push;
case CS_UINT_64:
castBuffer.rewind();
castBuffer.put(src, n, 8);
{
long o = castBuffer.getLong(0);
if(o < 0) {
obj = IntegerType.create(new BigInteger(1, castBuffer.array()));
} else {
obj = IntegerType.create(o);
}
}
break _push;
case CS_INT_8:
obj = IntegerType.create( src[n] );
break _push;
case CS_INT_16:
castBuffer.rewind();
castBuffer.put(src, n, 2);
obj = IntegerType.create( castBuffer.getShort(0) );
break _push;
case CS_INT_32:
castBuffer.rewind();
castBuffer.put(src, n, 4);
obj = IntegerType.create( castBuffer.getInt(0) );
break _push;
case CS_INT_64:
castBuffer.rewind();
castBuffer.put(src, n, 8);
obj = IntegerType.create( castBuffer.getLong(0) );
break _push;
case CS_RAW_16:
castBuffer.rewind();
castBuffer.put(src, n, 2);
trail = ((int)castBuffer.getShort(0)) & 0xffff;
if(trail == 0) {
obj = RawType.create(new byte[0]);
break _push;
}
cs = ACS_RAW_VALUE;
break _fixed_trail_again;
case CS_RAW_32:
castBuffer.rewind();
castBuffer.put(src, n, 4);
// FIXME overflow check
trail = castBuffer.getInt(0) & 0x7fffffff;
if(trail == 0) {
obj = RawType.create(new byte[0]);
break _push;
}
cs = ACS_RAW_VALUE;
break _fixed_trail_again;
case ACS_RAW_VALUE: {
// TODO zero-copy buffer
byte[] raw = new byte[trail];
System.arraycopy(src, n, raw, 0, trail);
obj = RawType.create(raw);
}
break _push;
case CS_ARRAY_16:
if(top >= MAX_STACK_SIZE) {
throw new UnpackException("parse error");
}
castBuffer.rewind();
castBuffer.put(src, n, 2);
count = ((int)castBuffer.getShort(0)) & 0xffff;
obj = new MessagePackObject[count];
if(count == 0) {
obj = ArrayType.create((MessagePackObject[])obj);
break _push;
}
++top;
stack_obj[top] = top_obj;
stack_ct[top] = top_ct;
stack_count[top] = top_count;
top_obj = obj;
top_ct = CT_ARRAY_ITEM;
top_count = count;
break _header_again;
case CS_ARRAY_32:
if(top >= MAX_STACK_SIZE) {
throw new UnpackException("parse error");
}
castBuffer.rewind();
castBuffer.put(src, n, 4);
// FIXME overflow check
count = castBuffer.getInt(0) & 0x7fffffff;
obj = new MessagePackObject[count];
if(count == 0) {
obj = ArrayType.create((MessagePackObject[])obj);
break _push;
}
++top;
stack_obj[top] = top_obj;
stack_ct[top] = top_ct;
stack_count[top] = top_count;
top_obj = obj;
top_ct = CT_ARRAY_ITEM;
top_count = count;
break _header_again;
case CS_MAP_16:
if(top >= MAX_STACK_SIZE) {
throw new UnpackException("parse error");
}
castBuffer.rewind();
castBuffer.put(src, n, 2);
count = ((int)castBuffer.getShort(0)) & 0xffff;
obj = new MessagePackObject[count*2];
if(count == 0) {
obj = MapType.create((MessagePackObject[])obj);
break _push;
}
//System.out.println("fixmap count:"+count);
++top;
stack_obj[top] = top_obj;
stack_ct[top] = top_ct;
stack_count[top] = top_count;
top_obj = obj;
top_ct = CT_MAP_KEY;
top_count = count;
break _header_again;
case CS_MAP_32:
if(top >= MAX_STACK_SIZE) {
throw new UnpackException("parse error");
}
castBuffer.rewind();
castBuffer.put(src, n, 4);
// FIXME overflow check
count = castBuffer.getInt(0) & 0x7fffffff;
obj = new MessagePackObject[count*2];
if(count == 0) {
obj = MapType.create((MessagePackObject[])obj);
break _push;
}
//System.out.println("fixmap count:"+count);
++top;
stack_obj[top] = top_obj;
stack_ct[top] = top_ct;
stack_count[top] = top_count;
top_obj = obj;
top_ct = CT_MAP_KEY;
top_count = count;
break _header_again;
default:
throw new UnpackException("parse error");
}
} // _fixed_trail_again
} while(true);
} // _push
do {
_push: {
//System.out.println("push top:"+top);
if(top == -1) {
++i;
data = (MessagePackObject)obj;
finished = true;
break _out;
}
switch(top_ct) {
case CT_ARRAY_ITEM: {
//System.out.println("array item "+obj);
Object[] ar = (Object[])top_obj;
ar[ar.length - top_count] = obj;
if(--top_count == 0) {
top_obj = stack_obj[top];
top_ct = stack_ct[top];
top_count = stack_count[top];
obj = ArrayType.create((MessagePackObject[])ar);
stack_obj[top] = null;
--top;
break _push;
}
break _header_again;
}
case CT_MAP_KEY: {
//System.out.println("map key:"+top+" "+obj);
Object[] mp = (Object[])top_obj;
mp[mp.length - top_count*2] = obj;
top_ct = CT_MAP_VALUE;
break _header_again;
}
case CT_MAP_VALUE: {
//System.out.println("map value:"+top+" "+obj);
Object[] mp = (Object[])top_obj;
mp[mp.length - top_count*2 + 1] = obj;
if(--top_count == 0) {
top_obj = stack_obj[top];
top_ct = stack_ct[top];
top_count = stack_count[top];
obj = MapType.create((MessagePackObject[])mp);
stack_obj[top] = null;
--top;
break _push;
}
top_ct = CT_MAP_KEY;
break _header_again;
}
default:
throw new UnpackException("parse error");
}
} // _push
} while(true);
} // _header_again
cs = CS_HEADER;
++i;
} while(i < limit); // _out
return i;
}
}

28
java/src/main/java/org/msgpack/annotation/Ignore.java
View File

@ -1,28 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Ignore {
}

29
java/src/main/java/org/msgpack/annotation/Index.java
View File

@ -1,29 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Index {
int value();
}

35
java/src/main/java/org/msgpack/annotation/MessagePackBeans.java
View File

@ -1,35 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.msgpack.template.FieldOption;
/**
* Annotation for java beans class
* @author takeshita
*
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessagePackBeans {
FieldOption value() default FieldOption.DEFAULT;
}

29
java/src/main/java/org/msgpack/annotation/MessagePackDelegate.java
View File

@ -1,29 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessagePackDelegate {
String value();
}

30
java/src/main/java/org/msgpack/annotation/MessagePackMessage.java
View File

@ -1,30 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.msgpack.template.FieldOption;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessagePackMessage {
FieldOption value() default FieldOption.DEFAULT;
}

28
java/src/main/java/org/msgpack/annotation/MessagePackOrdinalEnum.java
View File

@ -1,28 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessagePackOrdinalEnum {
}

28
java/src/main/java/org/msgpack/annotation/Nullable.java
View File

@ -1,28 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Nullable {
}

28
java/src/main/java/org/msgpack/annotation/Optional.java
View File

@ -1,28 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Optional {
}

28
java/src/main/java/org/msgpack/annotation/Required.java
View File

@ -1,28 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Required {
}

462
java/src/main/java/org/msgpack/buffer/VectoredByteBuffer.java
View File

@ -1,462 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.buffer;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.List;
import java.util.ArrayList;
import java.nio.ByteBuffer;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.ScatteringByteChannel;
public class VectoredByteBuffer implements GatheringByteChannel, ScatteringByteChannel {
private List<ByteBuffer> vec = new ArrayList<ByteBuffer>();
private ByteBuffer internalBuffer;
private ByteBuffer lastInternalBuffer;
private int chunkSize;
private int referenceThreshold;
public VectoredByteBuffer() {
this(32*1024);
}
public VectoredByteBuffer(int chunkSize) {
this(chunkSize, 32);
}
public VectoredByteBuffer(int chunkSize, int referenceThreshold) {
this.chunkSize = chunkSize;
this.referenceThreshold = referenceThreshold;
internalBuffer = ByteBuffer.allocateDirect(chunkSize);
}
public void setChunkSize(int chunkSize) {
this.chunkSize = chunkSize;
}
public int getChunkSize(int chunkSize) {
return this.chunkSize;
}
public void setReferenceThreshold(int referenceThreshold) {
this.referenceThreshold = referenceThreshold;
}
public int getReferenceThreshold(int referenceThreshold) {
return this.referenceThreshold;
}
@Override
public void close() {
reset();
}
@Override
public boolean isOpen() {
return true; // FIXME?
}
public synchronized void reset() {
vec.clear();
lastInternalBuffer = null;
}
public void write(byte[] b) {
write(b, 0, b.length);
}
public void write(byte[] b, int off, int len) {
if(off < 0 || len < 0 || b.length < off+len) {
throw new IndexOutOfBoundsException();
}
if(referenceThreshold >= 0 && len > referenceThreshold) {
writeReference(b, off, len);
} else {
writeCopy(b, off, len);
}
}
public void write(int b) {
byte[] ba = new byte[1];
ba[0] = (byte)b;
write(ba);
}
@Override
public int write(ByteBuffer src) {
int slen = src.remaining();
if(referenceThreshold >= 0 && slen > referenceThreshold) {
writeCopy(src);
} else {
writeReference(src);
}
return slen;
}
@Override
public synchronized long write(ByteBuffer[] srcs) {
return write(srcs, 0, srcs.length);
}
@Override
public synchronized long write(ByteBuffer[] srcs, int offset, int length) {
if(offset < 0 || length < 0 || srcs.length < offset+length) {
throw new IndexOutOfBoundsException();
}
long total = 0;
for(int i=offset; offset < length; offset++) {
ByteBuffer src = srcs[i];
total += write(src);
}
return total;
}
private synchronized void writeCopy(byte[] b, int off, int len) {
int ipos = internalBuffer.position();
if(internalBuffer.capacity() - ipos < len) {
// allocate new buffer
int nsize = chunkSize > len ? chunkSize : len;
internalBuffer = ByteBuffer.allocateDirect(nsize);
ipos = 0;
} else if(internalBuffer == lastInternalBuffer) {
// optimization: concatenates to the last buffer instead
// of adding new reference
ByteBuffer dup = vec.get(vec.size()-1);
internalBuffer.put(b, off, len);
dup.limit(ipos + len);
return;
}
internalBuffer.put(b, off, len);
ByteBuffer dup = internalBuffer.duplicate();
dup.position(ipos);
dup.mark();
dup.limit(ipos + len);
vec.add(dup);
lastInternalBuffer = internalBuffer;
}
private synchronized void writeCopy(ByteBuffer src) {
int slen = src.remaining();
int ipos = internalBuffer.position();
if(internalBuffer.capacity() - ipos < slen) {
// allocate new buffer
int nsize = chunkSize > slen ? chunkSize : slen;
internalBuffer = ByteBuffer.allocateDirect(nsize);
ipos = 0;
} else if(internalBuffer == lastInternalBuffer) {
// optimization: concatenates to the last buffer instead
// of adding new reference
ByteBuffer dup = vec.get(vec.size()-1);
int dpos = dup.position();
internalBuffer.put(src);
ByteBuffer dup2 = internalBuffer.duplicate();
dup2.position(dpos);
dup2.limit(ipos + slen);
vec.set(vec.size()-1, dup2);
return;
}
internalBuffer.put(src);
ByteBuffer dup = internalBuffer.duplicate();
dup.position(ipos);
dup.mark();
dup.limit(ipos + slen);
vec.add(dup);
lastInternalBuffer = internalBuffer;
}
private synchronized void writeReference(byte[] b, int off, int len) {
ByteBuffer buf = ByteBuffer.wrap(b, off, len);
vec.add(buf);
lastInternalBuffer = null;
}
private synchronized void writeReference(ByteBuffer src) {
ByteBuffer buf = src.duplicate();
vec.add(buf);
lastInternalBuffer = null;
}
public synchronized void writeTo(java.io.OutputStream out) throws IOException {
byte[] tmpbuf = null;
for(int i=0; i < vec.size(); i++) {
ByteBuffer r = vec.get(i);
int rpos = r.position();
int rlen = r.limit() - rpos;
if(r.hasArray()) {
byte[] array = r.array();
out.write(array, rpos, rlen);
} else {
if(tmpbuf == null) {
int max = rlen;
for(int j=i+1; j < vec.size(); j++) {
ByteBuffer c = vec.get(j);
int clen = c.remaining();
if(max < clen) {
max = clen;
}
}
tmpbuf = new byte[max];
}
r.get(tmpbuf, 0, rlen);
r.position(rpos);
out.write(tmpbuf, 0, rlen);
}
}
}
public synchronized byte[] toByteArray() {
byte[] out = new byte[available()];
int off = 0;
for(ByteBuffer r: vec) {
int rpos = r.position();
int rlen = r.limit() - rpos;
r.get(out, off, rlen);
r.position(rpos);
off += rlen;
}
return out;
}
public synchronized int available() {
int total = 0;
for(ByteBuffer r : vec) {
total += r.remaining();
}
return total;
}
public synchronized int read(byte[] b) {
return read(b, 0, b.length);
}
public synchronized int read(byte[] b, int off, int len) {
if(off < 0 || len < 0 || b.length < off+len) {
throw new IndexOutOfBoundsException();
}
int start = len;
while(!vec.isEmpty()) {
ByteBuffer r = vec.get(0);
int rlen = r.remaining();
if(rlen <= len) {
r.get(b, off, rlen);
vec.remove(0);
off += rlen;
len -= rlen;
} else {
r.get(b, off, len);
return start;
}
}
return start - len;
}
public synchronized int read() {
byte[] ba = new byte[1];
if(read(ba) >= 1) {
return ba[0];
} else {
return -1;
}
}
@Override
public synchronized int read(ByteBuffer dst) {
int len = dst.remaining();
int start = len;
while(!vec.isEmpty()) {
ByteBuffer r = vec.get(0);
int rlen = r.remaining();
if(rlen <= len) {
dst.put(r);
vec.remove(0);
len -= rlen;
} else {
int blim = r.limit();
r.limit(len);
try {
dst.put(r);
} finally {
r.limit(blim);
}
return start;
}
}
return start - len;
}
@Override
public synchronized long read(ByteBuffer[] dsts) {
return read(dsts, 0, dsts.length);
}
@Override
public synchronized long read(ByteBuffer[] dsts, int offset, int length) {
if(offset < 0 || length < 0 || dsts.length < offset+length) {
throw new IndexOutOfBoundsException();
}
long total = 0;
for(int i=offset; i < length; i++) {
ByteBuffer dst = dsts[i];
int dlen = dst.remaining();
int rlen = read(dsts[i]);
total += rlen;
if(rlen < dlen) {
return total;
}
}
return total;
}
public synchronized long read(GatheringByteChannel to) throws IOException {
long total = to.write(vec.toArray(new ByteBuffer[0]));
while(!vec.isEmpty()) {
ByteBuffer r = vec.get(0);
if(r.remaining() == 0) {
vec.remove(0);
} else {
break;
}
}
return total;
}
public synchronized long skip(long len) {
if(len <= 0) {
return 0;
}
long start = len;
while(!vec.isEmpty()) {
ByteBuffer r = vec.get(0);
int rlen = r.remaining();
if(rlen <= len) {
r.position(r.position()+rlen);
vec.remove(0);
len -= rlen;
} else {
r.position((int)(r.position()+len));
return start;
}
}
return start - len;
}
public final static class OutputStream extends java.io.OutputStream {
private VectoredByteBuffer vbb;
OutputStream(VectoredByteBuffer vbb) {
this.vbb = vbb;
}
@Override
public void write(byte[] b) {
vbb.write(b);
}
@Override
public void write(byte[] b, int off, int len) {
vbb.write(b, off, len);
}
@Override
public void write(int b) {
vbb.write(b);
}
public int write(ByteBuffer src) {
return vbb.write(src);
}
public long write(ByteBuffer[] srcs) {
return vbb.write(srcs);
}
public long write(ByteBuffer[] srcs, int offset, int length) {
return vbb.write(srcs, offset, length);
}
public void writeTo(OutputStream out) throws IOException {
vbb.writeTo(out);
}
public byte[] toByteArray() {
return vbb.toByteArray();
}
}
public final static class InputStream extends java.io.InputStream {
private VectoredByteBuffer vbb;
InputStream(VectoredByteBuffer vbb) {
this.vbb = vbb;
}
@Override
public int available() {
return vbb.available();
}
@Override
public int read(byte[] b) {
return vbb.read(b);
}
@Override
public int read(byte[] b, int off, int len) {
return vbb.read(b, off, len);
}
@Override
public int read() {
return vbb.read();
}
public int read(ByteBuffer dst) {
return vbb.read(dst);
}
public long read(ByteBuffer[] dsts, int offset, int length) {
return vbb.read(dsts, offset, length);
}
public long read(GatheringByteChannel to) throws IOException {
return vbb.read(to);
}
public long skip(long len) {
return vbb.skip(len);
}
}
public OutputStream outputStream() {
return new OutputStream(this);
}
public InputStream inputStream() {
return new InputStream(this);
}
}

81
java/src/main/java/org/msgpack/object/ArrayType.java
View File

@ -1,81 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.util.List;
import java.util.Arrays;
import java.io.IOException;
import org.msgpack.*;
public class ArrayType extends MessagePackObject {
private MessagePackObject[] array;
ArrayType(MessagePackObject[] array) {
this.array = array;
}
public static ArrayType create(MessagePackObject[] array) {
return new ArrayType(array);
}
@Override
public boolean isArrayType() {
return true;
}
@Override
public MessagePackObject[] asArray() {
return array;
}
@Override
public List<MessagePackObject> asList() {
return Arrays.asList(array);
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packArray(array.length);
for(int i=0; i < array.length; i++) {
array[i].messagePack(pk);
}
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return Arrays.equals(((ArrayType)obj).array, array);
}
@Override
public int hashCode() {
return array.hashCode();
}
@Override
public Object clone() {
MessagePackObject[] copy = new MessagePackObject[array.length];
for(int i=0; i < array.length; i++) {
copy[i] = (MessagePackObject)array[i].clone();
}
return copy;
}
}

131
java/src/main/java/org/msgpack/object/BigIntegerTypeIMPL.java
View File

@ -1,131 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.math.BigInteger;
import java.io.IOException;
import org.msgpack.*;
class BigIntegerTypeIMPL extends IntegerType {
private BigInteger value;
BigIntegerTypeIMPL(BigInteger value) {
this.value = value;
}
@Override
public byte asByte() {
if(value.compareTo(BigInteger.valueOf((long)Byte.MAX_VALUE)) > 0) {
throw new MessageTypeException("type error");
}
return value.byteValue();
}
@Override
public short asShort() {
if(value.compareTo(BigInteger.valueOf((long)Short.MAX_VALUE)) > 0) {
throw new MessageTypeException("type error");
}
return value.shortValue();
}
@Override
public int asInt() {
if(value.compareTo(BigInteger.valueOf((long)Integer.MAX_VALUE)) > 0) {
throw new MessageTypeException("type error");
}
return value.intValue();
}
@Override
public long asLong() {
if(value.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0) {
throw new MessageTypeException("type error");
}
return value.longValue();
}
@Override
public BigInteger asBigInteger() {
return value;
}
@Override
public byte byteValue() {
return value.byteValue();
}
@Override
public short shortValue() {
return value.shortValue();
}
@Override
public int intValue() {
return value.intValue();
}
@Override
public long longValue() {
return value.longValue();
}
@Override
public BigInteger bigIntegerValue() {
return value;
}
@Override
public float floatValue() {
return value.floatValue();
}
@Override
public double doubleValue() {
return value.doubleValue();
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packBigInteger(value);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
if(obj.getClass() == ShortIntegerTypeIMPL.class) {
return BigInteger.valueOf(((ShortIntegerTypeIMPL)obj).longValue()).equals(value);
} else if(obj.getClass() == LongIntegerTypeIMPL.class) {
return BigInteger.valueOf(((LongIntegerTypeIMPL)obj).longValue()).equals(value);
}
return false;
}
return ((BigIntegerTypeIMPL)obj).value.equals(value);
}
@Override
public int hashCode() {
return value.hashCode();
}
@Override
public Object clone() {
return new BigIntegerTypeIMPL(value);
}
}

71
java/src/main/java/org/msgpack/object/BooleanType.java
View File

@ -1,71 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.io.IOException;
import org.msgpack.*;
public class BooleanType extends MessagePackObject {
private boolean value;
BooleanType(boolean value) {
this.value = value;
}
public static BooleanType create(boolean value) {
return new BooleanType(value);
}
@Override
public boolean isBooleanType() {
return true;
}
@Override
public boolean asBoolean() {
return value;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packBoolean(value);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return ((BooleanType)obj).value == value;
}
@Override
public int hashCode() {
if(value) {
return 1231;
} else {
return 1237;
}
}
@Override
public Object clone() {
return new BooleanType(value);
}
}

101
java/src/main/java/org/msgpack/object/DoubleTypeIMPL.java
View File

@ -1,101 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.math.BigInteger;
import java.io.IOException;
import org.msgpack.*;
class DoubleTypeIMPL extends FloatType {
private double value;
public DoubleTypeIMPL(double value) {
this.value = value;
}
@Override
public float asFloat() {
// FIXME check overflow, underflow?
return (float)value;
}
@Override
public double asDouble() {
return value;
}
@Override
public byte byteValue() {
return (byte)value;
}
@Override
public short shortValue() {
return (short)value;
}
@Override
public int intValue() {
return (int)value;
}
@Override
public long longValue() {
return (long)value;
}
@Override
public BigInteger bigIntegerValue() {
return BigInteger.valueOf((long)value);
}
@Override
public float floatValue() {
return (float)value;
}
@Override
public double doubleValue() {
return (double)value;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packDouble(value);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return ((DoubleTypeIMPL)obj).value == value;
}
@Override
public int hashCode() {
long v = Double.doubleToLongBits(value);
return (int)(v^(v>>>32));
}
@Override
public Object clone() {
return new DoubleTypeIMPL(value);
}
}

36
java/src/main/java/org/msgpack/object/FloatType.java
View File

@ -1,36 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import org.msgpack.*;
public abstract class FloatType extends MessagePackObject {
@Override
public boolean isFloatType() {
return true;
}
public static FloatType create(float value) {
return new FloatTypeIMPL(value);
}
public static FloatType create(double value) {
return new DoubleTypeIMPL(value);
}
}

94
java/src/main/java/org/msgpack/object/FloatTypeIMPL.java
View File

@ -1,94 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.math.BigInteger;
import java.io.IOException;
import org.msgpack.*;
class FloatTypeIMPL extends FloatType {
private float value;
public FloatTypeIMPL(float value) {
this.value = value;
}
@Override
public float asFloat() {
return value;
}
@Override
public double asDouble() {
return (double)value;
}
@Override
public byte byteValue() {
return (byte)value;
}
@Override
public short shortValue() {
return (short)value;
}
@Override
public int intValue() {
return (int)value;
}
@Override
public long longValue() {
return (long)value;
}
@Override
public float floatValue() {
return (float)value;
}
@Override
public double doubleValue() {
return (double)value;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packFloat(value);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return ((FloatTypeIMPL)obj).value == value;
}
@Override
public int hashCode() {
return Float.floatToIntBits(value);
}
@Override
public Object clone() {
return new FloatTypeIMPL(value);
}
}

49
java/src/main/java/org/msgpack/object/IntegerType.java
View File

@ -1,49 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.math.BigInteger;
import org.msgpack.*;
public abstract class IntegerType extends MessagePackObject {
@Override
public boolean isIntegerType() {
return true;
}
public static IntegerType create(byte value) {
return new ShortIntegerTypeIMPL((int)value);
}
public static IntegerType create(short value) {
return new ShortIntegerTypeIMPL((int)value);
}
public static IntegerType create(int value) {
return new ShortIntegerTypeIMPL(value);
}
public static IntegerType create(long value) {
return new LongIntegerTypeIMPL(value);
}
public static IntegerType create(BigInteger value) {
return new BigIntegerTypeIMPL(value);
}
}

128
java/src/main/java/org/msgpack/object/LongIntegerTypeIMPL.java
View File

@ -1,128 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.math.BigInteger;
import java.io.IOException;
import org.msgpack.*;
class LongIntegerTypeIMPL extends IntegerType {
private long value;
LongIntegerTypeIMPL(long value) {
this.value = value;
}
@Override
public byte asByte() {
if(value > (long)Byte.MAX_VALUE) {
throw new MessageTypeException("type error");
}
return (byte)value;
}
@Override
public short asShort() {
if(value > (long)Short.MAX_VALUE) {
throw new MessageTypeException("type error");
}
return (short)value;
}
@Override
public int asInt() {
if(value > (long)Integer.MAX_VALUE) {
throw new MessageTypeException("type error");
}
return (int)value;
}
@Override
public long asLong() {
return value;
}
@Override
public BigInteger asBigInteger() {
return BigInteger.valueOf(value);
}
@Override
public byte byteValue() {
return (byte)value;
}
@Override
public short shortValue() {
return (short)value;
}
@Override
public int intValue() {
return (int)value;
}
@Override
public long longValue() {
return (long)value;
}
@Override
public BigInteger bigIntegerValue() {
return BigInteger.valueOf(value);
}
@Override
public float floatValue() {
return (float)value;
}
@Override
public double doubleValue() {
return (double)value;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packLong(value);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
if(obj.getClass() == ShortIntegerTypeIMPL.class) {
return value == ((ShortIntegerTypeIMPL)obj).longValue();
} else if(obj.getClass() == BigIntegerTypeIMPL.class) {
return BigInteger.valueOf(value).equals(((BigIntegerTypeIMPL)obj).bigIntegerValue());
}
return false;
}
return ((LongIntegerTypeIMPL)obj).value == value;
}
@Override
public int hashCode() {
return (int)(value^(value>>>32));
}
@Override
public Object clone() {
return new LongIntegerTypeIMPL(value);
}
}

84
java/src/main/java/org/msgpack/object/MapType.java
View File

@ -1,84 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.util.HashMap;
import java.util.Map;
import java.util.Arrays;
import java.io.IOException;
import org.msgpack.*;
public class MapType extends MessagePackObject {
private MessagePackObject[] map;
MapType(MessagePackObject[] map) {
this.map = map;
}
public static MapType create(MessagePackObject[] map) {
return new MapType(map);
}
@Override
public boolean isMapType() {
return true;
}
@Override
public Map<MessagePackObject, MessagePackObject> asMap() {
HashMap<MessagePackObject, MessagePackObject> m = new HashMap(map.length / 2);
int i = 0;
while(i < map.length) {
MessagePackObject k = map[i++];
MessagePackObject v = map[i++];
m.put(k, v);
}
return m;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packMap(map.length / 2);
for(int i=0; i < map.length; i++) {
map[i].messagePack(pk);
}
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return Arrays.equals(((MapType)obj).map, map);
}
@Override
public int hashCode() {
return map.hashCode();
}
@Override
public Object clone() {
MessagePackObject[] copy = new MessagePackObject[map.length];
for(int i=0; i < map.length; i++) {
copy[i] = (MessagePackObject)map[i].clone();
}
return copy;
}
}

60
java/src/main/java/org/msgpack/object/NilType.java
View File

@ -1,60 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.io.IOException;
import org.msgpack.*;
public class NilType extends MessagePackObject {
private final static NilType INSTANCE = new NilType();
public static NilType create() {
return INSTANCE;
}
private NilType() { }
@Override
public boolean isNil() {
return true;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packNil();
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return true;
}
@Override
public int hashCode() {
return 0;
}
@Override
public Object clone() {
return INSTANCE;
}
}

90
java/src/main/java/org/msgpack/object/RawType.java
View File

@ -1,90 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.util.Arrays;
import java.io.IOException;
import org.msgpack.*;
public class RawType extends MessagePackObject {
private byte[] bytes;
RawType(byte[] bytes) {
this.bytes = bytes;
}
RawType(String str) {
try {
this.bytes = str.getBytes("UTF-8");
} catch (Exception e) {
throw new MessageTypeException("type error");
}
}
public static RawType create(byte[] bytes) {
return new RawType(bytes);
}
public static RawType create(String str) {
return new RawType(str);
}
@Override
public boolean isRawType() {
return true;
}
@Override
public byte[] asByteArray() {
return bytes;
}
@Override
public String asString() {
try {
return new String(bytes, "UTF-8");
} catch (Exception e) {
throw new MessageTypeException("type error");
}
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packRaw(bytes.length);
pk.packRawBody(bytes);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
return false;
}
return Arrays.equals(((RawType)obj).bytes, bytes);
}
@Override
public int hashCode() {
return Arrays.hashCode(bytes);
}
@Override
public Object clone() {
return new RawType((byte[])bytes.clone());
}
}

125
java/src/main/java/org/msgpack/object/ShortIntegerTypeIMPL.java
View File

@ -1,125 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.object;
import java.math.BigInteger;
import java.io.IOException;
import org.msgpack.*;
class ShortIntegerTypeIMPL extends IntegerType {
private int value;
ShortIntegerTypeIMPL(int value) {
this.value = value;
}
@Override
public byte asByte() {
if(value > (int)Byte.MAX_VALUE) {
throw new MessageTypeException("type error");
}
return (byte)value;
}
@Override
public short asShort() {
if(value > (int)Short.MAX_VALUE) {
throw new MessageTypeException("type error");
}
return (short)value;
}
@Override
public int asInt() {
return value;
}
@Override
public long asLong() {
return value;
}
@Override
public BigInteger asBigInteger() {
return BigInteger.valueOf((long)value);
}
@Override
public byte byteValue() {
return (byte)value;
}
@Override
public short shortValue() {
return (short)value;
}
@Override
public int intValue() {
return (int)value;
}
@Override
public long longValue() {
return (long)value;
}
@Override
public BigInteger bigIntegerValue() {
return BigInteger.valueOf((long)value);
}
@Override
public float floatValue() {
return (float)value;
}
@Override
public double doubleValue() {
return (double)value;
}
@Override
public void messagePack(Packer pk) throws IOException {
pk.packInt(value);
}
@Override
public boolean equals(Object obj) {
if(obj.getClass() != getClass()) {
if(obj.getClass() == LongIntegerTypeIMPL.class) {
return (long)value == ((LongIntegerTypeIMPL)obj).longValue();
} else if(obj.getClass() == BigIntegerTypeIMPL.class) {
return ((BigIntegerTypeIMPL)obj).bigIntegerValue().equals(BigInteger.valueOf((long)value));
}
return false;
}
return ((ShortIntegerTypeIMPL)obj).value == value;
}
@Override
public int hashCode() {
return value;
}
@Override
public Object clone() {
return new ShortIntegerTypeIMPL(value);
}
}

8
java/src/main/java/org/msgpack/package-info.java
View File

@ -1,8 +0,0 @@
/**
* MessagePack is a binary-based efficient object serialization library.
* It enables to exchange structured objects between many languages like JSON.
* But unlike JSON, it is very fast and small.
*
* Use {@link Packer} to serialize and {@link Unpacker} to deserialize.
*/
package org.msgpack;

54
java/src/main/java/org/msgpack/template/AnyTemplate.java
View File

@ -1,54 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class AnyTemplate implements Template {
private AnyTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(target instanceof MessagePackObject) {
pk.pack((MessagePackObject)target);
} else if(target == null) {
pk.packNil();
} else {
TemplateRegistry.lookup(target.getClass()).pack(pk, target);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackObject();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from;
}
static public AnyTemplate getInstance() {
return instance;
}
static final AnyTemplate instance = new AnyTemplate();
static {
TemplateRegistry.register(MessagePackObject.class, instance);
}
}

143
java/src/main/java/org/msgpack/template/BeansFieldEntry.java
View File

@ -1,143 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.beans.PropertyDescriptor;
import java.lang.reflect.*;
import org.msgpack.*;
/**
* Field entry for Java beans property.
* @author takeshita
*
*/
public class BeansFieldEntry implements IFieldEntry {
PropertyDescriptor desc;
FieldOption option = FieldOption.DEFAULT;
public BeansFieldEntry(PropertyDescriptor desc) {
this.desc = desc;
}
@Override
public String getName() {
return desc.getDisplayName();
}
public String getGetterName(){
return desc.getReadMethod().getName();
}
public String getSetterName(){
return desc.getWriteMethod().getName();
}
@Override
public Class<?> getType() {
return desc.getPropertyType();
}
@Override
public String getJavaTypeName() {
Class<?> type = getType();
if(type.isArray()) {
return arrayTypeToString(type);
} else {
return type.getName();
}
}
static String arrayTypeToString(Class<?> type) {
int dim = 1;
Class<?> baseType = type.getComponentType();
while(baseType.isArray()) {
baseType = baseType.getComponentType();
dim += 1;
}
StringBuilder sb = new StringBuilder();
sb.append(baseType.getName());
for (int i = 0; i < dim; ++i) {
sb.append("[]");
}
return sb.toString();
}
@Override
public Type getGenericType() {
return desc.getReadMethod().getGenericReturnType();
}
@Override
public FieldOption getOption() {
return option;
}
public void setOption(FieldOption option){
this.option = option;
}
@Override
public boolean isAvailable() {
return option != FieldOption.IGNORE;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isRequired()
*/
@Override
public boolean isRequired() {
return option == FieldOption.REQUIRED;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isOptional()
*/
@Override
public boolean isOptional() {
return option == FieldOption.OPTIONAL;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isNullable()
*/
@Override
public boolean isNullable() {
return option == FieldOption.NULLABLE;
}
public Object get(Object target){
try {
return desc.getReadMethod().invoke(target);
} catch (IllegalArgumentException e) {
throw new MessageTypeException(e);
} catch (IllegalAccessException e) {
throw new MessageTypeException(e);
} catch (InvocationTargetException e) {
throw new MessageTypeException(e);
}
}
public void set(Object target , Object value){
try {
desc.getWriteMethod().invoke(target, value);
} catch (IllegalArgumentException e) {
throw new MessageTypeException(e);
} catch (IllegalAccessException e) {
throw new MessageTypeException(e);
} catch (InvocationTargetException e) {
throw new MessageTypeException(e);
}
}
}

188
java/src/main/java/org/msgpack/template/BeansFieldEntryReader.java
View File

@ -1,188 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import org.msgpack.annotation.Ignore;
import org.msgpack.annotation.Index;
import org.msgpack.annotation.MessagePackMessage;
import org.msgpack.annotation.Nullable;
import org.msgpack.annotation.Optional;
import org.msgpack.annotation.Required;
/**
* List up Java beans property methods.
* @author takeshita
*
*/
public class BeansFieldEntryReader implements IFieldEntryReader{
public IFieldEntry[] convertFieldEntries(Class<?> targetClass, FieldList flist) throws NoSuchFieldException {
List<FieldList.Entry> src = flist.getList();
FieldEntry[] result = new FieldEntry[src.size()];
for(int i=0; i < src.size(); i++) {
FieldList.Entry s = src.get(i);
if(s.isAvailable()) {
result[i] = new FieldEntry(targetClass.getDeclaredField(s.getName()), s.getOption());
} else {
result[i] = new FieldEntry();
}
}
return result;
}
@Override
public IFieldEntry[] readFieldEntries(Class<?> targetClass,
FieldOption implicitOption) {
BeanInfo desc;
try {
desc = Introspector.getBeanInfo(targetClass);
} catch (IntrospectionException e1) {
throw new TemplateBuildException("Class must be java beans class:" + targetClass.getName());
}
PropertyDescriptor[] props = desc.getPropertyDescriptors();
ArrayList<PropertyDescriptor> list = new ArrayList<PropertyDescriptor>();
for(int i = 0;i < props.length;i++){
PropertyDescriptor pd = props[i];
if(!isIgnoreProp(pd)){
list.add(pd);
}
}
props = new PropertyDescriptor[list.size()];
list.toArray(props);
BeansFieldEntry[] entries = new BeansFieldEntry[props.length];
for(int i = 0;i < props.length;i++){
PropertyDescriptor p = props[i];
int index = readPropIndex(p);
if(index >= 0){
if(entries[index] != null){
throw new TemplateBuildException("duplicated index: "+index);
}
if(index >= entries.length){
throw new TemplateBuildException("invalid index: "+index);
}
entries[index] = new BeansFieldEntry(p);
props[index] = null;
}
}
int insertIndex = 0;
for(int i = 0;i < props.length;i++){
PropertyDescriptor p = props[i];
if(p != null){
while(entries[insertIndex] != null){
insertIndex++;
}
entries[insertIndex] = new BeansFieldEntry(p);
}
}
for(int i = 0;i < entries.length;i++){
BeansFieldEntry e = entries[i];
FieldOption op = readPropOption(e.desc, implicitOption);
e.setOption(op);
}
return entries;
}
public FieldOption readImplicitFieldOption(Class<?> targetClass) {
MessagePackMessage a = targetClass.getAnnotation(MessagePackMessage.class);
if(a == null) {
return FieldOption.DEFAULT;
}
return a.value();
}
private FieldOption readPropOption(PropertyDescriptor desc, FieldOption implicitOption) {
FieldOption forGetter = readMethodOption(desc.getReadMethod());
if(forGetter != FieldOption.DEFAULT){
return forGetter;
}
FieldOption forSetter = readMethodOption(desc.getWriteMethod());
if(forSetter != FieldOption.DEFAULT){
return forSetter;
}else{
return implicitOption;
}
}
private FieldOption readMethodOption(Method method){
if(isAnnotated(method, Ignore.class)) {
return FieldOption.IGNORE;
} else if(isAnnotated(method, Required.class)) {
return FieldOption.REQUIRED;
} else if(isAnnotated(method, Optional.class)) {
return FieldOption.OPTIONAL;
} else if(isAnnotated(method, Nullable.class)) {
if(method.getDeclaringClass().isPrimitive()) {
return FieldOption.REQUIRED;
} else {
return FieldOption.NULLABLE;
}
}
return FieldOption.DEFAULT;
}
private int readPropIndex(PropertyDescriptor desc) {
int forGetter = readMethodIndex(desc.getReadMethod());
if(forGetter >= 0){
return forGetter;
}
int forSetter = readMethodIndex(desc.getWriteMethod());
return forSetter;
}
private int readMethodIndex(Method method){
Index a = method.getAnnotation(Index.class);
if(a == null) {
return -1;
} else {
return a.value();
}
}
private boolean isAnnotated(AccessibleObject ao, Class<? extends Annotation> with) {
return ao.getAnnotation(with) != null;
}
boolean isIgnoreProp(PropertyDescriptor desc){
if(desc == null)return true;
Method getter = desc.getReadMethod();
Method setter = desc.getWriteMethod();
return getter == null ||
setter == null ||
!Modifier.isPublic(getter.getModifiers()) ||
!Modifier.isPublic(setter.getModifiers()) ||
isAnnotated(getter,Ignore.class) ||
isAnnotated(setter, Ignore.class);
}
}

61
java/src/main/java/org/msgpack/template/BigDecimalTemplate.java
View File

@ -1,61 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import java.math.BigDecimal;
import org.msgpack.MessagePackObject;
import org.msgpack.MessageTypeException;
import org.msgpack.Packer;
import org.msgpack.Template;
import org.msgpack.Unpacker;
public class BigDecimalTemplate implements Template {
@Override
public void pack(Packer pk, Object target) throws IOException {
BigDecimal temp = (BigDecimal) target;
try {
pk.packString(temp.toString());
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
@Override
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
String temp = pac.unpackString();
return new BigDecimal(temp);
}
@Override
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
String temp = from.asString();
return new BigDecimal(temp);
}
static public BigDecimalTemplate getInstance() {
return instance;
}
static final BigDecimalTemplate instance = new BigDecimalTemplate();
static {
TemplateRegistry.register(BigDecimal.class, instance);
}
}

53
java/src/main/java/org/msgpack/template/BigIntegerTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import java.math.BigInteger;
import org.msgpack.*;
public class BigIntegerTemplate implements Template {
private BigIntegerTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packBigInteger((BigInteger)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackBigInteger();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asBigInteger();
}
static public BigIntegerTemplate getInstance() {
return instance;
}
static final BigIntegerTemplate instance = new BigIntegerTemplate();
static {
TemplateRegistry.register(BigInteger.class, instance);
}
}

80
java/src/main/java/org/msgpack/template/BooleanArrayTemplate.java
View File

@ -1,80 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class BooleanArrayTemplate implements Template {
private BooleanArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof boolean[])) {
throw new MessageTypeException();
}
boolean[] array = (boolean[])target;
try {
pk.packArray(array.length);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
for(boolean a : array) {
pk.pack(a);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
boolean[] array;
if(to != null && to instanceof boolean[] && ((boolean[])to).length == length) {
array = (boolean[])to;
} else {
array = new boolean[length];
}
for(int i=0; i < length; i++) {
array[i] = pac.unpackBoolean();
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
boolean[] array;
if(to != null && to instanceof boolean[] && ((boolean[])to).length == src.length) {
array = (boolean[])to;
} else {
array = new boolean[src.length];
}
for(int i=0; i < src.length; i++) {
MessagePackObject s = src[i];
array[i] = s.asBoolean();
}
return array;
}
static public BooleanArrayTemplate getInstance() {
return instance;
}
static final BooleanArrayTemplate instance = new BooleanArrayTemplate();
static {
TemplateRegistry.register(boolean[].class, instance);
}
}

53
java/src/main/java/org/msgpack/template/BooleanTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class BooleanTemplate implements Template {
private BooleanTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packBoolean((Boolean)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackBoolean();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asBoolean();
}
static public BooleanTemplate getInstance() {
return instance;
}
static final BooleanTemplate instance = new BooleanTemplate();
static {
TemplateRegistry.register(Boolean.class, instance);
TemplateRegistry.register(boolean.class, instance);
}
}

49
java/src/main/java/org/msgpack/template/BuiltInTemplateLoader.java
View File

@ -1,49 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
public class BuiltInTemplateLoader {
public static void load() {
AnyTemplate.getInstance();
BigIntegerTemplate.getInstance();
BigDecimalTemplate.getInstance();
BooleanArrayTemplate.getInstance();
BooleanTemplate.getInstance();
ByteArrayTemplate.getInstance();
ByteBufferTemplate.getInstance();
ByteTemplate.getInstance();
DoubleArrayTemplate.getInstance();
DoubleTemplate.getInstance();
DateTemplate.getInstance();
FloatArrayTemplate.getInstance();
FloatTemplate.getInstance();
IntArrayTemplate.getInstance();
IntegerTemplate.getInstance();
LongArrayTemplate.getInstance();
LongTemplate.getInstance();
ShortArrayTemplate.getInstance();
ShortTemplate.getInstance();
StringTemplate.getInstance();
CollectionTemplate.load();
ListTemplate.load();
MapTemplate.load();
NullableTemplate.load();
}
}

52
java/src/main/java/org/msgpack/template/ByteArrayTemplate.java
View File

@ -1,52 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class ByteArrayTemplate implements Template {
private ByteArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packByteArray((byte[])target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackByteArray();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asByteArray();
}
static public ByteArrayTemplate getInstance() {
return instance;
}
static final ByteArrayTemplate instance = new ByteArrayTemplate();
static {
TemplateRegistry.register(byte[].class, instance);
}
}

56
java/src/main/java/org/msgpack/template/ByteBufferTemplate.java
View File

@ -1,56 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.nio.ByteBuffer;
import java.io.IOException;
import org.msgpack.*;
public class ByteBufferTemplate implements Template {
private ByteBufferTemplate() {
}
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packByteBuffer((ByteBuffer) target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackByteBuffer();
}
public Object convert(MessagePackObject from, Object to)
throws MessageTypeException {
// FIXME
byte[] bytes = from.asByteArray();
return ByteBuffer.wrap(bytes);
}
static public ByteBufferTemplate getInstance() {
return instance;
}
static final ByteBufferTemplate instance = new ByteBufferTemplate();
static {
TemplateRegistry.register(ByteBuffer.class, instance);
}
}

53
java/src/main/java/org/msgpack/template/ByteTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class ByteTemplate implements Template {
private ByteTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packByte((Byte)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackByte();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asByte();
}
static public ByteTemplate getInstance() {
return instance;
}
static final ByteTemplate instance = new ByteTemplate();
static {
TemplateRegistry.register(Byte.class, instance);
TemplateRegistry.register(byte.class, instance);
}
}

93
java/src/main/java/org/msgpack/template/CollectionTemplate.java
View File

@ -1,93 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.util.Collection;
import java.util.LinkedList;
import java.io.IOException;
import org.msgpack.MessagePackObject;
import org.msgpack.MessageTypeException;
import org.msgpack.Packer;
import org.msgpack.Template;
import org.msgpack.Unpacker;
public class CollectionTemplate implements Template {
public static void load() { }
private Template elementTemplate;
public CollectionTemplate(Template elementTemplate) {
this.elementTemplate = elementTemplate;
}
@SuppressWarnings("unchecked")
public void pack(Packer pk, Object target) throws IOException {
if (! (target instanceof Collection)) {
if (target == null) {
throw new MessageTypeException(new NullPointerException("target is null."));
}
throw new MessageTypeException("target is not Collection type: " + target.getClass());
}
Collection<Object> collection = (Collection<Object>) target;
pk.packArray(collection.size());
for(Object element : collection) {
elementTemplate.pack(pk, element);
}
}
@SuppressWarnings("unchecked")
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
Collection<Object> c;
if(to == null) {
c = new LinkedList<Object>();
} else {
// TODO: optimize if list is instanceof ArrayList
c = (Collection<Object>) to;
c.clear();
}
for(; length > 0; length--) {
c.add(elementTemplate.unpack(pac, null));
}
return c;
}
@SuppressWarnings("unchecked")
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] array = from.asArray();
Collection<Object> c;
if(to == null) {
c = new LinkedList<Object>();
} else {
// TODO: optimize if list is instanceof ArrayList
c = (Collection<Object>) to;
c.clear();
}
for(MessagePackObject element : array) {
c.add(elementTemplate.convert(element, null));
}
return c;
}
static {
TemplateRegistry.registerGeneric(Collection.class, new GenericTemplate1(CollectionTemplate.class));
TemplateRegistry.register(Collection.class, new CollectionTemplate(AnyTemplate.getInstance()));
}
}

57
java/src/main/java/org/msgpack/template/DateTemplate.java
View File

@ -1,57 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import java.util.Date;
import org.msgpack.MessagePackObject;
import org.msgpack.MessageTypeException;
import org.msgpack.Packer;
import org.msgpack.Template;
import org.msgpack.Unpacker;
public class DateTemplate implements Template {
@Override
public void pack(Packer pk, Object target) throws IOException {
Date temp = (Date) target;
pk.packLong(temp.getTime());
}
@Override
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
Long temp = pac.unpackLong();
return new Date(temp);
}
@Override
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
Long temp = from.asLong();
return new Date(temp);
}
static public DateTemplate getInstance() {
return instance;
}
static final DateTemplate instance = new DateTemplate();
static {
TemplateRegistry.register(Date.class, instance);
}
}

96
java/src/main/java/org/msgpack/template/DefaultTemplate.java
View File

@ -1,96 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import java.lang.reflect.Type;
import org.msgpack.*;
public class DefaultTemplate implements Template {
private Class<?> targetClass;
private Type lookupType;
private boolean messagePackable;
private boolean messageUnpackable;
private boolean messageConvertable;
public DefaultTemplate(Class<?> targetClass) {
this(targetClass, (Type)targetClass);
}
public DefaultTemplate(Class<?> targetClass, Type lookupType) {
this.targetClass = targetClass;
this.lookupType = lookupType;
this.messagePackable = MessagePackable.class.isAssignableFrom(targetClass);
this.messageUnpackable = MessageUnpackable.class.isAssignableFrom(targetClass);
this.messageConvertable = MessageConvertable.class.isAssignableFrom(targetClass);
}
public void pack(Packer pk, Object target) throws IOException {
if(messagePackable) {
if(target == null) {
throw new MessageTypeException("target is null.");
}
((MessagePackable)target).messagePack(pk);
return;
}
Template tmpl = TemplateRegistry.tryLookup(lookupType);
if(tmpl == this || tmpl == null) {
throw new MessageTypeException("Template lookup fail: " + lookupType);
}
tmpl.pack(pk, target);
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
if(messageUnpackable) {
if(to == null) {
try {
to = targetClass.newInstance();
} catch (Exception e) {
throw new MessageTypeException(e);
}
}
((MessageUnpackable)to).messageUnpack(pac);
return to;
}
Template tmpl = TemplateRegistry.tryLookup(lookupType);
if(tmpl == this || tmpl == null) {
throw new MessageTypeException("Template lookup fail: " + lookupType);
}
return tmpl.unpack(pac, to);
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
if(messageConvertable) {
if(to == null) {
try {
to = targetClass.newInstance();
} catch (Exception e) {
throw new MessageTypeException(e);
}
}
((MessageConvertable)to).messageConvert(from);
return from;
}
Template tmpl = TemplateRegistry.tryLookup(lookupType);
if(tmpl == this || tmpl == null) {
throw new MessageTypeException("Template lookup fail: " + lookupType);
}
return tmpl.convert(from, to);
}
}

80
java/src/main/java/org/msgpack/template/DoubleArrayTemplate.java
View File

@ -1,80 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class DoubleArrayTemplate implements Template {
private DoubleArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof double[])) {
throw new MessageTypeException();
}
double[] array = (double[])target;
try {
pk.packArray(array.length);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
for(double a : array) {
pk.pack(a);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
double[] array;
if(to != null && to instanceof double[] && ((double[])to).length == length) {
array = (double[])to;
} else {
array = new double[length];
}
for(int i=0; i < length; i++) {
array[i] = pac.unpackDouble();
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
double[] array;
if(to != null && to instanceof double[] && ((double[])to).length == src.length) {
array = (double[])to;
} else {
array = new double[src.length];
}
for(int i=0; i < src.length; i++) {
MessagePackObject s = src[i];
array[i] = s.asDouble();
}
return array;
}
static public DoubleArrayTemplate getInstance() {
return instance;
}
static final DoubleArrayTemplate instance = new DoubleArrayTemplate();
static {
TemplateRegistry.register(double[].class, instance);
}
}

53
java/src/main/java/org/msgpack/template/DoubleTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class DoubleTemplate implements Template {
private DoubleTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packDouble(((Double)target));
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackDouble();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asDouble();
}
static public DoubleTemplate getInstance() {
return instance;
}
static final DoubleTemplate instance = new DoubleTemplate();
static {
TemplateRegistry.register(Double.class, instance);
TemplateRegistry.register(double.class, instance);
}
}

143
java/src/main/java/org/msgpack/template/FieldEntry.java
View File

@ -1,143 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import java.lang.reflect.*;
import java.lang.annotation.*;
import java.util.List;
import java.util.ArrayList;
import java.util.EnumSet;
import org.msgpack.*;
import org.msgpack.annotation.*;
public class FieldEntry implements IFieldEntry {
private Field field;
private FieldOption option;
public FieldEntry() {
this.field = null;
this.option = FieldOption.IGNORE;
}
public FieldEntry(FieldEntry e) {
this.field = e.field;
this.option = e.option;
}
public FieldEntry(Field field, FieldOption option) {
this.field = field;
this.option = option;
}
public Field getField() {
return field;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#getName()
*/
@Override
public String getName() {
return field.getName();
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#getType()
*/
@Override
public Class<?> getType() {
return field.getType();
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#getJavaTypeName()
*/
@Override
public String getJavaTypeName() {
Class<?> type = field.getType();
if(type.isArray()) {
return arrayTypeToString(type);
} else {
return type.getName();
}
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#getGenericType()
*/
@Override
public Type getGenericType() {
return field.getGenericType();
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#getOption()
*/
@Override
public FieldOption getOption() {
return option;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isAvailable()
*/
@Override
public boolean isAvailable() {
return option != FieldOption.IGNORE;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isRequired()
*/
@Override
public boolean isRequired() {
return option == FieldOption.REQUIRED;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isOptional()
*/
@Override
public boolean isOptional() {
return option == FieldOption.OPTIONAL;
}
/* (non-Javadoc)
* @see org.msgpack.template.IFieldEntry#isNullable()
*/
@Override
public boolean isNullable() {
return option == FieldOption.NULLABLE;
}
static String arrayTypeToString(Class<?> type) {
int dim = 1;
Class<?> baseType = type.getComponentType();
while(baseType.isArray()) {
baseType = baseType.getComponentType();
dim += 1;
}
StringBuilder sb = new StringBuilder();
sb.append(baseType.getName());
for (int i = 0; i < dim; ++i) {
sb.append("[]");
}
return sb.toString();
}
}

182
java/src/main/java/org/msgpack/template/FieldEntryReader.java
View File

@ -1,182 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import org.msgpack.annotation.Ignore;
import org.msgpack.annotation.Index;
import org.msgpack.annotation.MessagePackMessage;
import org.msgpack.annotation.Nullable;
import org.msgpack.annotation.Optional;
import org.msgpack.annotation.Required;
public class FieldEntryReader implements IFieldEntryReader{
public IFieldEntry[] convertFieldEntries(Class<?> targetClass, FieldList flist) throws NoSuchFieldException {
List<FieldList.Entry> src = flist.getList();
FieldEntry[] result = new FieldEntry[src.size()];
for(int i=0; i < src.size(); i++) {
FieldList.Entry s = src.get(i);
if(s.isAvailable()) {
result[i] = new FieldEntry(targetClass.getDeclaredField(s.getName()), s.getOption());
} else {
result[i] = new FieldEntry();
}
}
return result;
}
@Override
public IFieldEntry[] readFieldEntries(Class<?> targetClass,
FieldOption implicitOption) {
Field[] allFields = readAllFields(targetClass);
/* index:
* @Index(0) int field_a; // 0
* int field_b; // 1
* @Index(3) int field_c; // 3
* int field_d; // 4
* @Index(2) int field_e; // 2
* int field_f; // 5
*/
List<FieldEntry> indexed = new ArrayList<FieldEntry>();
int maxIndex = -1;
for(Field f : allFields) {
FieldOption opt = readFieldOption(f, implicitOption);
if(opt == FieldOption.IGNORE) {
// skip
continue;
}
int index = readFieldIndex(f, maxIndex);
if(indexed.size() > index && indexed.get(index) != null) {
throw new TemplateBuildException("duplicated index: "+index);
}
if(index < 0) {
throw new TemplateBuildException("invalid index: "+index);
}
while(indexed.size() <= index) {
indexed.add(null);
}
indexed.set(index, new FieldEntry(f, opt));
if(maxIndex < index) {
maxIndex = index;
}
}
FieldEntry[] result = new FieldEntry[maxIndex+1];
for(int i=0; i < indexed.size(); i++) {
FieldEntry e = indexed.get(i);
if(e == null) {
result[i] = new FieldEntry();
} else {
result[i] = e;
}
}
return result;
}
public FieldOption readImplicitFieldOption(Class<?> targetClass) {
MessagePackMessage a = targetClass.getAnnotation(MessagePackMessage.class);
if(a == null) {
return FieldOption.DEFAULT;
}
return a.value();
}
private Field[] readAllFields(Class<?> targetClass) {
// order: [fields of super class, ..., fields of this class]
List<Field[]> succ = new ArrayList<Field[]>();
int total = 0;
for(Class<?> c = targetClass; c != Object.class; c = c.getSuperclass()) {
Field[] fields = c.getDeclaredFields();
total += fields.length;
succ.add(fields);
}
Field[] result = new Field[total];
int off = 0;
for(int i=succ.size()-1; i >= 0; i--) {
Field[] fields = succ.get(i);
System.arraycopy(fields, 0, result, off, fields.length);
off += fields.length;
}
return result;
}
private static FieldOption readFieldOption(Field field, FieldOption implicitOption) {
int mod = field.getModifiers();
if(Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
return FieldOption.IGNORE;
}
if(isAnnotated(field, Ignore.class)) {
return FieldOption.IGNORE;
} else if(isAnnotated(field, Required.class)) {
return FieldOption.REQUIRED;
} else if(isAnnotated(field, Optional.class)) {
return FieldOption.OPTIONAL;
} else if(isAnnotated(field, Nullable.class)) {
if(field.getType().isPrimitive()) {
return FieldOption.REQUIRED;
} else {
return FieldOption.NULLABLE;
}
}
if(implicitOption != FieldOption.DEFAULT) {
return implicitOption;
}
// default mode:
// transient : Ignore
// public : Required
// others : Ignore
if(Modifier.isTransient(mod)) {
return FieldOption.IGNORE;
} else if(Modifier.isPublic(mod)) {
return FieldOption.REQUIRED;
} else {
return FieldOption.IGNORE;
}
}
private static int readFieldIndex(Field field, int maxIndex) {
Index a = field.getAnnotation(Index.class);
if(a == null) {
return maxIndex + 1;
} else {
return a.value();
}
}
private static boolean isAnnotated(AccessibleObject ao, Class<? extends Annotation> with) {
return ao.getAnnotation(with) != null;
}
}

96
java/src/main/java/org/msgpack/template/FieldList.java
View File

@ -1,96 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.util.List;
import java.util.ArrayList;
public class FieldList {
public static class Entry {
public Entry() {
this.name = null;
this.option = FieldOption.IGNORE;
}
public Entry(String name, FieldOption option) {
this.name = name;
this.option = option;
}
private String name;
private FieldOption option;
public String getName() {
return name;
}
public FieldOption getOption() {
return option;
}
public boolean isAvailable() {
return this.option != FieldOption.IGNORE;
}
public boolean isRequired() {
return this.option == FieldOption.REQUIRED;
}
public boolean isOptional() {
return this.option == FieldOption.OPTIONAL;
}
public boolean isNullable() {
return this.option == FieldOption.NULLABLE;
}
}
private ArrayList<Entry> list;
public FieldList() {
list = new ArrayList<Entry>();
}
public void add(final String name) {
add(name, FieldOption.REQUIRED);
}
public void add(final String name, final FieldOption option) {
list.add(new Entry(name, option));
}
public void put(int index, final String name) {
put(index, name, FieldOption.REQUIRED);
}
public void put(int index, final String name, final FieldOption option) {
if(list.size() < index) {
do {
list.add(new Entry());
} while(list.size() < index);
list.add(new Entry(name, option));
} else {
list.set(index, new Entry(name, option));
}
}
public List<Entry> getList() {
return list;
}
}

27
java/src/main/java/org/msgpack/template/FieldOption.java
View File

@ -1,27 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
public enum FieldOption {
IGNORE,
REQUIRED,
OPTIONAL,
NULLABLE,
DEFAULT;
}

80
java/src/main/java/org/msgpack/template/FloatArrayTemplate.java
View File

@ -1,80 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class FloatArrayTemplate implements Template {
private FloatArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof float[])) {
throw new MessageTypeException();
}
float[] array = (float[])target;
try {
pk.packArray(array.length);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
for(float a : array) {
pk.pack(a);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
float[] array;
if(to != null && to instanceof float[] && ((float[])to).length == length) {
array = (float[])to;
} else {
array = new float[length];
}
for(int i=0; i < length; i++) {
array[i] = pac.unpackFloat();
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
float[] array;
if(to != null && to instanceof float[] && ((float[])to).length == src.length) {
array = (float[])to;
} else {
array = new float[src.length];
}
for(int i=0; i < src.length; i++) {
MessagePackObject s = src[i];
array[i] = s.asFloat();
}
return array;
}
static public FloatArrayTemplate getInstance() {
return instance;
}
static final FloatArrayTemplate instance = new FloatArrayTemplate();
static {
TemplateRegistry.register(float[].class, instance);
}
}

53
java/src/main/java/org/msgpack/template/FloatTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class FloatTemplate implements Template {
private FloatTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packFloat((Float)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackFloat();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asFloat();
}
static public FloatTemplate getInstance() {
return instance;
}
static final FloatTemplate instance = new FloatTemplate();
static {
TemplateRegistry.register(Float.class, instance);
TemplateRegistry.register(float.class, instance);
}
}

25
java/src/main/java/org/msgpack/template/GenericTemplate.java
View File

@ -1,25 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import org.msgpack.Template;
public interface GenericTemplate {
public Template build(Template[] params);
}

54
java/src/main/java/org/msgpack/template/GenericTemplate1.java
View File

@ -1,54 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.msgpack.Template;
public class GenericTemplate1 implements GenericTemplate {
Constructor<? extends Template> constructor;
public GenericTemplate1(Class<? extends Template> tmpl) {
try {
this.constructor = tmpl.getConstructor(new Class<?>[]{Template.class});
constructor.newInstance(new Object[]{AnyTemplate.getInstance()});
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException(e);
} catch (InvocationTargetException e) {
throw new IllegalArgumentException(e);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException(e);
} catch (InstantiationException e) {
throw new IllegalArgumentException(e);
}
}
public Template build(Template[] params) {
try {
return constructor.newInstance(params);
} catch (InvocationTargetException e) {
throw new IllegalArgumentException(e);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException(e);
} catch (InstantiationException e) {
throw new IllegalArgumentException(e);
}
}
}

54
java/src/main/java/org/msgpack/template/GenericTemplate2.java
View File

@ -1,54 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.msgpack.Template;
public class GenericTemplate2 implements GenericTemplate {
Constructor<? extends Template> constructor;
public GenericTemplate2(Class<? extends Template> tmpl) {
try {
this.constructor = tmpl.getConstructor(new Class<?>[]{Template.class, Template.class});
constructor.newInstance(new Object[]{AnyTemplate.getInstance(), AnyTemplate.getInstance()});
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException(e);
} catch (InvocationTargetException e) {
throw new IllegalArgumentException(e);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException(e);
} catch (InstantiationException e) {
throw new IllegalArgumentException(e);
}
}
public Template build(Template[] params) {
try {
return constructor.newInstance(params);
} catch (InvocationTargetException e) {
throw new IllegalArgumentException(e);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException(e);
} catch (InstantiationException e) {
throw new IllegalArgumentException(e);
}
}
}

42
java/src/main/java/org/msgpack/template/IFieldEntry.java
View File

@ -1,42 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.lang.reflect.Type;
public interface IFieldEntry {
public abstract String getName();
public abstract Class<?> getType();
public abstract String getJavaTypeName();
public abstract Type getGenericType();
public abstract FieldOption getOption();
public abstract boolean isAvailable();
public abstract boolean isRequired();
public abstract boolean isOptional();
public abstract boolean isNullable();
}

25
java/src/main/java/org/msgpack/template/IFieldEntryReader.java
View File

@ -1,25 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
public interface IFieldEntryReader {
public IFieldEntry[] convertFieldEntries(Class<?> targetClass, FieldList flist) throws NoSuchFieldException;
public IFieldEntry[] readFieldEntries(Class<?> targetClass, FieldOption implicitOption);
public FieldOption readImplicitFieldOption(Class<?> targetClass) ;
}

80
java/src/main/java/org/msgpack/template/IntArrayTemplate.java
View File

@ -1,80 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class IntArrayTemplate implements Template {
private IntArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof int[])) {
throw new MessageTypeException();
}
int[] array = (int[])target;
try {
pk.packArray(array.length);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
for(int a : array) {
pk.pack(a);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
int[] array;
if(to != null && to instanceof int[] && ((int[])to).length == length) {
array = (int[])to;
} else {
array = new int[length];
}
for(int i=0; i < length; i++) {
array[i] = pac.unpackInt();
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
int[] array;
if(to != null && to instanceof int[] && ((int[])to).length == src.length) {
array = (int[])to;
} else {
array = new int[src.length];
}
for(int i=0; i < src.length; i++) {
MessagePackObject s = src[i];
array[i] = s.asInt();
}
return array;
}
static public IntArrayTemplate getInstance() {
return instance;
}
static final IntArrayTemplate instance = new IntArrayTemplate();
static {
TemplateRegistry.register(int[].class, instance);
}
}

53
java/src/main/java/org/msgpack/template/IntegerTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class IntegerTemplate implements Template {
private IntegerTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packInt((Integer)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackInt();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asInt();
}
static public IntegerTemplate getInstance() {
return instance;
}
static final IntegerTemplate instance = new IntegerTemplate();
static {
TemplateRegistry.register(Integer.class, instance);
TemplateRegistry.register(int.class, instance);
}
}

91
java/src/main/java/org/msgpack/template/ListTemplate.java
View File

@ -1,91 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.util.List;
import java.util.ArrayList;
import java.io.IOException;
import org.msgpack.*;
public class ListTemplate implements Template {
static void load() { }
private Template elementTemplate;
public ListTemplate(Template elementTemplate) {
this.elementTemplate = elementTemplate;
}
public Template getElementTemplate() {
return elementTemplate;
}
@SuppressWarnings("unchecked")
public void pack(Packer pk, Object target) throws IOException {
if (! (target instanceof List)) {
if (target == null) {
throw new MessageTypeException(new NullPointerException("target is null."));
}
throw new MessageTypeException("target is not List type: " + target.getClass());
}
List<Object> list = (List<Object>)target;
pk.packArray(list.size());
for(Object element : list) {
elementTemplate.pack(pk, element);
}
}
@SuppressWarnings("unchecked")
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
List<Object> list;
if(to == null) {
list = new ArrayList<Object>(length);
} else {
list = (List<Object>) to;
list.clear();
}
for(; length > 0; length--) {
list.add( elementTemplate.unpack(pac, null) );
}
return list;
}
@SuppressWarnings("unchecked")
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] array = from.asArray();
List<Object> list;
if(to == null) {
list = new ArrayList<Object>(array.length);
} else {
// TODO: optimize if list is instanceof ArrayList
list = (List<Object>) to;
list.clear();
}
for(MessagePackObject element : array) {
list.add( elementTemplate.convert(element, null) );
}
return list;
}
static {
TemplateRegistry.registerGeneric(List.class, new GenericTemplate1(ListTemplate.class));
TemplateRegistry.register(List.class, new ListTemplate(AnyTemplate.getInstance()));
}
}

80
java/src/main/java/org/msgpack/template/LongArrayTemplate.java
View File

@ -1,80 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class LongArrayTemplate implements Template {
private LongArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof long[])) {
throw new MessageTypeException();
}
long[] array = (long[])target;
try {
pk.packArray(array.length);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
for(long a : array) {
pk.pack(a);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
long[] array;
if(to != null && to instanceof long[] && ((long[])to).length == length) {
array = (long[])to;
} else {
array = new long[length];
}
for(int i=0; i < length; i++) {
array[i] = pac.unpackLong();
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
long[] array;
if(to != null && to instanceof long[] && ((long[])to).length == src.length) {
array = (long[])to;
} else {
array = new long[src.length];
}
for(int i=0; i < src.length; i++) {
MessagePackObject s = src[i];
array[i] = s.asLong();
}
return array;
}
static public LongArrayTemplate getInstance() {
return instance;
}
static final LongArrayTemplate instance = new LongArrayTemplate();
static {
TemplateRegistry.register(long[].class, instance);
}
}

53
java/src/main/java/org/msgpack/template/LongTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class LongTemplate implements Template {
private LongTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packLong((Long)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackLong();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asLong();
}
static public LongTemplate getInstance() {
return instance;
}
static final LongTemplate instance = new LongTemplate();
static {
TemplateRegistry.register(Long.class, instance);
TemplateRegistry.register(long.class, instance);
}
}

101
java/src/main/java/org/msgpack/template/MapTemplate.java
View File

@ -1,101 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.util.Map;
import java.util.HashMap;
import java.io.IOException;
import org.msgpack.*;
public class MapTemplate implements Template {
static void load() { }
private Template keyTemplate;
private Template valueTemplate;
public MapTemplate(Template keyTemplate, Template valueTemplate) {
this.keyTemplate = keyTemplate;
this.valueTemplate = valueTemplate;
}
public Template getKeyTemplate() {
return keyTemplate;
}
public Template getValueTemplate() {
return valueTemplate;
}
@SuppressWarnings("unchecked")
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof Map)) {
if (target == null) {
throw new MessageTypeException(new NullPointerException("target is null."));
}
throw new MessageTypeException("target is not Map type: " + target.getClass());
}
Map<Object,Object> map = (Map<Object,Object>) target;
pk.packMap(map.size());
for(Map.Entry<Object,Object> pair : map.entrySet()) {
keyTemplate.pack(pk, pair.getKey());
valueTemplate.pack(pk, pair.getValue());
}
}
@SuppressWarnings("unchecked")
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackMap();
Map<Object,Object> map;
if(to == null) {
map = new HashMap<Object,Object>(length);
} else {
map = (Map<Object,Object>) to;
map.clear();
}
for(; length > 0; length--) {
Object key = keyTemplate.unpack(pac, null);
Object value = valueTemplate.unpack(pac, null);
map.put(key, value);
}
return map;
}
@SuppressWarnings("unchecked")
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
Map<MessagePackObject,MessagePackObject> src = from.asMap();
Map<Object,Object> map;
if(to == null) {
map = new HashMap<Object,Object>(src.size());
} else {
map = (Map<Object,Object>) to;
map.clear();
}
for(Map.Entry<MessagePackObject,MessagePackObject> pair : src.entrySet()) {
Object key = keyTemplate.convert(pair.getKey(), null);
Object value = valueTemplate.convert(pair.getValue(), null);
map.put(key, value);
}
return map;
}
static {
TemplateRegistry.registerGeneric(Map.class, new GenericTemplate2(MapTemplate.class));
TemplateRegistry.register(Map.class, new MapTemplate(AnyTemplate.getInstance(), AnyTemplate.getInstance()));
}
}

58
java/src/main/java/org/msgpack/template/NullableTemplate.java
View File

@ -1,58 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class NullableTemplate implements Template {
static void load() { }
private Template elementTemplate;
public NullableTemplate(Template elementTemplate) {
this.elementTemplate = elementTemplate;
}
public Template getElementTemplate() {
return elementTemplate;
}
public void pack(Packer pk, Object target) throws IOException {
if(target == null) {
pk.packNil();
} else {
elementTemplate.pack(pk, target);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
if(pac.tryUnpackNull()) {
return null;
}
return elementTemplate.unpack(pac, to);
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
if(from.isNil()) {
return null;
}
return elementTemplate.convert(from, to);
}
}

62
java/src/main/java/org/msgpack/template/OptionalTemplate.java
View File

@ -1,62 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class OptionalTemplate implements Template {
private Template elementTemplate;
private Object defaultObject;
public OptionalTemplate(Template elementTemplate) {
this(elementTemplate, null);
}
public OptionalTemplate(Template elementTemplate, Object defaultObject) {
this.elementTemplate = elementTemplate;
this.defaultObject = defaultObject;
}
public Template getElementTemplate() {
return elementTemplate;
}
public void pack(Packer pk, Object target) throws IOException {
if(target == null) {
pk.pack(defaultObject);
} else {
elementTemplate.pack(pk, target);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
if(pac.tryUnpackNull()) {
return defaultObject; // FIXME return to?
}
return elementTemplate.unpack(pac, to);
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
if(from.isNil()) {
return defaultObject; // FIXME return to?
}
return elementTemplate.convert(from, to);
}
}

80
java/src/main/java/org/msgpack/template/ShortArrayTemplate.java
View File

@ -1,80 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class ShortArrayTemplate implements Template {
private ShortArrayTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof short[])) {
throw new MessageTypeException();
}
short[] array = (short[])target;
try {
pk.packArray(array.length);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
for(short a : array) {
pk.pack(a);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
short[] array;
if(to != null && to instanceof short[] && ((short[])to).length == length) {
array = (short[])to;
} else {
array = new short[length];
}
for(int i=0; i < length; i++) {
array[i] = pac.unpackShort();
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
short[] array;
if(to != null && to instanceof short[] && ((short[])to).length == src.length) {
array = (short[])to;
} else {
array = new short[src.length];
}
for(int i=0; i < src.length; i++) {
MessagePackObject s = src[i];
array[i] = s.asShort();
}
return array;
}
static public ShortArrayTemplate getInstance() {
return instance;
}
static final ShortArrayTemplate instance = new ShortArrayTemplate();
static {
TemplateRegistry.register(short[].class, instance);
}
}

53
java/src/main/java/org/msgpack/template/ShortTemplate.java
View File

@ -1,53 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class ShortTemplate implements Template {
private ShortTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packShort((Short)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackShort();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asShort();
}
static public ShortTemplate getInstance() {
return instance;
}
static final ShortTemplate instance = new ShortTemplate();
static {
TemplateRegistry.register(Short.class, instance);
TemplateRegistry.register(short.class, instance);
}
}

52
java/src/main/java/org/msgpack/template/StringTemplate.java
View File

@ -1,52 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2010 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.io.IOException;
import org.msgpack.*;
public class StringTemplate implements Template {
private StringTemplate() { }
public void pack(Packer pk, Object target) throws IOException {
try {
pk.packString((String)target);
} catch (NullPointerException e) {
throw new MessageTypeException("target is null.", e);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
return pac.unpackString();
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
return from.asString();
}
static public StringTemplate getInstance() {
return instance;
}
static final StringTemplate instance = new StringTemplate();
static {
TemplateRegistry.register(String.class, instance);
}
}

35
java/src/main/java/org/msgpack/template/TemplateBuildException.java
View File

@ -1,35 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
@SuppressWarnings("serial")
public class TemplateBuildException extends RuntimeException {
public TemplateBuildException(String reason) {
super(reason);
}
public TemplateBuildException(String reason, Throwable t) {
super(reason, t);
}
public TemplateBuildException(Throwable t) {
super(t);
}
}

208
java/src/main/java/org/msgpack/template/TemplateRegistry.java
View File

@ -1,208 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template;
import java.util.Map;
import java.util.HashMap;
import java.lang.reflect.Type;
import java.lang.reflect.ParameterizedType;
import org.msgpack.template.builder.BuilderSelectorRegistry;
import org.msgpack.template.builder.CustomTemplateBuilder;
import org.msgpack.template.builder.TemplateBuilder;
import org.msgpack.Template;
public class TemplateRegistry {
private static Map<Type, Template> map;
private static Map<Type, GenericTemplate> genericMap;
private static BuilderSelectorRegistry builderSelectorRegistry;
static {
map = new HashMap<Type, Template>();
genericMap = new HashMap<Type, GenericTemplate>();
BuiltInTemplateLoader.load();
builderSelectorRegistry = BuilderSelectorRegistry.getInstance();
}
public static void register(Class<?> target) {
TemplateBuilder builder = builderSelectorRegistry.select(target);
if (builder != null) {
register(target,builder.buildTemplate(target));
} else {
register(target,builderSelectorRegistry.getForceBuilder().buildTemplate(target));
}
}
public static void register(Class<?> target, FieldOption implicitOption) {
TemplateBuilder builder = builderSelectorRegistry.select(target);
if (builder != null && builder instanceof CustomTemplateBuilder) {
register(target, ((CustomTemplateBuilder)builder).buildTemplate(target, implicitOption));
} else {
throw new TemplateBuildException("Cannot build template with filed option");
}
}
public static void register(Class<?> target, FieldList flist) throws NoSuchFieldException {
TemplateBuilder builder = builderSelectorRegistry.select(target);
if (builder != null && builder instanceof CustomTemplateBuilder) {
register(target, ((CustomTemplateBuilder)builder).buildTemplate(target, flist));
} else {
throw new TemplateBuildException("Cannot build template with filed list");
}
}
public static synchronized void register(Type rawType, Template tmpl) {
if (rawType instanceof ParameterizedType) {
rawType = ((ParameterizedType)rawType).getRawType();
}
map.put(rawType, tmpl);
}
public static synchronized boolean unregister(Class<?> target) {
Template tmpl = map.remove(target);
return tmpl != null;
}
public static synchronized void registerGeneric(Type rawType, GenericTemplate gtmpl) {
if(rawType instanceof ParameterizedType) {
rawType = ((ParameterizedType)rawType).getRawType();
}
genericMap.put(rawType, gtmpl);
}
public static synchronized Template lookup(Type targetType) {
return lookupImpl(targetType, true, false, true);
}
public static synchronized Template lookup(Type targetType, boolean forceBuild) {
return lookupImpl(targetType, true, forceBuild, true);
}
public static synchronized Template lookup(Type targetType, boolean forceLoad, boolean forceBuild) {
return lookupImpl(targetType, forceLoad, forceBuild, true);
}
public static synchronized Template tryLookup(Type targetType) {
return lookupImpl(targetType, true, false, false);
}
public static synchronized Template tryLookup(Type targetType, boolean forceBuild) {
return lookupImpl(targetType, true, forceBuild, false);
}
private static synchronized Template lookupImpl(Type targetType,
boolean forceLoad, boolean forceBuild, boolean fallbackDefault) {
Template tmpl;
if(targetType instanceof ParameterizedType) {
// ParameterizedType is not a Class<?>?
tmpl = lookupGenericImpl((ParameterizedType)targetType);
if(tmpl != null) {
return tmpl;
}
targetType = ((ParameterizedType)targetType).getRawType();
}
tmpl = map.get(targetType);
if(tmpl != null) {
return tmpl;
}
// find match TemplateBuilder
TemplateBuilder builder = BuilderSelectorRegistry.getInstance().select(targetType);
if (builder != null) {
if (forceLoad) {
tmpl = builder.loadTemplate(targetType);
if (tmpl != null) {
register(targetType, tmpl);
return tmpl;
}
}
tmpl = builder.buildTemplate(targetType);
if (tmpl != null) {
register(targetType, tmpl);
return tmpl;
}
}
Class<?> target = (Class<?>)targetType;
for(Class<?> i : target.getInterfaces()) {
tmpl = map.get(i);
if(tmpl != null) {
register(target, tmpl);
return tmpl;
}
}
Class<?> c = target.getSuperclass();
if(c != null) {
for(; c != Object.class; c = c.getSuperclass()) {
tmpl = map.get(c);
if(tmpl != null) {
register(target, tmpl);
return tmpl;
}
}
if(forceBuild) {
tmpl = builderSelectorRegistry.getForceBuilder().buildTemplate(target);
register(target, tmpl);
return tmpl;
}
}
if(fallbackDefault) {
tmpl = new DefaultTemplate((Class<?>)target);
register(target, tmpl);
return tmpl;
} else {
return null;
}
}
public static synchronized Template lookupGeneric(Type targetType) {
if(targetType instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType)targetType;
Template tmpl = lookupGenericImpl(parameterizedType);
if(tmpl != null) {
return tmpl;
}
return new DefaultTemplate((Class<?>)parameterizedType.getRawType(), parameterizedType);
} else {
throw new IllegalArgumentException("Actual types of the generic type are erased: "+targetType);
}
}
private static synchronized Template lookupGenericImpl(ParameterizedType type) {
Type rawType = type.getRawType();
GenericTemplate gtmpl = genericMap.get(rawType);
if(gtmpl == null) {
return null;
}
Type[] types = type.getActualTypeArguments();
Template[] tmpls = new Template[types.length];
for(int i=0; i < types.length; i++) {
tmpls[i] = lookup(types[i]);
}
return gtmpl.build(tmpls);
}
}

54
java/src/main/java/org/msgpack/template/builder/AnnotationTemplateBuilderSelector.java
View File

@ -1,54 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import org.msgpack.annotation.MessagePackMessage;
public class AnnotationTemplateBuilderSelector implements BuilderSelector{
public static final String NAME = "AnnotationTemplateBuilder";
TemplateBuilder builder;
public AnnotationTemplateBuilderSelector(TemplateBuilder builder){
this.builder = builder;
}
@Override
public String getName(){
return NAME;
}
@Override
public boolean matchType(Type targetType) {
Class<?> targetClass = (Class<?>)targetType;
return isAnnotated(targetClass, MessagePackMessage.class);
}
@Override
public TemplateBuilder getTemplateBuilder(Type targetType) {
return builder;
}
public static boolean isAnnotated(Class<?> targetClass, Class<? extends Annotation> with) {
return targetClass.getAnnotation(with) != null;
}
}

194
java/src/main/java/org/msgpack/template/builder/ArrayTemplateBuilder.java
View File

@ -1,194 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import org.msgpack.AbstractTemplate;
import org.msgpack.MessagePackObject;
import org.msgpack.MessageTypeException;
import org.msgpack.Packer;
import org.msgpack.Template;
import org.msgpack.Unpacker;
import org.msgpack.template.BooleanArrayTemplate;
import org.msgpack.template.DoubleArrayTemplate;
import org.msgpack.template.FloatArrayTemplate;
import org.msgpack.template.IntArrayTemplate;
import org.msgpack.template.LongArrayTemplate;
import org.msgpack.template.ShortArrayTemplate;
import org.msgpack.template.TemplateRegistry;
public class ArrayTemplateBuilder implements TemplateBuilder {
static class ReflectionObjectArrayTemplate extends AbstractTemplate {
private Class<?> componentClass;
private Template elementTemplate;
public ReflectionObjectArrayTemplate(Class<?> componentClass, Template elementTemplate) {
this.componentClass = componentClass;
this.elementTemplate = elementTemplate;
}
public void pack(Packer pk, Object target) throws IOException {
if(!(target instanceof Object[]) || !componentClass.isAssignableFrom(target.getClass().getComponentType())) {
throw new MessageTypeException();
}
Object[] array = (Object[])target;
int length = array.length;
pk.packArray(length);
for(int i=0; i < length; i++) {
elementTemplate.pack(pk, array[i]);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException {
int length = pac.unpackArray();
Object[] array = (Object[])Array.newInstance(componentClass, length);
for(int i=0; i < length; i++) {
array[i] = elementTemplate.unpack(pac, null);
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
int length = src.length;
Object[] array = (Object[])Array.newInstance(componentClass, length);
for(int i=0; i < length; i++) {
array[i] = elementTemplate.convert(src[i], null);
}
return array;
}
}
static class ReflectionMultidimentionalArrayTemplate extends AbstractTemplate {
private Class<?> componentClass;
private Template componentTemplate;
public ReflectionMultidimentionalArrayTemplate(Class<?> componentClass, Template componentTemplate) {
this.componentClass = componentClass;
this.componentTemplate = componentTemplate;
}
Class<?> getComponentClass() {
return componentClass;
}
public void pack(Packer pk, Object target) throws IOException {
Object[] array = (Object[])target;
int length = array.length;
pk.packArray(length);
for(int i=0; i < length; i++) {
componentTemplate.pack(pk, array[i]);
}
}
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
int length = pac.unpackArray();
Object[] array = (Object[])Array.newInstance(componentClass, length);
for(int i=0; i < length; i++) {
array[i] = componentTemplate.unpack(pac, null);
}
return array;
}
public Object convert(MessagePackObject from, Object to) throws MessageTypeException {
MessagePackObject[] src = from.asArray();
int length = src.length;
Object[] array = (Object[])Array.newInstance(componentClass, length);
for(int i=0; i < length; i++) {
array[i] = componentTemplate.convert(src[i], null);
}
return array;
}
}
@Override
public Template buildTemplate(Type arrayType) {
Type baseType;
Class<?> baseClass;
int dim = 1;
if(arrayType instanceof GenericArrayType) {
GenericArrayType type = (GenericArrayType)arrayType;
baseType = type.getGenericComponentType();
while(baseType instanceof GenericArrayType) {
baseType = ((GenericArrayType)baseType).getGenericComponentType();
dim += 1;
}
if(baseType instanceof ParameterizedType) {
baseClass = (Class<?>)((ParameterizedType)baseType).getRawType();
} else {
baseClass = (Class<?>)baseType;
}
} else {
Class<?> type = (Class<?>)arrayType;
baseClass = type.getComponentType();
while(baseClass.isArray()) {
baseClass = baseClass.getComponentType();
dim += 1;
}
baseType = baseClass;
}
return toTemplate(arrayType, baseType, baseClass, dim);
}
private Template toTemplate(Type arrayType, Type genericBaseType, Class<?> baseClass, int dim) {
if(dim == 1) {
if(baseClass == boolean.class) {
return BooleanArrayTemplate.getInstance();
} else if(baseClass == short.class) {
return ShortArrayTemplate.getInstance();
} else if(baseClass == int.class) {
return IntArrayTemplate.getInstance();
} else if(baseClass == long.class) {
return LongArrayTemplate.getInstance();
} else if(baseClass == float.class) {
return FloatArrayTemplate.getInstance();
} else if(baseClass == double.class) {
return DoubleArrayTemplate.getInstance();
} else {
Template baseTemplate = TemplateRegistry.lookup(genericBaseType);
return new ReflectionObjectArrayTemplate(baseClass, baseTemplate);
}
} else if(dim == 2) {
Class<?> componentClass = Array.newInstance(baseClass, 0).getClass();
Template componentTemplate = toTemplate(arrayType, genericBaseType, baseClass, dim-1);
return new ReflectionMultidimentionalArrayTemplate(componentClass, componentTemplate);
} else {
ReflectionMultidimentionalArrayTemplate componentTemplate = (ReflectionMultidimentionalArrayTemplate)
toTemplate(arrayType, genericBaseType, baseClass, dim-1);
Class<?> componentClass = Array.newInstance(componentTemplate.getComponentClass(), 0).getClass();
return new ReflectionMultidimentionalArrayTemplate(componentClass, componentTemplate);
}
}
@Override
public void writeTemplate(Type targetType, String directoryName) {
throw new UnsupportedOperationException(targetType.toString());
}
@Override
public Template loadTemplate(Type targetType) {
return null;
}
}

49
java/src/main/java/org/msgpack/template/builder/ArrayTemplateBuilderSelector.java
View File

@ -1,49 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Type;
public class ArrayTemplateBuilderSelector implements BuilderSelector {
public static final String NAME = "ArrayTemplateBuilder";
ArrayTemplateBuilder templateBuilder = new ArrayTemplateBuilder();
@Override
public String getName(){
return NAME;
}
@Override
public boolean matchType(Type targetType) {
if(targetType instanceof GenericArrayType){
return true;
}
Class<?> targetClass = (Class<?>)targetType;
return targetClass.isArray();
}
@Override
public TemplateBuilder getTemplateBuilder(Type target) {
return templateBuilder;
}
}

285
java/src/main/java/org/msgpack/template/builder/BeansBuildContext.java
View File

@ -1,285 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.msgpack.*;
import org.msgpack.template.*;
import javassist.CannotCompileException;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtNewConstructor;
import javassist.NotFoundException;
public class BeansBuildContext extends BuildContextBase<BeansFieldEntry> {
protected BeansFieldEntry[] entries;
protected Class<?> origClass;
protected String origName;
protected Template[] templates;
protected int minimumArrayLength;
public BeansBuildContext(JavassistTemplateBuilder director) {
super(director);
}
public Template buildTemplate(Class<?> targetClass, BeansFieldEntry[] entries, Template[] templates) {
this.entries = entries;
this.templates = templates;
this.origClass = targetClass;
this.origName = this.origClass.getName();
return build(this.origName);
}
protected void setSuperClass() throws CannotCompileException, NotFoundException {
this.tmplCtClass.setSuperclass(
director.getCtClass(JavassistTemplateBuilder.JavassistTemplate.class.getName()));
}
protected void buildConstructor() throws CannotCompileException, NotFoundException {
// Constructor(Class targetClass, Template[] templates)
CtConstructor newCtCons = CtNewConstructor.make(
new CtClass[] {
director.getCtClass(Class.class.getName()),
director.getCtClass(Template.class.getName()+"[]")
},
new CtClass[0],
this.tmplCtClass);
this.tmplCtClass.addConstructor(newCtCons);
}
protected Template buildInstance(Class<?> c) throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Constructor<?> cons = c.getConstructor(new Class[] {
Class.class,
Template[].class
});
Object tmpl = cons.newInstance(new Object[] {
this.origClass,
this.templates
});
return (Template)tmpl;
}
protected void buildMethodInit() {
this.minimumArrayLength = 0;
for(int i=0; i < entries.length; i++) {
IFieldEntry e = entries[i];
if(e.isRequired() || e.isNullable()) {
this.minimumArrayLength = i+1;
}
}
}
protected String buildPackMethodBody() {
resetStringBuilder();
buildString("{");
buildString("%s _$$_t = (%s)$2;", this.origName, this.origName);
buildString("$1.packArray(%d);", entries.length);
for(int i=0; i < entries.length; i++) {
BeansFieldEntry e = entries[i];
if(!e.isAvailable()) {
buildString("$1.packNil();");
continue;
}
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("$1.%s(_$$_t.%s());", primitivePackName(type), e.getGetterName());
} else {
buildString("if(_$$_t.%s() == null) {", e.getGetterName());
if(!e.isNullable() && !e.isOptional()) {
buildString("throw new %s();", MessageTypeException.class.getName());
} else {
buildString("$1.packNil();");
}
buildString("} else {");
buildString(" this.templates[%d].pack($1, _$$_t.%s());", i, e.getGetterName());
buildString("}");
}
}
buildString("}");
return getBuiltString();
}
protected String buildUnpackMethodBody() {
resetStringBuilder();
buildString("{ ");
buildString("%s _$$_t;", this.origName);
buildString("if($2 == null) {");
buildString(" _$$_t = new %s();", this.origName);
buildString("} else {");
buildString(" _$$_t = (%s)$2;", this.origName);
buildString("}");
buildString("int length = $1.unpackArray();");
buildString("if(length < %d) {", this.minimumArrayLength);
buildString(" throw new %s();", MessageTypeException.class.getName());
buildString("}");
int i;
for(i=0; i < this.minimumArrayLength; i++) {
BeansFieldEntry e = entries[i];
if(!e.isAvailable()) {
buildString("$1.unpackObject();");
continue;
}
buildString("if($1.tryUnpackNull()) {");
if(e.isRequired()) {
// Required + nil => exception
buildString("throw new %s();", MessageTypeException.class.getName());
} else if(e.isOptional()) {
// Optional + nil => keep default value
} else { // Nullable
// Nullable + nil => set null
buildString("_$$_t.%s(null);", e.getSetterName());
}
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.set%s( $1.%s() );", e.getName(), primitiveUnpackName(type));
} else {
buildString("_$$_t.set%s( (%s)this.templates[%d].unpack($1, _$$_t.get%s()) );", e.getName(), e.getJavaTypeName(), i, e.getName());
}
buildString("}");
}
for(; i < entries.length; i++) {
buildString("if(length <= %d) { return _$$_t; }", i);
BeansFieldEntry e = entries[i];
if(!e.isAvailable()) {
buildString("$1.unpackObject();");
continue;
}
buildString("if($1.tryUnpackNull()) {");
// this is Optional field becaue i >= minimumArrayLength
// Optional + nil => keep default value
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s( $1.%s() );", e.getSetterName(), primitiveUnpackName(type));
} else {
buildString("_$$_t.%s( (%s)this.templates[%d].unpack($1, _$$_t.%s()) );", e.getSetterName(), e.getJavaTypeName(), i, e.getGetterName());
}
buildString("}");
}
// latter entries are all Optional + nil => keep default value
buildString("for(int i=%d; i < length; i++) {", i);
buildString(" $1.unpackObject();");
buildString("}");
buildString("return _$$_t;");
buildString("}");
return getBuiltString();
}
protected String buildConvertMethodBody() {
resetStringBuilder();
buildString("{ ");
buildString("%s _$$_t;", this.origName);
buildString("if($2 == null) {");
buildString(" _$$_t = new %s();", this.origName);
buildString("} else {");
buildString(" _$$_t = (%s)$2;", this.origName);
buildString("}");
buildString("%s[] array = $1.asArray();", MessagePackObject.class.getName());
buildString("int length = array.length;");
buildString("if(length < %d) {", this.minimumArrayLength);
buildString(" throw new %s();", MessageTypeException.class.getName());
buildString("}");
buildString("%s obj;", MessagePackObject.class.getName());
int i;
for(i=0; i < this.minimumArrayLength; i++) {
BeansFieldEntry e = entries[i];
if(!e.isAvailable()) {
continue;
}
buildString("obj = array[%d];", i);
buildString("if(obj.isNil()) {");
if(e.isRequired()) {
// Required + nil => exception
buildString("throw new %s();", MessageTypeException.class.getName());
} else if(e.isOptional()) {
// Optional + nil => keep default value
} else { // Nullable
// Nullable + nil => set null
buildString("_$$_t.%s( null );", e.getSetterName());
}
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s( obj.%s() );", e.getSetterName(), primitiveConvertName(type));
} else {
buildString("_$$_t.%s( (%s)this.templates[%d].convert(obj, _$$_t.%s()) );", e.getSetterName(), e.getJavaTypeName(), i, e.getGetterName());
}
buildString("}");
}
for(; i < entries.length; i++) {
buildString("if(length <= %d) { return _$$_t; }", i);
BeansFieldEntry e = entries[i];
if(!e.isAvailable()) {
continue;
}
buildString("obj = array[%d];", i);
buildString("if(obj.isNil()) {");
// this is Optional field becaue i >= minimumArrayLength
// Optional + nil => keep default value
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s( obj.%s() );", e.getSetterName(), primitiveConvertName(type));
} else {
buildString("_$$_t.%s( (%s)this.templates[%d].convert(obj, _$$_t.%s()) );", e.getSetterName(), e.getJavaTypeName(), i, e.getGetterName());
}
buildString("}");
}
// latter entries are all Optional + nil => keep default value
buildString("return _$$_t;");
buildString("}");
return getBuiltString();
}
@Override
public void writeTemplate(Class<?> targetClass, BeansFieldEntry[] entries,
Template[] templates, String directoryName) {
throw new UnsupportedOperationException(targetClass.getName());
}
@Override
public Template loadTemplate(Class<?> targetClass, BeansFieldEntry[] entries, Template[] templates) {
return null;
}
}

328
java/src/main/java/org/msgpack/template/builder/BeansTemplateBuilder.java
View File

@ -1,328 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.io.IOException;
import java.lang.reflect.Type;
import org.msgpack.AbstractTemplate;
import org.msgpack.MessagePackObject;
import org.msgpack.MessageTypeException;
import org.msgpack.Packer;
import org.msgpack.Template;
import org.msgpack.Unpacker;
import org.msgpack.template.BeansFieldEntry;
import org.msgpack.template.BeansFieldEntryReader;
import org.msgpack.template.IFieldEntry;
import org.msgpack.template.IFieldEntryReader;
import org.msgpack.template.TemplateRegistry;
/**
* Class for building java reflection template builder for java beans class.
* @author takeshita
*
*/
public class BeansTemplateBuilder extends CustomTemplateBuilder{
IFieldEntryReader reader = new BeansFieldEntryReader();
public BeansTemplateBuilder(){}
@Override
public IFieldEntryReader getFieldEntryReader(){
return reader;
}
static class ReflectionEntry{
BeansFieldEntry entry;
public ReflectionEntry(BeansFieldEntry entry){
this.entry = entry;
}
public void pack(Object value , Packer packer) throws IOException{
packer.pack(value);
}
public void convert(Object target, MessagePackObject obj) throws MessageTypeException, IllegalAccessException {
entry.set(target, obj.convert(entry.getType()));
}
public void unpack(Object target, Unpacker unpacker) throws IOException, MessageTypeException, IllegalAccessException {
entry.set(target, unpacker.unpack(entry.getType()));
}
public void setNull(Object target){
entry.set(target, null);
}
public boolean isRequired(){
return entry.isRequired();
}
public boolean isNullable(){
return entry.isNullable();
}
public boolean isAvailable(){
return entry.isAvailable();
}
public boolean isOptional(){
return entry.isOptional();
}
public Object get(Object target){
return entry.get(target);
}
}
static class ObjectFieldEntry extends ReflectionEntry{
Template template;
public ObjectFieldEntry(BeansFieldEntry entry,Template template){
super(entry);
this.template = template;
}
public void pack(Object value , Packer packer) throws IOException{
template.pack(packer,value);
}
public void convert(Object target, MessagePackObject obj) throws MessageTypeException, IllegalAccessException {
Class<Object> type = (Class<Object>)entry.getType();
Object fieldReference = entry.get(target);
Object valueReference = template.convert(obj, fieldReference);
if(valueReference != fieldReference) {
entry.set(target, valueReference);
}
}
public void unpack(Object target, Unpacker unpacker) throws IOException, MessageTypeException, IllegalAccessException {
Class<Object> type = (Class<Object>)entry.getType();
Object fieldReference = entry.get(target);
Object valueReference = template.unpack(unpacker, fieldReference);
if(valueReference != fieldReference) {
entry.set(target, valueReference);
}
}
}
static class BeansReflectionTemplate extends AbstractTemplate{
Class<?> targetClass;
ReflectionEntry[] entries = null;
protected int minimumArrayLength;
public BeansReflectionTemplate(
Class<?> targetClass,
ReflectionEntry[] entries){
this.targetClass = targetClass;
this.entries = entries;
this.minimumArrayLength = 0;
for(int i=0; i < entries.length; i++) {
ReflectionEntry e = entries[i];
if(e.isRequired() || e.isNullable()) {
this.minimumArrayLength = i+1;
}
}
}
@Override
public void pack(Packer pk, Object target) throws IOException {
pk.packArray(entries.length);
for(ReflectionEntry e : entries){
if(!e.isAvailable()){
pk.packNil();
continue;
}
Object obj = e.get(target);
if(obj == null) {
if(!e.isNullable() && !e.isOptional()) {
throw new MessageTypeException();
}
pk.packNil();
} else {
e.pack(obj, pk);
}
}
}
@Override
public Object unpack(Unpacker pac, Object to) throws IOException, MessageTypeException {
try {
if(to == null) {
to = targetClass.newInstance();
}
int length = pac.unpackArray();
if(length < minimumArrayLength) {
throw new MessageTypeException();
}
int i;
for(i=0; i < minimumArrayLength; i++) {
ReflectionEntry e = entries[i];
if(!e.isAvailable()) {
pac.unpackObject();
continue;
}
if(pac.tryUnpackNull()) {
if(e.isRequired()) {
// Required + nil => exception
throw new MessageTypeException();
} else if(e.isOptional()) {
// Optional + nil => keep default value
} else { // Nullable
// Nullable + nil => set null
e.setNull(to);
}
} else {
e.unpack(to,pac);
//e.set(to, pac.unpack(e.getType()));
}
}
int max = length < entries.length ? length : entries.length;
for(; i < max; i++) {
ReflectionEntry e = entries[i];
if(!e.isAvailable()) {
pac.unpackObject();
continue;
}
if(pac.tryUnpackNull()) {
// this is Optional field becaue i >= minimumArrayLength
// Optional + nil => keep default value
} else {
e.unpack(to, pac);
//e.set(to, pac.unpack(e.getType()));
}
}
// latter entries are all Optional + nil => keep default value
for(; i < length; i++) {
pac.unpackObject();
}
return to;
} catch (MessageTypeException e) {
throw e;
} catch (IOException e) {
throw e;
} catch (Exception e) {
throw new MessageTypeException(e);
}
}
@Override
public Object convert(MessagePackObject from, Object to)
throws MessageTypeException {
try {
if(to == null) {
to = targetClass.newInstance();
}
MessagePackObject[] array = from.asArray();
int length = array.length;
if(length < minimumArrayLength) {
throw new MessageTypeException();
}
int i;
for(i=0; i < minimumArrayLength; i++) {
ReflectionEntry e = entries[i];
if(!e.isAvailable()) {
continue;
}
MessagePackObject obj = array[i];
if(obj.isNil()) {
if(e.isRequired()) {
// Required + nil => exception
throw new MessageTypeException();
} else if(e.isOptional()) {
// Optional + nil => keep default value
} else { // Nullable
// Nullable + nil => set null
e.setNull(to);
//e.set(to,null);
}
} else {
e.convert(to, obj);
//e.set(to, from.convert(e.getType()));
}
}
int max = length < entries.length ? length : entries.length;
for(; i < max; i++) {
ReflectionEntry e = entries[i];
if(!e.isAvailable()) {
continue;
}
MessagePackObject obj = array[i];
if(obj.isNil()) {
// this is Optional field becaue i >= minimumArrayLength
// Optional + nil => keep default value
} else {
e.convert(to, obj);
//e.set(to, obj.convert(e.getType()));
}
}
// latter entries are all Optional + nil => keep default value
return to;
} catch (MessageTypeException e) {
throw e;
} catch (Exception e) {
throw new MessageTypeException(e);
}
}
}
@Override
public Template buildTemplate(Class<?> targetClass, IFieldEntry[] entries) {
ReflectionEntry[] refEntries = new ReflectionEntry[entries.length];
for(int i = 0;i < entries.length;i++){
BeansFieldEntry e = (BeansFieldEntry)entries[i];
Class<?> type = e.getType();
if(type.equals(boolean.class)) {
refEntries[i] = new ReflectionEntry(e);
} else if(type.equals(byte.class)) {
refEntries[i] = new ReflectionEntry(e);
} else if(type.equals(short.class)) {
refEntries[i] = new ReflectionEntry(e);
} else if(type.equals(int.class)) {
refEntries[i] = new ReflectionEntry(e);
} else if(type.equals(long.class)) {
refEntries[i] = new ReflectionEntry(e);
} else if(type.equals(float.class)) {
refEntries[i] = new ReflectionEntry(e);
} else if(type.equals(double.class)) {
refEntries[i] = new ReflectionEntry(e);
} else {
Template tmpl = TemplateRegistry.lookup(e.getGenericType(), true);
refEntries[i] = new ObjectFieldEntry(e, tmpl);
}
}
return new BeansReflectionTemplate(targetClass,refEntries);
}
}

49
java/src/main/java/org/msgpack/template/builder/BeansTemplateBuilderSelector.java
View File

@ -1,49 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.lang.reflect.Type;
import org.msgpack.annotation.MessagePackBeans;
public class BeansTemplateBuilderSelector implements BuilderSelector{
public static final String NAME = "BeansTemplateBuilder";
TemplateBuilder builder;
public BeansTemplateBuilderSelector(TemplateBuilder builder){
this.builder = builder;
}
@Override
public String getName(){
return NAME;
}
@Override
public boolean matchType(Type targetType) {
Class<?> targetClass = (Class<?>)targetType;
return AnnotationTemplateBuilderSelector.isAnnotated(targetClass, MessagePackBeans.class);
}
@Override
public TemplateBuilder getTemplateBuilder(Type targetType) {
return builder;
}
}

293
java/src/main/java/org/msgpack/template/builder/BuildContext.java
View File

@ -1,293 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import org.msgpack.*;
import org.msgpack.template.*;
import javassist.CannotCompileException;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtNewConstructor;
import javassist.NotFoundException;
public class BuildContext extends BuildContextBase<FieldEntry> {
protected IFieldEntry[] entries;
protected Class<?> origClass;
protected String origName;
protected Template[] templates;
protected int minimumArrayLength;
public BuildContext(JavassistTemplateBuilder director) {
super(director);
}
public Template buildTemplate(Class<?> targetClass, FieldEntry[] entries, Template[] templates) {
this.entries = entries;
this.templates = templates;
this.origClass = targetClass;
this.origName = this.origClass.getName();
return build(this.origName);
}
protected void setSuperClass() throws CannotCompileException, NotFoundException {
this.tmplCtClass.setSuperclass(
director.getCtClass(JavassistTemplateBuilder.JavassistTemplate.class.getName()));
}
protected void buildConstructor() throws CannotCompileException, NotFoundException {
// Constructor(Class targetClass, Template[] templates)
CtConstructor newCtCons = CtNewConstructor.make(
new CtClass[] {
director.getCtClass(Class.class.getName()),
director.getCtClass(Template.class.getName()+"[]")
},
new CtClass[0],
this.tmplCtClass);
this.tmplCtClass.addConstructor(newCtCons);
}
protected Template buildInstance(Class<?> c) throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Constructor<?> cons = c.getConstructor(new Class[] {
Class.class,
Template[].class
});
Object tmpl = cons.newInstance(new Object[] {
this.origClass,
this.templates
});
return (Template)tmpl;
}
protected void buildMethodInit() {
this.minimumArrayLength = 0;
for(int i=0; i < entries.length; i++) {
IFieldEntry e = entries[i];
if(e.isRequired() || e.isNullable()) {
this.minimumArrayLength = i+1;
}
}
}
protected String buildPackMethodBody() {
resetStringBuilder();
buildString("{");
buildString("%s _$$_t = (%s)$2;", this.origName, this.origName);
buildString("$1.packArray(%d);", entries.length);
for(int i=0; i < entries.length; i++) {
IFieldEntry e = entries[i];
if(!e.isAvailable()) {
buildString("$1.packNil();");
continue;
}
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("$1.%s(_$$_t.%s);", primitivePackName(type), e.getName());
} else {
buildString("if(_$$_t.%s == null) {", e.getName());
if(!e.isNullable() && !e.isOptional()) {
buildString("throw new %s();", MessageTypeException.class.getName());
} else {
buildString("$1.packNil();");
}
buildString("} else {");
buildString(" this.templates[%d].pack($1, _$$_t.%s);", i, e.getName());
buildString("}");
}
}
buildString("}");
return getBuiltString();
}
protected String buildUnpackMethodBody() {
resetStringBuilder();
buildString("{ ");
buildString("%s _$$_t;", this.origName);
buildString("if($2 == null) {");
buildString(" _$$_t = new %s();", this.origName);
buildString("} else {");
buildString(" _$$_t = (%s)$2;", this.origName);
buildString("}");
buildString("int length = $1.unpackArray();");
buildString("if(length < %d) {", this.minimumArrayLength);
buildString(" throw new %s();", MessageTypeException.class.getName());
buildString("}");
int i;
for(i=0; i < this.minimumArrayLength; i++) {
IFieldEntry e = entries[i];
if(!e.isAvailable()) {
buildString("$1.unpackObject();");
continue;
}
buildString("if($1.tryUnpackNull()) {");
if(e.isRequired()) {
// Required + nil => exception
buildString("throw new %s();", MessageTypeException.class.getName());
} else if(e.isOptional()) {
// Optional + nil => keep default value
} else { // Nullable
// Nullable + nil => set null
buildString("_$$_t.%s = null;", e.getName());
}
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s = $1.%s();", e.getName(), primitiveUnpackName(type));
} else {
buildString("_$$_t.%s = (%s)this.templates[%d].unpack($1, _$$_t.%s);", e.getName(), e.getJavaTypeName(), i, e.getName());
}
buildString("}");
}
for(; i < entries.length; i++) {
buildString("if(length <= %d) { return _$$_t; }", i);
IFieldEntry e = entries[i];
if(!e.isAvailable()) {
buildString("$1.unpackObject();");
continue;
}
buildString("if($1.tryUnpackNull()) {");
// this is Optional field becaue i >= minimumArrayLength
// Optional + nil => keep default value
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s = $1.%s();", e.getName(), primitiveUnpackName(type));
} else {
buildString("_$$_t.%s = (%s)this.templates[%d].unpack($1, _$$_t.%s);", e.getName(), e.getJavaTypeName(), i, e.getName());
}
buildString("}");
}
// latter entries are all Optional + nil => keep default value
buildString("for(int i=%d; i < length; i++) {", i);
buildString(" $1.unpackObject();");
buildString("}");
buildString("return _$$_t;");
buildString("}");
return getBuiltString();
}
protected String buildConvertMethodBody() {
resetStringBuilder();
buildString("{ ");
buildString("%s _$$_t;", this.origName);
buildString("if($2 == null) {");
buildString(" _$$_t = new %s();", this.origName);
buildString("} else {");
buildString(" _$$_t = (%s)$2;", this.origName);
buildString("}");
buildString("%s[] array = $1.asArray();", MessagePackObject.class.getName());
buildString("int length = array.length;");
buildString("if(length < %d) {", this.minimumArrayLength);
buildString(" throw new %s();", MessageTypeException.class.getName());
buildString("}");
buildString("%s obj;", MessagePackObject.class.getName());
int i;
for(i=0; i < this.minimumArrayLength; i++) {
IFieldEntry e = entries[i];
if(!e.isAvailable()) {
continue;
}
buildString("obj = array[%d];", i);
buildString("if(obj.isNil()) {");
if(e.isRequired()) {
// Required + nil => exception
buildString("throw new %s();", MessageTypeException.class.getName());
} else if(e.isOptional()) {
// Optional + nil => keep default value
} else { // Nullable
// Nullable + nil => set null
buildString("_$$_t.%s = null;", e.getName());
}
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s = obj.%s();", e.getName(), primitiveConvertName(type));
} else {
buildString("_$$_t.%s = (%s)this.templates[%d].convert(obj, _$$_t.%s);", e.getName(), e.getJavaTypeName(), i, e.getName());
}
buildString("}");
}
for(; i < entries.length; i++) {
buildString("if(length <= %d) { return _$$_t; }", i);
IFieldEntry e = entries[i];
if(!e.isAvailable()) {
continue;
}
buildString("obj = array[%d];", i);
buildString("if(obj.isNil()) {");
// this is Optional field becaue i >= minimumArrayLength
// Optional + nil => keep default value
buildString("} else {");
Class<?> type = e.getType();
if(type.isPrimitive()) {
buildString("_$$_t.%s = obj.%s();", e.getName(), primitiveConvertName(type));
} else {
buildString("_$$_t.%s = (%s)this.templates[%d].convert(obj, _$$_t.%s);", e.getName(), e.getJavaTypeName(), i, e.getName());
}
buildString("}");
}
// latter entries are all Optional + nil => keep default value
buildString("return _$$_t;");
buildString("}");
return getBuiltString();
}
@Override
public void writeTemplate(Class<?> targetClass, FieldEntry[] entries,
Template[] templates, String directoryName) {
this.entries = entries;
this.templates = templates;
this.origClass = targetClass;
this.origName = this.origClass.getName();
write(this.origName, directoryName);
}
@Override
public Template loadTemplate(Class<?> targetClass, FieldEntry[] entries, Template[] templates) {
this.entries = entries;
this.templates = templates;
this.origClass = targetClass;
this.origName = this.origClass.getName();
return load(this.origName);
}
}

285
java/src/main/java/org/msgpack/template/builder/BuildContextBase.java
View File

@ -1,285 +0,0 @@
//
// MessagePack for Java
//
// Copyright (C) 2009-2011 FURUHASHI Sadayuki
//
// 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 org.msgpack.template.builder;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import org.msgpack.*;
import org.msgpack.template.*;
import javassist.CannotCompileException;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.CtNewMethod;
import javassist.NotFoundException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class BuildContextBase<T extends IFieldEntry> {
private static Logger LOG = LoggerFactory.getLogger(JavassistTemplateBuilder.class);
protected JavassistTemplateBuilder director;
protected String tmplName;
protected CtClass tmplCtClass;
protected abstract Template buildTemplate(Class<?> targetClass, T[] entries, Template[] templates);
protected abstract void setSuperClass() throws CannotCompileException, NotFoundException;
protected abstract void buildConstructor() throws CannotCompileException, NotFoundException;
protected void buildMethodInit() { }
protected abstract String buildPackMethodBody();
protected abstract String buildUnpackMethodBody();
protected abstract String buildConvertMethodBody();
protected abstract Template buildInstance(Class<?> c)
throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException;
protected abstract void writeTemplate(Class<?> targetClass, T[] entries,
Template[] templates, String directoryName);
protected abstract Template loadTemplate(Class<?> targetClass, T[] entries, Template[] templates);
public BuildContextBase(JavassistTemplateBuilder director) {
this.director = director;
}
protected Template build(final String className) {
try {
reset(className, false);
buildClass();
buildConstructor();
buildMethodInit();
buildPackMethod();
buildUnpackMethod();
buildConvertMethod();
return buildInstance(createClass());
} catch (Exception e) {
String code = getBuiltString();
if(code != null) {
LOG.error("builder: " + code, e);
throw new TemplateBuildException("Cannot compile: " + code, e);
} else {
throw new TemplateBuildException(e);
}
}
}
protected void reset(String className, boolean isWritten) {
String tmplName = null;
if (!isWritten) {
tmplName = className + "_$$_Template" + director.nextSeqId();
} else {
tmplName = className + "_$$_Template";
}
tmplCtClass = director.makeCtClass(tmplName);
}
protected void buildClass() throws CannotCompileException, NotFoundException {
setSuperClass();
tmplCtClass.addInterface(director.getCtClass(Template.class.getName()));
}
protected void buildPackMethod() throws CannotCompileException, NotFoundException {
String mbody = buildPackMethodBody();
int mod = javassist.Modifier.PUBLIC;
CtClass returnType = CtClass.voidType;
String mname = "pack";
CtClass[] paramTypes = new CtClass[] {
director.getCtClass(Packer.class.getName()),
director.getCtClass(Object.class.getName())
};
CtClass[] exceptTypes = new CtClass[] {
director.getCtClass(IOException.class.getName())
};
CtMethod newCtMethod = CtNewMethod.make(
mod, returnType, mname,
paramTypes, exceptTypes, mbody, tmplCtClass);
tmplCtClass.addMethod(newCtMethod);
}
protected void buildUnpackMethod() throws CannotCompileException, NotFoundException {
String mbody = buildUnpackMethodBody();
int mod = javassist.Modifier.PUBLIC;
CtClass returnType = director.getCtClass(Object.class.getName());
String mname = "unpack";
CtClass[] paramTypes = new CtClass[] {
director.getCtClass(Unpacker.class.getName()),
director.getCtClass(Object.class.getName())
};
CtClass[] exceptTypes = new CtClass[] {
director.getCtClass(MessageTypeException.class.getName())
};
CtMethod newCtMethod = CtNewMethod.make(
mod, returnType, mname,
paramTypes, exceptTypes, mbody, tmplCtClass);
tmplCtClass.addMethod(newCtMethod);
}
protected void buildConvertMethod() throws CannotCompileException, NotFoundException {
String mbody = buildConvertMethodBody();
int mod = javassist.Modifier.PUBLIC;
CtClass returnType = director.getCtClass(Object.class.getName());
String mname = "convert";
CtClass[] paramTypes = new CtClass[] {
director.getCtClass(MessagePackObject.class.getName()),
director.getCtClass(Object.class.getName())
};
CtClass[] exceptTypes = new CtClass[] {
director.getCtClass(MessageTypeException.class.getName())
};
CtMethod newCtMethod = CtNewMethod.make(
mod, returnType, mname,
paramTypes, exceptTypes, mbody, tmplCtClass);
tmplCtClass.addMethod(newCtMethod);
}
protected Class<?> createClass() throws CannotCompileException {
return (Class<?>) tmplCtClass.toClass(null, null);
}
protected void saveClass(final String directoryName) throws CannotCompileException, IOException {
tmplCtClass.writeFile(directoryName);
}
protected StringBuilder stringBuilder = null;
protected void resetStringBuilder() {
stringBuilder = new StringBuilder();
}
protected void buildString(String str) {
stringBuilder.append(str);
}
protected void buildString(String format, Object... args) {
stringBuilder.append(String.format(format, args));
}
protected String getBuiltString() {
if(stringBuilder == null) {
return null;
}
return stringBuilder.toString();
}
protected String primitivePackName(Class<?> type) {
if(type == boolean.class) {
return "packBoolean";
} else if(type == byte.class) {
return "packByte";
} else if(type == short.class) {
return "packShort";
} else if(type == int.class) {
return "packInt";
} else if(type == long.class) {
return "packLong";
} else if(type == float.class) {
return "packFloat";
} else if(type == double.class) {
return "packDouble";
}
return null;
}
protected String primitiveUnpackName(Class<?> type) {
if(type == boolean.class) {
return "unpackBoolean";
} else if(type == byte.class) {
return "unpackByte";
} else if(type == short.class) {
return "unpackShort";
} else if(type == int.class) {
return "unpackInt";
} else if(type == long.class) {
return "unpackLong";
} else if(type == float.class) {
return "unpackFloat";
} else if(type == double.class) {
return "unpackDouble";
}
return null;
}
protected String primitiveConvertName(Class<?> type) {
if(type == boolean.class) {
return "asBoolean";
} else if(type == byte.class) {
return "asByte";
} else if(type == short.class) {
return "asShort";
} else if(type == int.class) {
return "asInt";
} else if(type == long.class) {
return "asLong";
} else if(type == float.class) {
return "asFloat";
} else if(type == double.class) {
return "asDouble";
}
return null;
}
protected void write(final String className, final String directoryName) {
try {
reset(className, true);
buildClass();
buildConstructor();
buildMethodInit();
buildPackMethod();
buildUnpackMethod();
buildConvertMethod();
saveClass(directoryName);
} catch (Exception e) {
String code = getBuiltString();
if(code != null) {
LOG.error("builder: " + code, e);
throw new TemplateBuildException("Cannot compile: " + code, e);
} else {
throw new TemplateBuildException(e);
}
}
}
protected Template load(final String className) {
String tmplName = className + "_$$_Template";
try {
Class<?> tmplClass = getClass().getClassLoader().loadClass(tmplName);
return buildInstance(tmplClass);
} catch (ClassNotFoundException e) {
return null;
} catch (Exception e) {
String code = getBuiltString();
if(code != null) {
LOG.error("builder: " + code, e);
throw new TemplateBuildException("Cannot compile: " + code, e);
} else {
throw new TemplateBuildException(e);
}
}
}
}

Some files were not shown because too many files have changed in this diff Show More