JD2022-TU1/main/tools/legacy/ITFInstaller/VirtualFat.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;


namespace ITFInstaller
{
    [Serializable()]
    public class ElementFat : ISerializable
    {
        public string   m_Filename  = "";
        public DateTime m_Time      = DateTime.MinValue;
        public UInt32   m_Version   = 0;
        public UInt32   m_Size      = 0;

        public ElementFat()
        {

        }

        public ElementFat(SerializationInfo info, StreamingContext ctxt)
        {
            this.m_Filename = (string)info.GetValue("filename", typeof(string));
            this.m_Time     = (DateTime)info.GetValue("datetime", typeof(DateTime));
            this.m_Version  = (UInt32)info.GetValue("version", typeof(UInt32));
            this.m_Size     = (UInt32)info.GetValue("size", typeof(UInt32));
        }

        public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            info.AddValue("filename", this.m_Filename);
            info.AddValue("datetime", this.m_Time);
            info.AddValue("version", this.m_Version);
            info.AddValue("size", this.m_Size);
        }
    }


    [Serializable()]
    public class ObjectToSerialize : ISerializable
    {
        UInt32 version;
        private List<ElementFat> elementsFat;

        public List<ElementFat> ElementsFat
        {
            get { return this.elementsFat; }
            set { this.elementsFat = value; }
        }

        public ObjectToSerialize()
        {
        }

        public ObjectToSerialize(SerializationInfo info, StreamingContext ctxt)
        {
            this.version = (UInt32)info.GetValue("version", typeof(UInt32));
            this.elementsFat = (List<ElementFat>)info.GetValue("ElementFats", typeof(List<ElementFat>));
        }

        public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
        {
            info.AddValue("version", version);
            info.AddValue("ElementFats", this.elementsFat);
        }
    }

    public class VirtualFat
    {
        
        public VirtualFat()
        {

        }

        public void RemoveFile(string _filename)
        {
            m_FatTable.Remove(_filename);
        }

        public List<String> Clean(Hashtable _table)
        {
            List<String> fileToClean = new List<String>();
            foreach (DictionaryEntry entry in m_FatTable)
            {
                if (!_table.ContainsKey(entry.Key))
                {
                    //delete
                    fileToClean.Add(entry.Key.ToString());
                }
            }

            return fileToClean;
        }

        public void DeSerialize(string _filename)
        {
            List<ElementFat> elementsFat = new List<ElementFat>();
            ObjectToSerialize objectToSerialize = new ObjectToSerialize();

            Serializer serializer = new Serializer();
            objectToSerialize = serializer.DeSerializeObject(_filename);
            elementsFat = objectToSerialize.ElementsFat;

            m_FatTable.Clear();
            foreach (ElementFat elementFat in elementsFat)
            {
                m_FatTable[elementFat.m_Filename] = elementFat;
            }

        }


        public void Serialize(string _filename)
        {
            
            List<ElementFat> elementsFat = new List<ElementFat>();

            foreach (DictionaryEntry entry in m_FatTable)
            {
                elementsFat.Add((ElementFat)entry.Value);    
            }

            ObjectToSerialize objectToSerialize = new ObjectToSerialize();
            objectToSerialize.ElementsFat = elementsFat;
             
            Serializer serializer = new Serializer();

            
            serializer.SerializeObject(_filename, objectToSerialize);
        }

        public bool isFileMatch(string _filename,DateTime _srcTime,UInt32 _version,UInt32 _size)
        {
            ElementFat elFat = (ElementFat)m_FatTable[_filename];
            if (elFat == null)
                return false;

            if (_version != elFat.m_Version)
                return false;


            if (_size != elFat.m_Size)
                return false;

            TimeSpan ts = (elFat.m_Time - _srcTime);
            double totalSeconds = Math.Abs(ts.TotalSeconds);
            bool bSkipFile = (totalSeconds >= 0 && totalSeconds <= 2);
            return bSkipFile;
           
        }
        

        public bool isFileExists(string _filename)
        {
            if (m_FatTable.ContainsKey(_filename))
                return true;

            return false;
        }
        
        public void addFile(string _filename,UInt32 _version, DateTime _time,UInt32 _size)
        {
            ElementFat elementFat = new ElementFat();
            elementFat.m_Filename = _filename;
            elementFat.m_Version  = _version;
            elementFat.m_Time     = _time;
            elementFat.m_Size     = _size;  
            m_FatTable[_filename] = elementFat;
        }

        protected Hashtable m_FatTable = new Hashtable();
    }


    public class Serializer
    {
        public Serializer()
        {
        }

        public void SerializeObject(string filename, ObjectToSerialize objectToSerialize)
        {
            Stream stream = File.Open(filename, FileMode.Create);
            BinaryFormatter bFormatter = new BinaryFormatter();
            bFormatter.Serialize(stream, objectToSerialize);
            stream.Close();
        }

        public ObjectToSerialize DeSerializeObject(string filename)
        {
            ObjectToSerialize objectToSerialize;
            Stream stream = File.Open(filename, FileMode.Open);
            BinaryFormatter bFormatter = new BinaryFormatter();
            objectToSerialize = (ObjectToSerialize)bFormatter.Deserialize(stream);
            stream.Close();
            return objectToSerialize;
        }
    }
}