상속: IEnumerable
        /**
         * create a sequence containing a vector of objects.
         */
        public DerSequence(
			Asn1EncodableVector v)
            : base(v.Count)
        {
            foreach (Asn1Encodable ae in v)
            {
                AddObject(ae);
            }
        }
        public static Asn1EncodableVector FromEnumerable(
			IEnumerable e)
        {
            Asn1EncodableVector v = new Asn1EncodableVector();
            foreach (Asn1Encodable obj in e)
            {
                v.Add(obj);
            }
            return v;
        }
        internal DerSet(
			Asn1EncodableVector	v,
			bool				needsSorting)
            : base(v.Count)
        {
            foreach (Asn1Encodable o in v)
            {
                AddObject(o);
            }

            if (needsSorting)
            {
                Sort();
            }
        }
        public DerExternal(
			Asn1EncodableVector vector)
        {
            int offset = 0;
            Asn1Object enc = GetObjFromVector(vector, offset);
            if (enc is DerObjectIdentifier)
            {
                directReference = (DerObjectIdentifier)enc;
                offset++;
                enc = GetObjFromVector(vector, offset);
            }
            if (enc is DerInteger)
            {
                indirectReference = (DerInteger) enc;
                offset++;
                enc = GetObjFromVector(vector, offset);
            }
            if (!(enc is DerTaggedObject))
            {
                dataValueDescriptor = (Asn1Object) enc;
                offset++;
                enc = GetObjFromVector(vector, offset);
            }
            if (!(enc is DerTaggedObject))
            {
                throw new InvalidOperationException(
                    "No tagged object found in vector. Structure doesn't seem to be of type External");
            }

            if (vector.Count != offset + 1)
                throw new ArgumentException("input vector too large", "vector");

            if (!(enc is DerTaggedObject))
                throw new ArgumentException("No tagged object found in vector. Structure doesn't seem to be of type External", "vector");

            DerTaggedObject obj = (DerTaggedObject)enc;

            // Use property accessor to include check on value
            Encoding = obj.TagNo;

            if (encoding < 0 || encoding > 2)
                throw new InvalidOperationException("invalid encoding value");

            externalContent = obj.GetObject();
        }
        public DerApplicationSpecific(
			int					tagNo,
			Asn1EncodableVector	vec)
        {
            this.tag = tagNo;
            this.isConstructed = true;
            MemoryStream bOut = new MemoryStream();

            for (int i = 0; i != vec.Count; i++)
            {
                try
                {
                    byte[] bs = vec[i].GetEncoded();
                    bOut.Write(bs, 0, bs.Length);
                }
                catch (IOException e)
                {
                    throw new InvalidOperationException("malformed object", e);
                }
            }
            this.octets = bOut.ToArray();
        }
        internal static DerSet FromVector(
			Asn1EncodableVector	v,
			bool				needsSorting)
        {
            return v.Count < 1 ? Empty : new DerSet(v, needsSorting);
        }
        public static DerSet FromVector(
			Asn1EncodableVector v)
        {
            return v.Count < 1 ? Empty : new DerSet(v);
        }
        /**
         * @param v - a vector of objects making up the set.
         */
        public DerSet(
			Asn1EncodableVector v)
            : this(v, true)
        {
        }
예제 #9
0
 public static DerSequence FromVector(
     Asn1EncodableVector v)
 {
     return(v.Count < 1 ? Empty : new DerSequence(v));
 }
예제 #10
0
 /**
  * @param v - a vector of objects making up the set.
  */
 public DerSet(
     Asn1EncodableVector v)
     : this(v, true)
 {
 }
예제 #11
0
 internal static DerSet FromVector(
     Asn1EncodableVector v,
     bool needsSorting)
 {
     return(v.Count < 1 ? Empty : new DerSet(v, needsSorting));
 }
        private static Asn1Object GetObjFromVector(Asn1EncodableVector v, int index)
        {
            if (v.Count <= index)
                throw new ArgumentException("too few objects in input vector", "v");

            return v[index].ToAsn1Object();
        }
        /**
         * Return an ASN1 set from a tagged object. There is a special
         * case here, if an object appears to have been explicitly tagged on
         * reading but we were expecting it to be implicitly tagged in the
         * normal course of events it indicates that we lost the surrounding
         * set - so we need to add it back (this will happen if the tagged
         * object is a sequence that contains other sequences). If you are
         * dealing with implicitly tagged sets you really <b>should</b>
         * be using this method.
         *
         * @param obj the tagged object.
         * @param explicitly true if the object is meant to be explicitly tagged
         *          false otherwise.
         * @exception ArgumentException if the tagged object cannot
         *          be converted.
         */
        public static Asn1Set GetInstance(
            Asn1TaggedObject	obj,
            bool				explicitly)
        {
            Asn1Object inner = obj.GetObject();

            if (explicitly)
            {
                if (!obj.IsExplicit())
                    throw new ArgumentException("object implicit - explicit expected.");

                return (Asn1Set) inner;
            }

            //
            // constructed object which appears to be explicitly tagged
            // and it's really implicit means we have to add the
            // surrounding sequence.
            //
            if (obj.IsExplicit())
            {
                return new DerSet(inner);
            }

            if (inner is Asn1Set)
            {
                return (Asn1Set) inner;
            }

            //
            // in this case the parser returns a sequence, convert it
            // into a set.
            //
            if (inner is Asn1Sequence)
            {
                Asn1EncodableVector v = new Asn1EncodableVector();
                Asn1Sequence s = (Asn1Sequence) inner;

                foreach (Asn1Encodable ae in s)
                {
                    v.Add(ae);
                }

                // TODO Should be able to construct set directly from sequence?
                return new DerSet(v, false);
            }

            throw new ArgumentException("Unknown object in GetInstance: " + obj.GetType().FullName, "obj");
        }
        internal Asn1EncodableVector BuildEncodableVector()
        {
            Asn1EncodableVector v = new Asn1EncodableVector();

            Asn1Object o;
            while ((o = ReadObject()) != null)
            {
                v.Add(o);
            }

            return v;
        }
        internal Asn1EncodableVector ReadVector()
        {
            Asn1EncodableVector v = new Asn1EncodableVector();

            IAsn1Convertible obj;
            while ((obj = ReadObject()) != null)
            {
                v.Add(obj.ToAsn1Object());
            }

            return v;
        }