// CkAsn.h: interface for the CkAsn class.
//
//////////////////////////////////////////////////////////////////////

// This header is generated for Chilkat 11.5.0

#define _CkVersion 11.5.0

#ifndef _CkAsn_H
#define _CkAsn_H
	
#include "chilkatDefs.h"
#include "CkString.h"
#include "CkMultiByteBase.h"

class CkByteData;
class CkBinData;



#if !defined(__sun__) && !defined(__sun)
#pragma pack (push, 8)
#endif


#undef Copy

// CLASS: CkAsn
class CK_VISIBLE_PUBLIC CkAsn  : public CkMultiByteBase
{
    private:

	// Don't allow assignment or copying these objects.
	CkAsn(const CkAsn &);
	CkAsn &operator=(const CkAsn &);

    public:
	CkAsn(void);
	virtual ~CkAsn(void);

	static CkAsn *createNew(void);
	static CkAsn *createNew2(int progLang);
	void CK_VISIBLE_PRIVATE inject(void *impl);

	// May be called when finished with the object to free/dispose of any
	// internal resources held by the object. 
	void dispose(void);

	
		
	

	// BEGIN PUBLIC INTERFACE

	// ----------------------
	// Properties
	// ----------------------
	// The ASN.1 item's boolean value if it is a boolean item.
	bool get_BoolValue(void);
	// The ASN.1 item's boolean value if it is a boolean item.
	void put_BoolValue(bool newVal);

	// true if this ASN.1 item is a constructed item. Sequence and Set items are
	// constructed and can contain sub-items. All other tags (boolean, integer, octets,
	// utf8String, etc.) are primitive (non-constructed).
	bool get_Constructed(void);

	// The ASN.1 item's content if it is an ASN.1 string type (such as Utf8String,
	// BmpString, PrintableString, VisibleString, T61String, IA5String, NumericString,
	// or UniversalString).
	void get_ContentStr(CkString &str);
	// The ASN.1 item's content if it is an ASN.1 string type (such as Utf8String,
	// BmpString, PrintableString, VisibleString, T61String, IA5String, NumericString,
	// or UniversalString).
	const char *contentStr(void);
	// The ASN.1 item's content if it is an ASN.1 string type (such as Utf8String,
	// BmpString, PrintableString, VisibleString, T61String, IA5String, NumericString,
	// or UniversalString).
	void put_ContentStr(const char *newVal);

	// The ASN.1 item's integer value if it is a small integer item.
	int get_IntValue(void);
	// The ASN.1 item's integer value if it is a small integer item.
	void put_IntValue(int newVal);

	// The number of sub-items contained within this ASN.1 item. Only constructed
	// items, such as Sequence and Set will contain sub-iitems. Primitive items such as
	// OIDs, octet strings, integers, etc. will never contain sub-items.
	int get_NumSubItems(void);

	// The ASN.1 item's tag as a descriptive string. Possible values are:boolean
	// integer
	// bitString
	// octets
	// null
	// oid
	// utf8String
	// relativeOid
	// sequence
	// set
	// numericString
	// printableString
	// t61String
	// ia5String
	// utcTime
	// bmpString
	void get_Tag(CkString &str);
	// The ASN.1 item's tag as a descriptive string. Possible values are:boolean
	// integer
	// bitString
	// octets
	// null
	// oid
	// utf8String
	// relativeOid
	// sequence
	// set
	// numericString
	// printableString
	// t61String
	// ia5String
	// utcTime
	// bmpString
	const char *tag(void);

	// The ASN.1 item's tag as a integer value. The integer values for possible tags
	// are as follows:boolean (1)
	// integer (2)
	// bitString (3)
	// octets (4)
	// null (5)
	// oid (6)
	// utf8String (12)
	// relativeOid (13)
	// sequence (16)
	// set (17)
	// numericString (18)
	// printableString (19)
	// t61String (20)
	// ia5String (22)
	// utcTime (23)
	// bmpString (30)
	int get_TagValue(void);



	// ----------------------
	// Methods
	// ----------------------
	// Appends an ASN.1 integer, but one that is a big (huge) integer that is too large
	// to be represented by an integer variable. The bytes composing the integer are
	// passed in encoded string format (such as base64, hex, etc.). The byte order must
	// be big-endian. The encoding may be any of the following encodings: Base64 , Hex ,
	// Base58 , modBase64 , Base32 , UU , QP (for quoted-printable), URL (for
	// url-encoding), Q , B , url_oath , url_rfc1738 , url_rfc2396 , and url_rfc3986 .
	// The encoding name is case insensitive (for example, both Base64 and base64 are
	// treated the same).
	bool AppendBigInt(const char *encodedBytes, const char *encoding);


	// Appends an ASN.1 bit string to the caller's sub-items. The bytes containing the
	// bits are passed in encoded string format (such as base64, hex, etc.). The byte
	// order must be big-endian (MSB first). The encoding may be any of the following
	// encodings: Base64 , Hex , Base58 , modBase64 , Base32 , UU , QP (for
	// quoted-printable), URL (for url-encoding), Q , B , url_oath , url_rfc1738 ,
	// url_rfc2396 , and url_rfc3986 . The encoding name is case insensitive (for example,
	// both Base64 and base64 are treated the same).
	bool AppendBits(const char *encodedBytes, const char *encoding);


	// Appends an ASN.1 boolean item to the caller's sub-items. Items may only be
	// appended to constructed data types such as Sequence and Set.
	bool AppendBool(bool value);


	// Appends an ASN.1 context-specific constructed item to the caller's sub-items.
	bool AppendContextConstructed(int tag);


	// Appends an ASN.1 context-specific primitive item to the caller's sub-items. The
	// bytes are passed in encoded string format (such as base64, hex, etc.). The encoding
	// may be any of the following encodings: Base64 , Hex , Base58 , modBase64 ,
	// Base32 , UU , QP (for quoted-printable), URL (for url-encoding), Q , B ,
	// url_oath , url_rfc1738 , url_rfc2396 , and url_rfc3986 . The encoding name is case
	// insensitive (for example, both Base64 and base64 are treated the same).
	bool AppendContextPrimitive(int tag, const char *encodedBytes, const char *encoding);


	// Appends an ASN.1 integer item to the caller's sub-items. Items may only be
	// appended to constructed data types such as Sequence and Set.
	bool AppendInt(int value);


	// Appends an ASN.1 null item to the caller's sub-items. Items may only be appended
	// to constructed data types such as Sequence and Set.
	bool AppendNull(void);


	// Appends an ASN.1 octet string to the caller's sub-items. The bytes are passed in
	// encoded string format (such as base64, hex, etc.). The encoding may be any of the
	// following encodings: Base64 , Hex , Base58 , modBase64 , Base32 , UU , QP (for
	// quoted-printable), URL (for url-encoding), Q , B , url_oath , url_rfc1738 ,
	// url_rfc2396 , and url_rfc3986 . The encoding name is case insensitive (for example,
	// both Base64 and base64 are treated the same).
	bool AppendOctets(const char *encodedBytes, const char *encoding);


	// Appends an ASN.1 OID (object identifier) to the caller's sub-items. The OID is
	// passed in string form, such as 1.2.840.113549.1.9.1 .
	bool AppendOid(const char *oid);


	// Appends an ASN.1 sequence item to the caller's sub-items.
	bool AppendSequence(void);


	// Appends an ASN.1 sequence item to the caller's sub-items, and updates the
	// internal reference to point to the newly appended sequence item.
	bool AppendSequence2(void);


	// Appends an ASN.1 sequence item to the caller's sub-items, and returns the newly
	// appended sequence item.
	// The caller is responsible for deleting the object returned by this method.
	CkAsn *AppendSequenceR(void);


	// Appends an ASN.1 set item to the caller's sub-items.
	bool AppendSet(void);


	// Appends an ASN.1 set item to the caller's sub-items, and updates the internal
	// reference to point to the newly appended set item.
	bool AppendSet2(void);


	// Appends an ASN.1 set item to the caller's sub-items, and returns the newly
	// appended set item.
	// The caller is responsible for deleting the object returned by this method.
	CkAsn *AppendSetR(void);


	// Appends a string item to the caller's sub-items. The strType specifies the type of
	// string to be added. It may be utf8 , ia5 , t61 , printable , visible , numeric ,
	// universal , or bmp . The value must conform to the ASN.1 restrictions imposed for
	// a given string type. The utf8 , bmp , and universal types have no restrictions
	// on what characters are allowed. In general, unless a specific type of string is
	// required, choose the utf8 type.
	bool AppendString(const char *strType, const char *value);


	// Appends a UTCTime item to the caller's sub-items. The timeFormat specifies the format
	// of the dateTimeStr. It should be set to utc . (In the future, this method will be
	// expanded to append GeneralizedTime items by using generalized for timeFormat.) To
	// append the current date/time, set dateTimeStr equal to the empty string or the keyword
	// now . Otherwise, the dateTimeStr should be in the UTC time format YYMMDDhhmm[ss]Z or
	// YYMMDDhhmm[ss](+|-)hhmm .
	bool AppendTime(const char *timeFormat, const char *dateTimeStr);


	// Converts ASN.1 to XML and returns the XML string.
	bool AsnToXml(CkString &outStr);

	// Converts ASN.1 to XML and returns the XML string.
	const char *asnToXml(void);

	// Discards the Nth sub-item. (The 1st sub-item is at index 0.)
	bool DeleteSubItem(int index);


	// Returns the ASN.1 in binary DER form.
	bool GetBinaryDer(CkByteData &outBytes);


	// Returns the content of the ASN.1 item in encoded string form. The encoding may be
	// any of the following encodings: Base64 , Hex , Base58 , modBase64 , Base32 , UU
	// , QP (for quoted-printable), URL (for url-encoding), Q , B , url_oath ,
	// url_rfc1738 , url_rfc2396 , and url_rfc3986 . The encoding name is case insensitive
	// (for example, both Base64 and base64 are treated the same).
	bool GetEncodedContent(const char *encoding, CkString &outStr);

	// Returns the content of the ASN.1 item in encoded string form. The encoding may be
	// any of the following encodings: Base64 , Hex , Base58 , modBase64 , Base32 , UU
	// , QP (for quoted-printable), URL (for url-encoding), Q , B , url_oath ,
	// url_rfc1738 , url_rfc2396 , and url_rfc3986 . The encoding name is case insensitive
	// (for example, both Base64 and base64 are treated the same).
	const char *getEncodedContent(const char *encoding);
	// Returns the content of the ASN.1 item in encoded string form. The encoding may be
	// any of the following encodings: Base64 , Hex , Base58 , modBase64 , Base32 , UU
	// , QP (for quoted-printable), URL (for url-encoding), Q , B , url_oath ,
	// url_rfc1738 , url_rfc2396 , and url_rfc3986 . The encoding name is case insensitive
	// (for example, both Base64 and base64 are treated the same).
	const char *encodedContent(const char *encoding);


	// Returns the binary DER in encoded string form. The encoding indicates the encoding
	// and can be base64 , hex , uu , quoted-printable , base32 , or modbase64 .
	bool GetEncodedDer(const char *encoding, CkString &outStr);

	// Returns the binary DER in encoded string form. The encoding indicates the encoding
	// and can be base64 , hex , uu , quoted-printable , base32 , or modbase64 .
	const char *getEncodedDer(const char *encoding);
	// Returns the binary DER in encoded string form. The encoding indicates the encoding
	// and can be base64 , hex , uu , quoted-printable , base32 , or modbase64 .
	const char *encodedDer(const char *encoding);


	// Returns the last ASN.1 sub-item. This method can be called immediately after any
	// Append* method to access the appended item.
	// The caller is responsible for deleting the object returned by this method.
	CkAsn *GetLastSubItem(void);


	// Returns the Nth ASN.1 sub-item. The 1st sub-item is at index 0.
	// The caller is responsible for deleting the object returned by this method.
	CkAsn *GetSubItem(int index);


	// Loads ASN.1 from the XML representation (such as that created by the AsnToXml
	// method).
	bool LoadAsnXml(const char *xmlStr);


	// Loads ASN.1 from the binary DER contained in bd.
	bool LoadBd(CkBinData &bd);


	// Loads ASN.1 from binary DER.
	bool LoadBinary(CkByteData &derBytes);


	// Loads ASN.1 from a binary DER file.
	bool LoadBinaryFile(const char *path);


	// Loads ASN.1 from an encoded string. The encoding can be base64 , hex , uu ,
	// quoted-printable , base32 , or modbase64 .
	bool LoadEncoded(const char *asnContent, const char *encoding);


	// Sets the content of this primitive ASN.1 item. The encoding may be any of the
	// following encodings: Base64 , Hex , Base58 , modBase64 , Base32 , UU , QP (for
	// quoted-printable), URL (for url-encoding), Q , B , url_oath , url_rfc1738 ,
	// url_rfc2396 , and url_rfc3986 . The encoding name is case insensitive (for example,
	// both Base64 and base64 are treated the same).
	bool SetEncodedContent(const char *encodedBytes, const char *encoding);


	// Appends the ASN.1 in binary DER format to bd.
	bool WriteBd(CkBinData &bd);


	// Writes the ASN.1 in binary DER form to a file.
	bool WriteBinaryDer(const char *path);






	// END PUBLIC INTERFACE


};
#if !defined(__sun__) && !defined(__sun)
#pragma pack (pop)
#endif
	
#endif
