示例#1
0
        public static void Serialize <TDoc, TCursor>(TagElementStream <TDoc, TCursor, string> s,
                                                     ref Values.GroupTagData32 value)
            where TDoc : class
            where TCursor : class
        {
            bool reading = s.IsReading;

            var group_tag = reading
                                ? null
                                : value.TagString;
            var name = reading
                                ? null
                                : value.Name;
            var guid = reading
                                ? Values.KGuid.Empty
                                : value.Uuid;

            s.StreamAttribute("tag", ref group_tag);
            s.StreamAttributeOpt("guid", ref guid, Predicates.IsNotEmpty);
            s.StreamAttribute("name", ref name);

            if (reading)
            {
                value = new Values.GroupTagData32(group_tag, name, guid);
            }
        }
示例#2
0
        public static void Serialize <TDoc, TCursor>(TagElementStream <TDoc, TCursor, string> s,
                                                     ref Values.GroupTag32Collection collection, string groupsElementName = "Groups")
            where TDoc : class
            where TCursor : class
        {
            Contract.Requires(!string.IsNullOrEmpty(groupsElementName));

            bool reading = s.IsReading;

            var guid = reading
                                ? Values.KGuid.Empty
                                : collection.Uuid;
            var tags = reading
                                ? null
                       // HACK: GroupTags is exposed as a IReadOnlyList, but at the time of this writing is implemented
                       // with a GroupTagData32[] as its backing field
                                : (Values.GroupTagData32[])collection.GroupTags;

            s.StreamAttributeOpt("guid", ref guid, Predicates.IsNotEmpty);

            using (var bm = s.EnterCursorBookmarkOpt(groupsElementName, tags, Predicates.HasItems)) if (bm.IsNotNull)
                {
                    StreamElements(s, ref tags);
                }

            if (reading)
            {
                bool sort = false;
                s.ReadAttributeOpt("sort", ref sort);

                collection = new Values.GroupTag32Collection(guid, sort, tags);
            }
        }
示例#3
0
        /// <summary>Saves the stream's cursor and sets <paramref name="newCursor"/> to be the new cursor for the stream</summary>
        /// <param name="stream">The underlying stream for this bookmark</param>
        /// <param name="newCursor">The new cursor for the stream</param>
        public TagElementStreamReadBookmark(TagElementStream <TDoc, TCursor, TName> stream, TCursor newCursor)
        {
            Contract.Requires <ArgumentNullException>(stream != null);
            Contract.Requires <ArgumentNullException>(newCursor != null);

            (mStream = stream).SaveCursor(newCursor, out mOldCursor);
        }
示例#4
0
 TagElementStreamBookmark(
     [SuppressMessage("Microsoft.Design", "CA1801:ReviewUnusedParameters")]
     bool dummy)
 {
     mStream    = null;
     mOldCursor = null;
 }
示例#5
0
 /// <summary>Returns the cursor of the underlying stream to the last saved cursor value</summary>
 public void Dispose()
 {
     if (mStream != null)
     {
         mStream.WriteElementEnd(ref mOldCursor);
         mStream = null;
     }
 }
示例#6
0
 /// <summary>Returns the cursor of the underlying stream to the last saved cursor value</summary>
 public void Dispose()
 {
     if (mStream != null)
     {
         mStream.RestoreCursor(ref mOldCursor);
         mStream = null;
     }
 }
示例#7
0
        /// <summary>Saves the stream's cursor so a new one can be specified, but then later restored to the saved cursor, via <see cref="Dispose()"/></summary>
        /// <param name="stream">The underlying stream for this bookmark</param>
        /// <param name="elementName"></param>
        public TagElementStreamWriteBookmark(TagElementStream <TDoc, TCursor, TName> stream, TName elementName)
        {
            Contract.Requires <ArgumentNullException>(stream != null);
            Contract.Requires <ArgumentNullException>(elementName != null);

            mStream    = null;
            mOldCursor = null;
            (mStream = stream).WriteElementBegin(elementName, out mOldCursor);
        }
示例#8
0
        public static void Serialize <TDoc, TCursor, TContext>(BitSet @this,
                                                               TagElementStream <TDoc, TCursor, string> s,
                                                               string elementName,
                                                               TContext ctxt, SerializeBitToTagElementStreamDelegate <TDoc, TCursor, TContext> streamElement,
                                                               int highestBitIndex = TypeExtensions.kNoneInt32)
            where TDoc : class
            where TCursor : class
        {
            Contract.Requires(s != null);
            Contract.Requires(streamElement != null);
            Contract.Requires(highestBitIndex.IsNoneOrPositive());
            Contract.Requires(highestBitIndex < @this.Length);

            if (highestBitIndex.IsNone())
            {
                highestBitIndex = @this.Length - 1;
            }

            if (s.IsReading)
            {
                int bit_index = 0;
                foreach (var node in s.ElementsByName(elementName))
                {
                    using (s.EnterCursorBookmark(node))
                    {
                        bit_index = streamElement(s, @this, TypeExtensions.kNoneInt32, ctxt);
                        if (bit_index.IsNone())
                        {
                            s.ThrowReadException(new System.IO.InvalidDataException(string.Format(Util.InvariantCultureInfo,
                                                                                                  "Element is not a valid {0} value", elementName)));
                        }

                        @this[bit_index] = true;
                    }
                }
            }
            else if (s.IsWriting)
            {
                foreach (int bit_index in @this.SetBitIndices)
                {
                    if (bit_index > highestBitIndex)
                    {
                        break;
                    }

                    using (s.EnterCursorBookmark(elementName))
                        streamElement(s, @this, bit_index, ctxt);
                }
            }
        }
示例#9
0
        public static void Serialize <TDoc, TCursor, TContext>(this Collections.BitSet @this,
                                                               IO.TagElementStream <TDoc, TCursor, string> s,
                                                               string elementName,
                                                               TContext ctxt,
                                                               IO.TagElementStreamDefaultSerializer.SerializeBitToTagElementStreamDelegate <TDoc, TCursor, TContext> streamElement,
                                                               int highestBitIndex = TypeExtensions.kNoneInt32)
            where TDoc : class
            where TCursor : class
        {
            Contract.Requires(s != null);
            Contract.Requires(streamElement != null);
            Contract.Requires(highestBitIndex.IsNoneOrPositive());
            Contract.Requires(highestBitIndex < @this.Length);

            IO.TagElementStreamDefaultSerializer.Serialize(@this, s, elementName,
                                                           ctxt, streamElement,
                                                           highestBitIndex);
        }
示例#10
0
        static void StreamElements <TDoc, TCursor>(TagElementStream <TDoc, TCursor, string> s,
                                                   ref Values.GroupTagData32[] tags)
            where TDoc : class
            where TCursor : class
        {
            const string k_element_name = "Group";

            if (s.IsReading)
            {
                var list = new List <Values.GroupTagData32>();

                foreach (var node in s.ElementsByName(k_element_name))
                {
                    using (s.EnterCursorBookmark(node))
                    {
                        Values.GroupTagData32 data = null;
                        Serialize(s, ref data);

                        list.Add(data);
                    }
                }

                tags = list.ToArray();
            }
            else if (s.IsWriting)
            {
                foreach (Values.GroupTagData32 data in tags)
                {
                    using (s.EnterCursorBookmark(k_element_name))
                    {
                        var temp = data;                         // can't pass a foreach value by ref
                        Serialize(s, ref temp);
                    }
                }
            }
        }
 public void Serialize <TDoc, TCursor>(TagElementStream <TDoc, TCursor, TName> s)
     where TDoc : class
     where TCursor : class
 {
     Contract.Requires(s != null);
 }