ln.types/odb/PreparedObject.cs

// /**
//  * File: PreparedObject.cs
//  * Author: haraldwolff
//  *
//  * This file and it's content is copyrighted by the Author and / or copyright holder.
//  * Any use wihtout proper permission is illegal and may lead to legal actions.
//  *
//  *
//  **/
using System;
using System.Collections.Generic;
using System.CodeDom;
using System.Reflection;
using System.IO;
namespace ln.types.odb
{
    public class PreparedObject
    {
        public ODB ODB { get; private set; }

        public DateTime Timestamp { get; private set; }
        public Type PreparedType { get; private set; }

        public IPersistent Instance { get; set; }
        public Guid PersistenceID { get; private set; }

        List<Guid> referencedPersistents = new List<Guid>();
        Dictionary<string, byte[]> fieldStore = new Dictionary<string, byte[]>();

        public PreparedObject(ODB odb,Type preparedType,Guid persistenceID)
        {
            ODB = odb;
            Timestamp = DateTime.Now;
            PreparedType = preparedType;
            PersistenceID = persistenceID;
            Instance = null;
        }
        public PreparedObject(ODB odb, IPersistent o)
        {
            ODB = odb;
            Timestamp = DateTime.Now;
            PreparedType = o.GetType();
            PersistenceID = o.GetPersistenceID();
            Instance = o;

            SyncFromInstance();
        }

        private void SyncFromInstance()
        {
            referencedPersistents.Clear();

            foreach (FieldInfo fieldInfo in PreparedType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                object value = fieldInfo.GetValue(Instance);
                if (value == null)
                {
                    fieldStore[fieldInfo.Name] = new byte[0];
                }
                else
                {
                    MemoryStream objectStream = new MemoryStream();
                    ODBObjectWriter objectWriter = new ODBObjectWriter(objectStream);

                    objectWriter.Write(value);

                    fieldStore[fieldInfo.Name] = objectStream.ToArray();
                    referencedPersistents.AddRange(objectWriter.ReferencedPersistentIDs);
                }
            }
        }
        private void SyncToInstance()
        {
            foreach (FieldInfo fieldInfo in PreparedType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                byte[] bytes = fieldStore[fieldInfo.Name];
                if (bytes.Length == 0)
                {
                    fieldInfo.SetValue(Instance, null);
                } else
                {
                    MemoryStream objectStream = new MemoryStream(fieldStore[fieldInfo.Name]);
                    ODBObjectReader objectReader = new ODBObjectReader(ODB, objectStream);

                    object value = objectReader.Read();
                    fieldInfo.SetValue(Instance, value);
                }
            }
        }



        public byte[] GetFieldBytes(string fieldName)
        {
            return fieldStore[fieldName];
        }
        public void SetFieldBytes(string fieldName,byte[] bytes)
        {
            fieldStore[fieldName] = bytes;
        }

        public IPersistent CreateInstance()
        {
            Instance = (IPersistent)Activator.CreateInstance(PreparedType,true);
            SyncToInstance();
            return Instance;
        }

        public bool InstanceEquals(PreparedObject other)
        {
            if (Equals(other))
            {
                foreach (String fieldName in fieldStore.Keys)
                {
                    if (!Object.Equals(fieldStore[fieldName], other.fieldStore[fieldName]))
                        return false;
                }
                return true;
            }
            return false;
        }

        public override int GetHashCode()
        {
            return PersistenceID.GetHashCode() ^ PreparedType.GetHashCode();
        }

        public override bool Equals(object obj)
        {
            if (obj is PreparedObject)
            {
                PreparedObject you = obj as PreparedObject;
                return PreparedType.Equals(you.PreparedType) && PersistenceID.Equals(you.PersistenceID);
            }
            return false;
        }

    }
}