// base256 encoder, i.e. ASCII
//
// derived from B64Encoder.java
//
// R. Perry, December 2015
//

/**
 * Encode bytes into a base256 string, i.e. ASCII.
 * <p>
 * This class is designed using internal buffers so that
 * the caller can encode bytes and byte arrays, then obtain the final
 * encoded result using the <code>flush()</code> method.
 * <p>
 * Example usage (from <code>main()</code>, for testing):
 * <pre>
 *  int i;
 *
 *  B256Encoder b256 = new B256Encoder();
 *
 *  for( i = 0; i < 256; ++i) b256.encode( (byte)i);
 *
 *  System.out.print( b256.flush());
 * </pre>
 *
 * @author  Rick Perry
 * @version 19 December 2015
 */

public class B256Encoder {

 /**
  * The mapping from 8-bit values to encoded characters.
  */
  private static String[] table = // generated by ascii.c
  {
    "\\x00", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05", "\\x06",   "\\a",
      "\\b",   "\\t",   "\\n",   "\\v",   "\\f",   "\\r", "\\x0e", "\\x0f",
    "\\x10", "\\x11", "\\x12", "\\x13", "\\x14", "\\x15", "\\x16", "\\x17",
    "\\x18", "\\x19", "\\x1a", "\\x1b", "\\x1c", "\\x1d", "\\x1e", "\\x1f",
      "\\_",     "!",    "\"",     "#",     "$",     "%",     "&",     "'",
        "(",     ")",     "*",     "+",     ",",     "-",     ".",     "/",
        "0",     "1",     "2",     "3",     "4",     "5",     "6",     "7",
        "8",     "9",     ":",     ";",     "<",     "=",     ">",     "?",
        "@",     "A",     "B",     "C",     "D",     "E",     "F",     "G",
        "H",     "I",     "J",     "K",     "L",     "M",     "N",     "O",
        "P",     "Q",     "R",     "S",     "T",     "U",     "V",     "W",
        "X",     "Y",     "Z",     "[",  "\\\\",     "]",     "^",     "_",
        "`",     "a",     "b",     "c",     "d",     "e",     "f",     "g",
        "h",     "i",     "j",     "k",     "l",     "m",     "n",     "o",
        "p",     "q",     "r",     "s",     "t",     "u",     "v",     "w",
        "x",     "y",     "z",     "{",     "|",     "}",     "~", "\\x7f",
    "\\x80", "\\x81", "\\x82", "\\x83", "\\x84", "\\x85", "\\x86", "\\x87",
    "\\x88", "\\x89", "\\x8a", "\\x8b", "\\x8c", "\\x8d", "\\x8e", "\\x8f",
    "\\x90", "\\x91", "\\x92", "\\x93", "\\x94", "\\x95", "\\x96", "\\x97",
    "\\x98", "\\x99", "\\x9a", "\\x9b", "\\x9c", "\\x9d", "\\x9e", "\\x9f",
    "\\xa0", "\\xa1", "\\xa2", "\\xa3", "\\xa4", "\\xa5", "\\xa6", "\\xa7",
    "\\xa8", "\\xa9", "\\xaa", "\\xab", "\\xac", "\\xad", "\\xae", "\\xaf",
    "\\xb0", "\\xb1", "\\xb2", "\\xb3", "\\xb4", "\\xb5", "\\xb6", "\\xb7",
    "\\xb8", "\\xb9", "\\xba", "\\xbb", "\\xbc", "\\xbd", "\\xbe", "\\xbf",
    "\\xc0", "\\xc1", "\\xc2", "\\xc3", "\\xc4", "\\xc5", "\\xc6", "\\xc7",
    "\\xc8", "\\xc9", "\\xca", "\\xcb", "\\xcc", "\\xcd", "\\xce", "\\xcf",
    "\\xd0", "\\xd1", "\\xd2", "\\xd3", "\\xd4", "\\xd5", "\\xd6", "\\xd7",
    "\\xd8", "\\xd9", "\\xda", "\\xdb", "\\xdc", "\\xdd", "\\xde", "\\xdf",
    "\\xe0", "\\xe1", "\\xe2", "\\xe3", "\\xe4", "\\xe5", "\\xe6", "\\xe7",
    "\\xe8", "\\xe9", "\\xea", "\\xeb", "\\xec", "\\xed", "\\xee", "\\xef",
    "\\xf0", "\\xf1", "\\xf2", "\\xf3", "\\xf4", "\\xf5", "\\xf6", "\\xf7",
    "\\xf8", "\\xf9", "\\xfa", "\\xfb", "\\xfc", "\\xfd", "\\xfe", "\\xff",
  };

 /**
  * Encoded output.
  */
  private StringBuilder out;

 /**
  * Construct a new Encoder.
  */
  public B256Encoder()
  {
    out = new StringBuilder();
  }

 /**
  * Encode one byte.
  *
  * @param b the byte to be encoded.
  */
  public void encode( byte b)
  {
    out.append( table[ b & 0xff]);
  }

 /**
  * Encode a byte array.
  * <p>
  * 
  * @param b the byte array to be encoded.
  */
  public void encode( byte[] b)
  {
    for( int i = 0; i < b.length; ++i)
      encode( b[i]);
  }

 /**
  * Encode a byte array, skipping the first byte if it is zero
  * <p>
  * 
  * @param b the byte array to be encoded.
  */
  public void encode_skip_leading_zero( byte[] b)
  {
    if( b[0] != 0) encode( b[0]);

    for( int i = 1; i < b.length; ++i)
      encode( b[i]);
  }

 /**
  * Encode a byte array, starting at the specified offset.
  * <p>
  * 
  * @param b the byte array to be encoded.
  * @param offset the offset to start from in the array of bytes.
  * @param len the number of bytes to use, starting at offset.
  */
  public void encode( byte[] b, int offset, int len)
  {
    for( int i = 0; i < len; ++i)
      encode( b[i+offset]);
  }

 /**
  * Return encoded output.
  * <p>
  * The encoder internal buffer is reset after this call is made.
  *
  * @return the encoded output string.
  */
  public String flush()
  {
    String s = new String( out);

    out.setLength( 0);

    return s;
  }

 /**
  * Return encoded output.
  * <p>
  * The encoder internal buffer is reset after this call is made.
  *
  * @param b the final byte to be encoded.
  * @return the encoded output string.
  */
  public String flush( byte b)
  {
    encode( b);
    return flush();
  }

 /**
  * Return encoded output.
  * <p>
  * The encoder internal buffer is reset after this call is made.
  *
  * @param b the final byte array to be encoded.
  * @return the encoded output string.
  */
  public String flush( byte[] b)
  {
    encode( b);
    return flush();
  }

 /**
  * Return encoded output.
  * <p>
  * The encoder internal buffer is reset after this call is made.
  *
  * @param b the final byte array to be encoded.
  * @param offset the offset to start from in the array of bytes.
  * @param len the number of bytes to use, starting at offset.
  * @return the encoded output string.
  */
  public String flush( byte[] b, int offset, int len)
  {
    encode( b, offset, len);
    return flush();
  }

 /**
  * Just for testing.
  */
  public static void main( String args[]) throws Exception
  {
    int i;

    B256Encoder b256 = new B256Encoder();

    for( i = 0; i < 256; ++i) b256.encode( (byte)i);

    System.out.print( b256.flush());
  }

}