View Javadoc

1   /**
2    * Copyright 2010 The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  package org.apache.hadoop.hbase.util;
21  
22  import org.apache.hadoop.hbase.HRegionInfo;
23  import org.apache.hadoop.io.DataInputBuffer;
24  import org.apache.hadoop.io.Writable;
25  
26  import java.io.ByteArrayInputStream;
27  import java.io.ByteArrayOutputStream;
28  import java.io.DataInputStream;
29  import java.io.DataOutputStream;
30  import java.io.IOException;
31  
32  /**
33   * Utility class with methods for manipulating Writable objects
34   */
35  public class Writables {
36    /**
37     * @param w writable
38     * @return The bytes of <code>w</code> gotten by running its
39     * {@link Writable#write(java.io.DataOutput)} method.
40     * @throws IOException e
41     * @see #getWritable(byte[], Writable)
42     */
43    public static byte [] getBytes(final Writable w) throws IOException {
44      if (w == null) {
45        throw new IllegalArgumentException("Writable cannot be null");
46      }
47      ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
48      DataOutputStream out = new DataOutputStream(byteStream);
49      try {
50        w.write(out);
51        out.close();
52        out = null;
53        return byteStream.toByteArray();
54      } finally {
55        if (out != null) {
56          out.close();
57        }
58      }
59    }
60  
61    /**
62     * Set bytes into the passed Writable by calling its
63     * {@link Writable#readFields(java.io.DataInput)}.
64     * @param bytes serialized bytes
65     * @param w An empty Writable (usually made by calling the null-arg
66     * constructor).
67     * @return The passed Writable after its readFields has been called fed
68     * by the passed <code>bytes</code> array or IllegalArgumentException
69     * if passed null or an empty <code>bytes</code> array.
70     * @throws IOException e
71     * @throws IllegalArgumentException
72     */
73    public static Writable getWritable(final byte [] bytes, final Writable w)
74    throws IOException {
75      return getWritable(bytes, 0, bytes.length, w);
76    }
77  
78    /**
79     * Set bytes into the passed Writable by calling its
80     * {@link Writable#readFields(java.io.DataInput)}.
81     * @param bytes serialized bytes
82     * @param offset offset into array
83     * @param length length of data
84     * @param w An empty Writable (usually made by calling the null-arg
85     * constructor).
86     * @return The passed Writable after its readFields has been called fed
87     * by the passed <code>bytes</code> array or IllegalArgumentException
88     * if passed null or an empty <code>bytes</code> array.
89     * @throws IOException e
90     * @throws IllegalArgumentException
91     */
92    public static Writable getWritable(final byte [] bytes, final int offset,
93      final int length, final Writable w)
94    throws IOException {
95      if (bytes == null || length <=0) {
96        throw new IllegalArgumentException("Can't build a writable with empty " +
97          "bytes array");
98      }
99      if (w == null) {
100       throw new IllegalArgumentException("Writable cannot be null");
101     }
102     DataInputBuffer in = new DataInputBuffer();
103     try {
104       in.reset(bytes, offset, length);
105       w.readFields(in);
106       return w;
107     } finally {
108       in.close();
109     }
110   }
111 
112   /**
113    * @param bytes serialized bytes
114    * @return A HRegionInfo instance built out of passed <code>bytes</code>.
115    * @throws IOException e
116    */
117   public static HRegionInfo getHRegionInfo(final byte [] bytes)
118   throws IOException {
119     return (HRegionInfo)getWritable(bytes, new HRegionInfo());
120   }
121 
122   /**
123    * @param bytes serialized bytes
124    * @return A HRegionInfo instance built out of passed <code>bytes</code>
125    * or <code>null</code> if passed bytes are null or an empty array.
126    * @throws IOException e
127    */
128   public static HRegionInfo getHRegionInfoOrNull(final byte [] bytes)
129   throws IOException {
130     return (bytes == null || bytes.length <= 0)?
131         null : getHRegionInfo(bytes);
132   }
133 
134   /**
135    * Copy one Writable to another.  Copies bytes using data streams.
136    * @param src Source Writable
137    * @param tgt Target Writable
138    * @return The target Writable.
139    * @throws IOException e
140    */
141   public static Writable copyWritable(final Writable src, final Writable tgt)
142   throws IOException {
143     return copyWritable(getBytes(src), tgt);
144   }
145 
146   /**
147    * Copy one Writable to another.  Copies bytes using data streams.
148    * @param bytes Source Writable
149    * @param tgt Target Writable
150    * @return The target Writable.
151    * @throws IOException e
152    */
153   public static Writable copyWritable(final byte [] bytes, final Writable tgt)
154   throws IOException {
155     DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes));
156     try {
157       tgt.readFields(dis);
158     } finally {
159       dis.close();
160     }
161     return tgt;
162   }
163 }