Mercurial > hg > Database > Alice

comparison src/main/java/alice/datasegment/ReceiveData.java @ 523:145c425db88d dispose

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add CompressedLDSM
author Nozomi Teruya <e125769@ie.u-ryukyu.ac.jp>
date Thu, 09 Apr 2015 18:36:26 +0900
parents 7ef0ebb40c9b
children 30a74eee59c7
comparison
equal deleted inserted replaced
522:b8fe79f0c764 523:145c425db88d
1 package alice.datasegment; 1 package alice.datasegment;
2 2
3 import java.io.ByteArrayOutputStream; 3 import java.io.ByteArrayOutputStream;
4 import java.io.IOException; 4 import java.io.IOException;
5 import java.util.zip.DataFormatException; 5 import java.nio.ByteBuffer;
6 import java.util.zip.Inflater; 6 import java.util.zip.*;
7 import java.util.zip.InflaterOutputStream;
8 7
8 import org.apache.log4j.Logger;
9 import org.msgpack.type.Value; 9 import org.msgpack.type.Value;
10
11 import alice.codesegment.SingletonMessage; 10 import alice.codesegment.SingletonMessage;
12 11
12 /**
13 * 送られてきたDSを一時的に取っておくクラス。inputでも使用。
14 */
13 public class ReceiveData { 15 public class ReceiveData {
14 private Object val; 16 private Object val;//Object型のDS
17 private byte[] messagePack;//byteArray(serialized)のDS
18 private byte[] zMessagePack;//byteArray(compressed)のDS
19 private Class<?> clazz;
20 private Logger logger = Logger.getLogger("MessagePack");
15 21
16 // both flag have to be true or false except DataSegment is byteArray; 22 public long time;//測定用
17 private boolean compressed = false;
18 private boolean serialized = false;
19 private boolean byteArray = false;
20
21 public long time;
22 public boolean setTime = false; 23 public boolean setTime = false;
23 public int depth = 1; 24 public int depth = 1;
24 25
25 public ReceiveData(Object obj, boolean cFlag, boolean sFlag){ 26 /**
27 * コンストラクタ。Object型のDSと圧縮のメタ情報を受け取る。
28 * put/update用？
29 * @param obj　DS本体(Object)
30 */
31 public ReceiveData(Object obj, boolean cFlag, boolean sFlag) {
26 val = obj; 32 val = obj;
27 compressed = cFlag; 33 if (cFlag){
28 serialized = sFlag; 34 messagePack = (byte[])val;
29 } 35 ByteBuffer buf = null;
30 36
31 public ReceiveData(byte[] obj, boolean cFlag, boolean sFlag){ 37 try {
32 val = obj; 38 zMessagePack = zip(messagePack);
33 byteArray = true; 39 buf = ByteBuffer.allocate(zMessagePack.length + 1);
34 compressed = cFlag; 40 buf.put((byte) 0xc1);
35 serialized = sFlag; 41 buf.put(zMessagePack);
36 } 42 zMessagePack = buf.array();
37 43 } catch (IOException e) {
38 public boolean isByteArray(){ 44 e.printStackTrace();
39 return byteArray; 45 }
40 }
41
42 public boolean compressed(){
43 return compressed;
44 }
45
46 public boolean serialized(){
47 return serialized;
48 }
49
50 public Object getObj(){
51 return val;
52 }
53
54 public String asString(){
55 if (serialized){
56 return asClass(String.class);
57 } else {
58 return (String) val;
59 } 46 }
60 } 47 }
61 48
62 public int asInteger(){ 49 /**
63 if (serialized){ 50 * コンストラクタ。byteArray型のDSと圧縮のメタ情報を受け取り、byteArrayフラグを立てる。
64 return asClass(Integer.class); 51 *
52 * @param messagePack DS本体（byteArray）
53 */
54 public ReceiveData(byte[] messagePack) {
55
56 if (messagePack[0] == 0xc1){
57 this.zMessagePack = messagePack;
65 } else { 58 } else {
66 return (Integer) val; 59 this.messagePack = messagePack;
67 } 60 }
61
62 logger.debug(this.messagePack);
63 logger.debug(this.zMessagePack);
68 } 64 }
69 65
70 public Float asFloat(){ 66
71 if (serialized){ 67 public boolean isByteArray(){//byteArrayフラグの状態を取得するメソッド
72 return asClass(Float.class); 68 return messagePack != null;
73 } else {
74 return (Float) val;
75 }
76 } 69 }
77 70
78 public Value getVal(){ 71 public boolean compressed(){//compressedフラグの状態を取得するメソッド
79 if (serialized){ 72 return zMessagePack != null;
73 }
74
75 public boolean serialized(){//serializedフラグの状態を取得するメソッド
76 return val != null;
77 }
78
79 public Object getObj(){//Object型のDS本体を取得するメソッド。
80 return asClass(Object.class);
81 }
82
83 public String asString(){//String型としてDSを取得するメソッド。DSがシリアライズされていればStringクラスを返す。
84 return asClass(String.class);
85 }
86
87 public int asInteger(){//Int型としてDSを取得するメソッド。DSがシリアライズされていればIntクラスを返す。
88 return asClass(Integer.class);
89 }
90
91 public Float asFloat(){//Float型としてDSを取得するメソッド。DSがシリアライズされていればFloatクラスを返す。
92 return asClass(Float.class);
93 }
94
95 public Value getVal(){//Value型としてDSを取得するメソッド
96 if (val == null){//もとはval != null
80 return asClass(Value.class); 97 return asClass(Value.class);
81 } else { 98 } else {
82 try { 99 try {
83 return SingletonMessage.getInstance().unconvert(val); 100 return SingletonMessage.getInstance().unconvert(val);//MassagePackでvalue型に変換。できなければnullを返す。
84 } catch (IOException e) { 101 } catch (IOException e) {
85 e.printStackTrace(); 102 e.printStackTrace();
86 } 103 }
87 return null; 104 return null;
88 } 105 }
89 } 106 }
90 107
91 @SuppressWarnings("unchecked") 108 /**
92 public <T> T asClass(Class<T> clazz) { 109 * DSを任意の型で取得するメソッド。
110 * DSがbyteArrayでなければ指定された型に変換して返す。
111 * DSがbyteArrayなら解凍状態にして指定された型に変換して返す。
112 *
113 * @param clazz
114 * @param <T>
115 * @return
116 */
117 public <T> T asClass(Class<T> clazz) {//javasist
93 try { 118 try {
94 if (!byteArray) { 119 if (val != null) {
95 return (T) val; 120 return (T) val;
96 } 121 }
97 byte[] b = null; 122 byte[] b = messagePack;
98 if (compressed) { 123
99 b = unzip((byte[]) val); 124 if (zMessagePack != null && messagePack == null) {
100 } else { 125 logger.debug("zMessagePack = " + zMessagePack);
101 b = (byte[]) val; 126 messagePack = unzip(zMessagePack);
127 b = messagePack;
102 } 128 }
103 129
104 if (serialized) { 130 logger.debug("MessagePack = " + messagePack);
131
132 if (val == null) {
133 this.clazz = clazz;
105 return SingletonMessage.getInstance().read(b, clazz); 134 return SingletonMessage.getInstance().read(b, clazz);
106 } else { 135 } else {
107 return (T) b; 136 return (T) val;
108 } 137 }
109 } catch (IOException | DataFormatException e) { 138 } catch (Exception e) {
110 e.printStackTrace(); 139 e.printStackTrace();
111 return null; 140 return null;
112 } 141 }
113 } 142 }
114 143
144 /**
145 * java.util.zip.Inflater(zlib)を使ってbyteArray型のDSを解凍する。
146 *
147 * @param input 圧縮されたbyteArray型のDS
148 * @return 解凍したbyteArray型DS
149 * @throws IOException
150 * @throws DataFormatException
151 */
115 public byte[] unzip(byte[] input) throws IOException, DataFormatException{ 152 public byte[] unzip(byte[] input) throws IOException, DataFormatException{
116 Inflater inflater = new Inflater(); 153 Inflater inflater = new Inflater();
117 ByteArrayOutputStream os = new ByteArrayOutputStream(); 154 ByteArrayOutputStream os = new ByteArrayOutputStream();
118 InflaterOutputStream ios = new InflaterOutputStream(os, inflater); 155 InflaterOutputStream ios = new InflaterOutputStream(os, inflater);
119 ios.write(input); 156 ios.write(input);
120 ios.finish(); 157 ios.finish();
121 return os.toByteArray(); 158 return os.toByteArray();
122 } 159 }
123 160
161 /**
162 * java.util.zip.Deflater(zlib)を使ってbyteArray型のDSを圧縮する。
163 *
164 * @param input 非圧縮状態のbyteArray型のDS
165 * @return 圧縮したbyteArray型DS
166 * @throws IOException
167 */
168 public byte[] zip(byte[] input) throws IOException{
169 Deflater deflater = new Deflater();
170 ByteArrayOutputStream os = new ByteArrayOutputStream();
171 DeflaterOutputStream dos = new DeflaterOutputStream(os, deflater);
172 dos.write(input);
173 dos.finish();
174 return os.toByteArray();
175 }
176
124 } 177 }