WriteTag() private method

private WriteTag ( int flags, int tagNo ) : void
flags int
tagNo int
return void
        internal override void Encode(
            DerOutputStream derOut)
        {
            if (derOut is Asn1OutputStream || derOut is BerOutputStream)
            {
                derOut.WriteTag((byte)(Asn1Tags.Constructed | Asn1Tags.Tagged), tagNo);
                derOut.WriteByte(0x80);

                if (!IsEmpty())
                {
                    if (!explicitly)
                    {
                        IEnumerable eObj;
                        if (obj is Asn1OctetString)
                        {
                            if (obj is BerOctetString)
                            {
                                eObj = (BerOctetString)obj;
                            }
                            else
                            {
                                Asn1OctetString octs = (Asn1OctetString)obj;
                                eObj = new BerOctetString(octs.GetOctets());
                            }
                        }
                        else if (obj is Asn1Sequence)
                        {
                            eObj = (Asn1Sequence)obj;
                        }
                        else if (obj is Asn1Set)
                        {
                            eObj = (Asn1Set)obj;
                        }
                        else
                        {
                            throw Platform.CreateNotImplementedException(obj.GetType().Name);
                        }

                        foreach (Asn1Encodable o in eObj)
                        {
                            derOut.WriteObject(o);
                        }
                    }
                    else
                    {
                        derOut.WriteObject(obj);
                    }
                }

                derOut.WriteByte(0x00);
                derOut.WriteByte(0x00);
            }
            else
            {
                base.Encode(derOut);
            }
        }
		internal override void Encode(
			DerOutputStream derOut)
		{
			if (derOut is Asn1OutputStream || derOut is BerOutputStream)
			{
				derOut.WriteTag((byte)(Asn1Tags.Constructed | Asn1Tags.Tagged), tagNo);
				derOut.WriteByte(0x80);

				if (!IsEmpty())
				{
					if (!explicitly)
					{
						IEnumerable eObj;
						if (obj is Asn1OctetString)
						{
							if (obj is BerOctetString)
							{
								eObj = (BerOctetString) obj;
							}
							else
							{
								Asn1OctetString octs = (Asn1OctetString)obj;
								eObj = new BerOctetString(octs.GetOctets());
							}
						}
						else if (obj is Asn1Sequence)
						{
							eObj = (Asn1Sequence) obj;
						}
						else if (obj is Asn1Set)
						{
							eObj = (Asn1Set) obj;
						}
						else
						{
							throw Platform.CreateNotImplementedException(obj.GetType().Name);
						}

						foreach (Asn1Encodable o in eObj)
						{
							derOut.WriteObject(o);
						}
					}
					else
					{
						derOut.WriteObject(obj);
					}
				}

				derOut.WriteByte(0x00);
				derOut.WriteByte(0x00);
			}
			else
			{
				base.Encode(derOut);
			}
		}
        internal override void Encode(DerOutputStream derOut)
        {
            if (derOut is Asn1OutputStream || derOut is BerOutputStream)
            {
                derOut.WriteTag(160, this.tagNo);
                derOut.WriteByte(128);
                if (!base.IsEmpty())
                {
                    if (!this.explicitly)
                    {
                        IEnumerable enumerable;
                        if (this.obj is Asn1OctetString)
                        {
                            if (this.obj is BerOctetString)
                            {
                                enumerable = (BerOctetString)this.obj;
                            }
                            else
                            {
                                Asn1OctetString asn1OctetString = (Asn1OctetString)this.obj;
                                enumerable = new BerOctetString(asn1OctetString.GetOctets());
                            }
                        }
                        else if (this.obj is Asn1Sequence)
                        {
                            enumerable = (Asn1Sequence)this.obj;
                        }
                        else
                        {
                            if (!(this.obj is Asn1Set))
                            {
                                throw Platform.CreateNotImplementedException(this.obj.GetType().Name);
                            }
                            enumerable = (Asn1Set)this.obj;
                        }
                        using (IEnumerator enumerator = enumerable.GetEnumerator())
                        {
                            while (enumerator.MoveNext())
                            {
                                Asn1Encodable obj = (Asn1Encodable)enumerator.Current;
                                derOut.WriteObject(obj);
                            }
                            goto IL_119;
                        }
                    }
                    derOut.WriteObject(this.obj);
                }
IL_119:
                derOut.WriteByte(0);
                derOut.WriteByte(0);
                return;
            }
            base.Encode(derOut);
        }
Example #4
0
 internal override void Encode(DerOutputStream derOut)
 {
     if (derOut is Asn1OutputStream || derOut is BerOutputStream)
     {
         derOut.WriteTag(160, tagNo);
         derOut.WriteByte(128);
         if (!IsEmpty())
         {
             if (!explicitly)
             {
                 IEnumerable enumerable;
                 if (base.obj is Asn1OctetString)
                 {
                     if (base.obj is BerOctetString)
                     {
                         enumerable = (BerOctetString)base.obj;
                     }
                     else
                     {
                         Asn1OctetString asn1OctetString = (Asn1OctetString)base.obj;
                         enumerable = new BerOctetString(asn1OctetString.GetOctets());
                     }
                 }
                 else if (base.obj is Asn1Sequence)
                 {
                     enumerable = (Asn1Sequence)base.obj;
                 }
                 else
                 {
                     if (!(base.obj is Asn1Set))
                     {
                         throw Platform.CreateNotImplementedException(base.obj.GetType().Name);
                     }
                     enumerable = (Asn1Set)base.obj;
                 }
                 foreach (Asn1Encodable item in enumerable)
                 {
                     derOut.WriteObject(item);
                 }
             }
             else
             {
                 derOut.WriteObject(obj);
             }
         }
         derOut.WriteByte(0);
         derOut.WriteByte(0);
     }
     else
     {
         base.Encode(derOut);
     }
 }
Example #5
0
        internal override void Encode(DerOutputStream derOut)
        {
            if (base.IsEmpty())
            {
                derOut.WriteEncoded(160, this.tagNo, new byte[0]);
                return;
            }
            byte[] derEncoded = this.obj.GetDerEncoded();
            if (this.explicitly)
            {
                derOut.WriteEncoded(160, this.tagNo, derEncoded);
                return;
            }
            int flags = (int)((derEncoded[0] & 32) | 128);

            derOut.WriteTag(flags, this.tagNo);
            derOut.Write(derEncoded, 1, derEncoded.Length - 1);
        }
Example #6
0
 internal override void Encode(DerOutputStream derOut)
 {
     if (!IsEmpty())
     {
         byte[] derEncoded = obj.GetDerEncoded();
         if (explicitly)
         {
             derOut.WriteEncoded(160, tagNo, derEncoded);
             return;
         }
         int flags = (derEncoded[0] & 0x20) | 0x80;
         derOut.WriteTag(flags, tagNo);
         ((Stream)derOut).Write(derEncoded, 1, derEncoded.Length - 1);
     }
     else
     {
         derOut.WriteEncoded(160, tagNo, new byte[0]);
     }
 }
 internal override void Encode(DerOutputStream derOut)
 {
     if (!base.IsEmpty())
     {
         byte[] derEncoded = base.obj.GetDerEncoded();
         if (base.explicitly)
         {
             derOut.WriteEncoded(160, base.tagNo, derEncoded);
         }
         else
         {
             int flags = (derEncoded[0] & 0x20) | 0x80;
             derOut.WriteTag(flags, base.tagNo);
             derOut.Write(derEncoded, 1, derEncoded.Length - 1);
         }
     }
     else
     {
         derOut.WriteEncoded(160, base.tagNo, new byte[0]);
     }
 }
 internal override void Encode(DerOutputStream derOut)
 {
     if ((derOut is Asn1OutputStream) || (derOut is BerOutputStream))
     {
         derOut.WriteTag(160, base.tagNo);
         derOut.WriteByte(0x80);
         if (!base.IsEmpty())
         {
             if (!base.explicitly)
             {
                 IEnumerable enumerable;
                 if (base.obj is Asn1OctetString)
                 {
                     if (base.obj is BerOctetString)
                     {
                         enumerable = (BerOctetString)base.obj;
                     }
                     else
                     {
                         Asn1OctetString str = (Asn1OctetString)base.obj;
                         enumerable = new BerOctetString(str.GetOctets());
                     }
                 }
                 else if (base.obj is Asn1Sequence)
                 {
                     enumerable = (Asn1Sequence)base.obj;
                 }
                 else
                 {
                     if (!(base.obj is Asn1Set))
                     {
                         throw Platform.CreateNotImplementedException(Platform.GetTypeName(base.obj));
                     }
                     enumerable = (Asn1Set)base.obj;
                 }
                 IEnumerator enumerator = enumerable.GetEnumerator();
                 try
                 {
                     while (enumerator.MoveNext())
                     {
                         Asn1Encodable current = (Asn1Encodable)enumerator.Current;
                         derOut.WriteObject(current);
                     }
                 }
                 finally
                 {
                     if (enumerator is IDisposable disposable)
                     {
                         IDisposable disposable;
                         disposable.Dispose();
                     }
                 }
             }
             else
             {
                 derOut.WriteObject(base.obj);
             }
         }
         derOut.WriteByte(0);
         derOut.WriteByte(0);
     }
     else
     {
         base.Encode(derOut);
     }
 }
 internal override void Encode(DerOutputStream derOut)
 {
     if (derOut is Asn1OutputStream || derOut is BerOutputStream)
     {
         derOut.WriteTag(160, tagNo);
         ((Stream)derOut).WriteByte((byte)128);
         if (!IsEmpty())
         {
             if (!explicitly)
             {
                 global::System.Collections.IEnumerable enumerable;
                 if (obj is Asn1OctetString)
                 {
                     if (obj is BerOctetString)
                     {
                         enumerable = (BerOctetString)obj;
                     }
                     else
                     {
                         Asn1OctetString asn1OctetString = (Asn1OctetString)obj;
                         enumerable = new BerOctetString(asn1OctetString.GetOctets());
                     }
                 }
                 else if (obj is Asn1Sequence)
                 {
                     enumerable = (Asn1Sequence)obj;
                 }
                 else
                 {
                     if (!(obj is Asn1Set))
                     {
                         throw Platform.CreateNotImplementedException(Platform.GetTypeName(obj));
                     }
                     enumerable = (Asn1Set)obj;
                 }
                 {
                     global::System.Collections.IEnumerator enumerator = enumerable.GetEnumerator();
                     try
                     {
                         while (enumerator.MoveNext())
                         {
                             Asn1Encodable asn1Encodable = (Asn1Encodable)enumerator.get_Current();
                             derOut.WriteObject(asn1Encodable);
                         }
                     }
                     finally
                     {
                         global::System.IDisposable disposable = enumerator as global::System.IDisposable;
                         if (disposable != null)
                         {
                             disposable.Dispose();
                         }
                     }
                 }
             }
             else
             {
                 derOut.WriteObject(obj);
             }
         }
         ((Stream)derOut).WriteByte((byte)0);
         ((Stream)derOut).WriteByte((byte)0);
     }
     else
     {
         base.Encode(derOut);
     }
 }