Beispiel #1
0
 protected void WriteEntity(CacheWriter f, UxlEntityFlags flags)
 {
     if (flags.HasFlag(UxlEntityFlags.Elements))
     {
         f.WriteList(Elements, (w, x) => x.Write(w));
     }
     if (flags.HasFlag(UxlEntityFlags.CopyFiles))
     {
         f.WriteList(CopyFiles, (w, x) => w.Write(x));
     }
     if (flags.HasFlag(UxlEntityFlags.ImageFiles))
     {
         f.WriteList(ImageFiles, (w, x) => w.Write(x));
     }
 }
Beispiel #2
0
        public void Write(CacheWriter f)
        {
            var flags = (UxlMethodFlags)EntityFlags;

            if (Condition != null)
            {
                flags |= UxlMethodFlags.HasCondition;
            }
            if (IsDefault)
            {
                flags |= UxlMethodFlags.IsDefault;
            }
            if (Implementations.Count > 0)
            {
                flags |= UxlMethodFlags.Implementations;
            }

            f.Write((byte)flags);
            f.WriteGlobal(Signature);

            if (flags.HasFlag(UxlMethodFlags.HasCondition))
            {
                f.WriteGlobal(Condition.Value);
            }
            if (flags.HasFlag(UxlMethodFlags.Implementations))
            {
                f.WriteList(Implementations, (w, x) => x.Write(w));
            }

            WriteEntity(f, (UxlEntityFlags)flags);
        }
Beispiel #3
0
        public void Write(CacheWriter f)
        {
            var flags = (UxlTypeFlags)EntityFlags;

            if (Condition.HasValue)
            {
                flags |= UxlTypeFlags.HasCondition;
            }
            if (IsDefault)
            {
                flags |= UxlTypeFlags.IsDefault;
            }
            if (Methods.Count > 0)
            {
                flags |= UxlTypeFlags.Methods;
            }

            f.Write((byte)flags);
            f.WriteGlobal(Name);

            if (flags.HasFlag(UxlTypeFlags.HasCondition))
            {
                f.WriteGlobal(Condition.Value);
            }
            if (flags.HasFlag(UxlTypeFlags.Methods))
            {
                f.WriteList(Methods, (w, x) => x.Write(w));
            }

            WriteEntity(f, (UxlEntityFlags)flags);
        }
Beispiel #4
0
        public void Write(CacheWriter f)
        {
            UxlDocumentFlags flags = 0;

            if (Condition != null)
            {
                flags |= UxlDocumentFlags.HasCondition;
            }
            if (Defines.Count > 0)
            {
                flags |= UxlDocumentFlags.Defines;
            }
            if (Usings.Count > 0)
            {
                flags |= UxlDocumentFlags.Usings;
            }
            if (Declarations.Count > 0)
            {
                flags |= UxlDocumentFlags.Declarations;
            }
            if (Deprecations.Count > 0)
            {
                flags |= UxlDocumentFlags.Deprecations;
            }
            if (Templates.Count > 0)
            {
                flags |= UxlDocumentFlags.Templates;
            }
            if (Types.Count > 0)
            {
                flags |= UxlDocumentFlags.Types;
            }

            f.Write((byte)Backend);
            f.Write((byte)flags);
            if (flags.HasFlag(UxlDocumentFlags.HasCondition))
            {
                f.WriteGlobal(Condition.Value);
            }
            if (flags.HasFlag(UxlDocumentFlags.Defines))
            {
                f.WriteList(Defines, (w, x) => x.Write(w));
            }
            if (flags.HasFlag(UxlDocumentFlags.Usings))
            {
                f.WriteList(Usings, (w, x) => w.WriteGlobal(x));
            }
            if (flags.HasFlag(UxlDocumentFlags.Declarations))
            {
                f.WriteList(Declarations, (w, x) => x.Write(w));
            }
            if (flags.HasFlag(UxlDocumentFlags.Deprecations))
            {
                f.WriteList(Deprecations, (w, x) => x.Write(w));
            }
            if (flags.HasFlag(UxlDocumentFlags.Templates))
            {
                f.WriteList(Templates, (w, x) => x.Write(w));
            }
            if (flags.HasFlag(UxlDocumentFlags.Types))
            {
                f.WriteList(Types, (w, x) => x.Write(w));
            }

            var entityFlags = EntityFlags;

            f.Write((byte)entityFlags);
            WriteEntity(f, entityFlags);
        }