public ContentHints(
			DerObjectIdentifier	contentType,
			DerUtf8String		contentDescription)
		{
			this.contentType = contentType;
			this.contentDescription = contentDescription;
		}

		public CertBag(
            DerObjectIdentifier	certID,
            Asn1Object			certValue)
        {
            this.certID = certID;
            this.certValue = certValue;
        }

		public override void PerformTest()
		{
			DerUtf8String contentDescription = new DerUtf8String("Description");
			DerObjectIdentifier contentType = new DerObjectIdentifier("1.2.2.3");

			ContentHints hints = new ContentHints(contentType);

			checkConstruction(hints, contentType, null);

			hints = new ContentHints(contentType, contentDescription);

			checkConstruction(hints, contentType, contentDescription);

			hints = ContentHints.GetInstance(null);

			if (hints != null)
			{
				Fail("null GetInstance() failed.");
			}

			try
			{
				ContentHints.GetInstance(new Object());

				Fail("GetInstance() failed to detect bad object.");
			}
			catch (ArgumentException)
			{
				// expected
			}
		}

		public EncryptedContentInfoParser(
			Asn1SequenceParser seq)
		{
			_contentType = (DerObjectIdentifier)seq.ReadObject();
			_contentEncryptionAlgorithm = AlgorithmIdentifier.GetInstance(seq.ReadObject().ToAsn1Object());
			_encryptedContent = (Asn1TaggedObjectParser)seq.ReadObject();
		}

		public Attribute(
            DerObjectIdentifier attrType,
            Asn1Set             attrValues)
        {
            this.attrType = attrType;
            this.attrValues = attrValues;
        }

		public KeySpecificInfo(
            DerObjectIdentifier	algorithm,
            Asn1OctetString		counter)
        {
            this.algorithm = algorithm;
            this.counter = counter;
        }

 public AttributeTypeAndValue(
     DerObjectIdentifier type,
     Asn1Encodable value)
 {
     this.type = type;
     this.value = value;
 }

 public QCStatement(
     DerObjectIdentifier qcStatementId,
     Asn1Encodable       qcStatementInfo)
 {
     this.qcStatementId = qcStatementId;
     this.qcStatementInfo = qcStatementInfo;
 }

 public OtherRecipientInfo(
     DerObjectIdentifier	oriType,
     Asn1Encodable		oriValue)
 {
     this.oriType = oriType;
     this.oriValue = oriValue;
 }

        /**
         * Apply default conversion for the given value depending on the oid
         * and the character range of the value.
         *
         * @param oid the object identifier for the DN entry
         * @param value the value associated with it
         * @return the ASN.1 equivalent for the string value.
         */
        public override Asn1Object GetConvertedValue(
            DerObjectIdentifier	oid,
            string				value)
        {
            if (value.Length != 0 && value[0] == '#')
            {
                try
                {
                    return ConvertHexEncoded(value, 1);
                }
                catch (IOException)
                {
                    throw new Exception("can't recode value for oid " + oid.Id);
                }
            }

            if (oid.Equals(X509Name.EmailAddress) || oid.Equals(X509Name.DC))
            {
                return new DerIA5String(value);
            }

            if (oid.Equals(X509Name.DateOfBirth)) // accept time string as well as # (for compatibility)
            {
                return new DerGeneralizedTime(value);
            }

            if (oid.Equals(X509Name.C)
                || oid.Equals(X509Name.SerialNumber)
                || oid.Equals(X509Name.DnQualifier))
            {
                return new DerPrintableString(value);
            }

            return new DerUtf8String(value);
        }

		public SigPolicyQualifierInfo(
			DerObjectIdentifier	sigPolicyQualifierId,
			Asn1Encodable		sigQualifier)
		{
			this.sigPolicyQualifierId = sigPolicyQualifierId;
			this.sigQualifier = sigQualifier.ToAsn1Object();
		}

 public ContentInfo(
     DerObjectIdentifier	contentType,
     Asn1Encodable		content)
 {
     this.contentType = contentType;
     this.content = content;
 }

 public AlgorithmIdentifier(
     DerObjectIdentifier algorithm,
     Asn1Encodable		parameters)
 {
     this.algorithm = algorithm;
     this.parameters = parameters;
 }

		public OtherKeyAttribute(
            DerObjectIdentifier	keyAttrId,
            Asn1Encodable		keyAttr)
        {
            this.keyAttrId = keyAttrId;
            this.keyAttr = keyAttr;
        }

        /**
        * return the X9ECParameters object for the named curve represented by
        * the passed in object identifier. Null if the curve isn't present.
        *
        * @param oid an object identifier representing a named curve, if present.
        */
        public static X9ECParameters GetByOid(
			DerObjectIdentifier oid)
        {
            X9ECParametersHolder holder = (X9ECParametersHolder) curves[oid];

            return holder == null ? null : holder.Parameters;
        }

        /**
         * Creates a new <code>PolicyQualifierInfo</code> instance.
         *
         * @param policyQualifierId a <code>PolicyQualifierId</code> value
         * @param qualifier the qualifier, defined by the above field.
         */
        public PolicyQualifierInfo(
			DerObjectIdentifier	policyQualifierId,
			Asn1Encodable		qualifier)
        {
            this.policyQualifierId = policyQualifierId;
            this.qualifier = qualifier;
        }

		public AlgorithmIdentifier(
            DerObjectIdentifier	objectID,
            Asn1Encodable		parameters)
        {
            this.objectID = objectID;
            this.parameters = parameters;
        }

 public OtherRevocationInfoFormat(
     DerObjectIdentifier otherRevInfoFormat,
     Asn1Encodable otherRevInfo)
 {
     this.otherRevInfoFormat = otherRevInfoFormat;
     this.otherRevInfo = otherRevInfo;
 }

		public SemanticsInformation(
            DerObjectIdentifier semanticsIdentifier,
            GeneralName[] generalNames)
        {
            this.semanticsIdentifier = semanticsIdentifier;
            this.nameRegistrationAuthorities = generalNames;
        }

 public PolicyInformation(
     DerObjectIdentifier	policyIdentifier,
     Asn1Sequence		policyQualifiers)
 {
     this.policyIdentifier = policyIdentifier;
     this.policyQualifiers = policyQualifiers;
 }