
// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-

#ifndef __gnu_java_security_x509_X509CertPath__
#define __gnu_java_security_x509_X509CertPath__

#pragma interface

#include <java/security/cert/CertPath.h>
#include <gcj/array.h>

extern "Java"
{
  namespace gnu
  {
    namespace java
    {
      namespace security
      {
          class OID;
        namespace x509
        {
            class X509CertPath;
        }
      }
    }
  }
}

class gnu::java::security::x509::X509CertPath : public ::java::security::cert::CertPath
{

public:
  X509CertPath(::java::util::List *);
  X509CertPath(::java::io::InputStream *);
  X509CertPath(::java::io::InputStream *, ::java::lang::String *);
  virtual ::java::util::List * getCertificates();
  virtual JArray< jbyte > * getEncoded();
  virtual JArray< jbyte > * getEncoded(::java::lang::String *);
  virtual ::java::util::Iterator * getEncodings();
private:
  void parse(::java::io::InputStream *, ::java::lang::String *);
  JArray< jbyte > * encodePki();
  JArray< jbyte > * encodePKCS();
public:
  static ::java::util::List * ENCODINGS;
private:
  static ::gnu::java::security::OID * PKCS7_SIGNED_DATA;
  static ::gnu::java::security::OID * PKCS7_DATA;
  ::java::util::List * __attribute__((aligned(__alignof__( ::java::security::cert::CertPath)))) path;
  JArray< jbyte > * pkcs_encoded;
  JArray< jbyte > * pki_encoded;
public:
  static ::java::lang::Class class$;
};

#endif // __gnu_java_security_x509_X509CertPath__
