001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.util;
019
020import java.io.ByteArrayInputStream;
021import java.io.ByteArrayOutputStream;
022import java.io.DataInputStream;
023import java.io.DataOutputStream;
024import java.io.IOException;
025import java.util.ArrayList;
026import java.util.List;
027import org.apache.hadoop.io.DataInputBuffer;
028import org.apache.hadoop.io.Writable;
029import org.apache.yetus.audience.InterfaceAudience;
030
031/**
032 * Utility class with methods for manipulating Writable objects
033 */
034@InterfaceAudience.Private
035public class Writables {
036  /**
037   * Get the Writable's contents as a byte array
038   * @param w writable
039   * @return The bytes of <code>w</code> gotten by running its
040   *         {@link Writable#write(java.io.DataOutput)} method.
041   * @throws IOException e
042   * @see #getWritable(byte[], Writable)
043   */
044  public static byte[] getBytes(final Writable w) throws IOException {
045    if (w == null) {
046      throw new IllegalArgumentException("Writable cannot be null");
047    }
048    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
049    DataOutputStream out = new DataOutputStream(byteStream);
050    try {
051      w.write(out);
052      out.close();
053      out = null;
054      return byteStream.toByteArray();
055    } finally {
056      if (out != null) {
057        out.close();
058      }
059    }
060  }
061
062  /**
063   * Put a bunch of Writables as bytes all into the one byte array.
064   * @param ws writable
065   * @return The bytes of <code>w</code> gotten by running its
066   *         {@link Writable#write(java.io.DataOutput)} method.
067   * @throws IOException e
068   */
069  public static byte[] getBytes(final Writable... ws) throws IOException {
070    List<byte[]> bytes = new ArrayList<>(ws.length);
071    int size = 0;
072    for (Writable w : ws) {
073      byte[] b = getBytes(w);
074      size += b.length;
075      bytes.add(b);
076    }
077    byte[] result = new byte[size];
078    int offset = 0;
079    for (byte[] b : bytes) {
080      System.arraycopy(b, 0, result, offset, b.length);
081      offset += b.length;
082    }
083    return result;
084  }
085
086  /**
087   * Set bytes into the passed Writable by calling its
088   * {@link Writable#readFields(java.io.DataInput)}.
089   * @param bytes serialized bytes
090   * @param w     An empty Writable (usually made by calling the null-arg constructor).
091   * @return The passed Writable after its readFields has been called fed by the passed
092   *         <code>bytes</code> array or IllegalArgumentException if passed null or an empty
093   *         <code>bytes</code> array.
094   * @throws IOException e n
095   */
096  public static Writable getWritable(final byte[] bytes, final Writable w) throws IOException {
097    return getWritable(bytes, 0, bytes.length, w);
098  }
099
100  /**
101   * Set bytes into the passed Writable by calling its
102   * {@link Writable#readFields(java.io.DataInput)}.
103   * @param bytes  serialized bytes
104   * @param offset offset into array
105   * @param length length of data
106   * @param w      An empty Writable (usually made by calling the null-arg constructor).
107   * @return The passed Writable after its readFields has been called fed by the passed
108   *         <code>bytes</code> array or IllegalArgumentException if passed null or an empty
109   *         <code>bytes</code> array.
110   * @throws IOException e n
111   */
112  public static Writable getWritable(final byte[] bytes, final int offset, final int length,
113    final Writable w) throws IOException {
114    if (bytes == null || length <= 0) {
115      throw new IllegalArgumentException("Can't build a writable with empty " + "bytes array");
116    }
117    if (w == null) {
118      throw new IllegalArgumentException("Writable cannot be null");
119    }
120    DataInputBuffer in = new DataInputBuffer();
121    try {
122      in.reset(bytes, offset, length);
123      w.readFields(in);
124      return w;
125    } finally {
126      in.close();
127    }
128  }
129
130  /**
131   * Copy one Writable to another. Copies bytes using data streams.
132   * @param src Source Writable
133   * @param tgt Target Writable
134   * @return The target Writable.
135   * @throws IOException e
136   */
137  public static Writable copyWritable(final Writable src, final Writable tgt) throws IOException {
138    return copyWritable(getBytes(src), tgt);
139  }
140
141  /**
142   * Copy one Writable to another. Copies bytes using data streams.
143   * @param bytes Source Writable
144   * @param tgt   Target Writable
145   * @return The target Writable.
146   * @throws IOException e
147   */
148  public static Writable copyWritable(final byte[] bytes, final Writable tgt) throws IOException {
149    DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes));
150    try {
151      tgt.readFields(dis);
152    } finally {
153      dis.close();
154    }
155    return tgt;
156  }
157}