Fire/Container/Partial/ContainerList_GetObject.cs

using System.Linq;
using System.IO;
using System.Fire.Serialize;
using System.Fire.Serialize.Property;

namespace System.Fire.Container {

    public partial class ContainerList {

        /// <summary>
        /// Returns an deserialized object that was stored in a container
        /// </summary>
        /// <typeparam name="T">The object type</typeparam>
        /// <param name="FileIndex">File</param>
        /// <returns>Returns the object</returns>
        public T GetObject<T>(int FileIndex) {
            return this.GetObject<T>(this._files[FileIndex]);
        }

        /// <summary>
        /// Returns an deserialized object that was stored in a container
        /// </summary>
        /// <typeparam name="T">The object type</typeparam>
        /// <param name="File">File</param>
        /// <returns>Returns the object</returns>
        public T GetObject<T>(ContainerFile File) {
            Stream s = this.GetStream(File);
            return Serializer.DeserializeObject<T>(s);
        }

        /// <summary>
        /// Returns an deserialized object that was stored in a container
        /// </summary>
        /// <typeparam name="T">The object type</typeparam>
        /// <param name="FileIndex">File</param>
        /// <param name="size">The array size</param>
        /// <returns>Returns the object</returns>
        public T GetObject<T>(int FileIndex, ArraySize size) {
            return this.GetObject<T>(this._files[FileIndex], size);
        }

        /// <summary>
        /// Returns an deserialized object that was stored in a container
        /// </summary>
        /// <typeparam name="T">The object type</typeparam>
        /// <param name="File">File</param>
        /// <param name="size">The array size</param>
        /// <returns>Returns the object</returns>
        public T GetObject<T>(ContainerFile File, ArraySize size) {
            Stream s = this.GetStream(File);
            return Serializer.DeserializeObject<T>(s,size);
        }


        public T GetObject<T>(int FileIndex, StringEncoding encode) {
            return this.GetObject<T>(this._files[FileIndex], encode);
        }

        public T GetObject<T>(ContainerFile File, StringEncoding encode) {
            Stream s = this.GetStream(File);
            return Serializer.DeserializeObject<T>(s, encode);
        }

        public T GetObject<T>(int FileIndex, ArraySize size, StringEncoding encode) {
            return this.GetObject<T>(this._files[FileIndex], size, encode);
        }

        public T GetObject<T>(ContainerFile File, ArraySize size, StringEncoding encode) {
            Stream s = this.GetStream(File);
            return Serializer.DeserializeObject<T>(s, size, encode);
        }

        public int WriteObject(object obj) {
            int stackId = this.CreateStack();
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, ArraySize size) {
            int stackId = this.CreateStack();
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj, size);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, StringEncoding encode) {
            int stackId = this.CreateStack();
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj, encode);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, ArraySize size, StringEncoding encode) {
            int stackId = this.CreateStack();
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj, size, encode);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, string FileName) {
            int stackId = this.CreateStack(FileName);
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, string FileName, ArraySize size) {
            int stackId = this.CreateStack(FileName);
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj, size);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, string FileName, StringEncoding encode) {
            int stackId = this.CreateStack(FileName);
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj, encode);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

        public int WriteObject(object obj, string FileName, ArraySize size, StringEncoding encode) {
            int stackId = this.CreateStack(FileName);
            MemoryStream mem = new MemoryStream();
            Serializer.SerializeObject(mem, obj, size, encode);
            this.Write(stackId, mem.ToArray());
            return this.CloseStack(stackId);
        }

    }
}