content: package local.org.bouncycastle.asn1;
  
  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  
  import local.org.bouncycastle.util.Arrays;
  import local.org.bouncycastle.util.encoders.Hex;
  
  
  public abstract class ASN1OctetString
      extends ASN1Primitive
      implements ASN1OctetStringParser
  {
      byte[]  string;
  
      /**
       * return an Octet String from a tagged object.
       *
       * @param obj the tagged object holding the object we want.
       * @param explicit true if the object is meant to be explicitly
       *              tagged false otherwise.
       * @exception IllegalArgumentException if the tagged object cannot
       *              be converted.
       */
      public static ASN1OctetString getInstance(
          ASN1TaggedObject    obj,
          boolean             explicit)
      {
          ASN1Primitive o = obj.getObject();
  
          if (explicit || o instanceof ASN1OctetString)
          {
              return getInstance(o);
          }
          else
          {
              return BEROctetString.fromSequence(ASN1Sequence.getInstance(o));
          }
      }
      
      /**
       * return an Octet String from the given object.
       *
       * @param obj the object we want converted.
       * @exception IllegalArgumentException if the object cannot be converted.
       */
      public static ASN1OctetString getInstance(
          Object  obj)
      {
          if (obj == null || obj instanceof ASN1OctetString)
          {
              return (ASN1OctetString)obj;
          }
          else if (obj instanceof byte[])
          {
              try
              {
                  return ASN1OctetString.getInstance(ASN1Primitive.fromByteArray((byte[])obj));
              }
              catch (IOException e)
              {
                  throw new IllegalArgumentException("failed to construct OCTET STRING from byte[]: " + e.getMessage());
              }
          }
          else if (obj instanceof ASN1Encodable)
          {
              ASN1Primitive primitive = ((ASN1Encodable)obj).toASN1Primitive();
  
              if (primitive instanceof ASN1OctetString)
              {
                  return (ASN1OctetString)primitive;
              }
          }
  
          throw new IllegalArgumentException("illegal object in getInstance: " + obj.getClass().getName());
      }
  
      /**
       * @param string the octets making up the octet string.
       */
      public ASN1OctetString(
          byte[]  string)
      {
          if (string == null)
          {
              throw new NullPointerException("string cannot be null");
          }
          this.string = string;
      }
  
      public InputStream getOctetStream()
      {
          return new ByteArrayInputStream(string);
      }
  
      public ASN1OctetStringParser parser()
      {
          return this;
      }
  
      public byte[] getOctets()
      {
          return string;
      }
  
      public int hashCode()
      {
          return Arrays.hashCode(this.getOctets());
      }
  
      boolean asn1Equals(
          ASN1Primitive o)
      {
          if (!(o instanceof ASN1OctetString))
          {
              return false;
          }
  
          ASN1OctetString  other = (ASN1OctetString)o;
  
          return Arrays.areEqual(string, other.string);
      }
  
      public ASN1Primitive getLoadedObject()
      {
          return this.toASN1Primitive();
      }
  
      ASN1Primitive toDERObject()
      {
          return new DEROctetString(string);
      }
  
      ASN1Primitive toDLObject()
      {
          return new DEROctetString(string);
      }
  
      abstract void encode(ASN1OutputStream out)
          throws IOException;
  
      public String toString()
      {
        return "#"+new String(Hex.encode(string));
      }
  }
  