CatalogueData.cs

Go to the documentation of this file.

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

namespace HouseOver.THARM
{
    [Serializable]
    public class CatalogueData : ICollection<Customer>
    {
        private List<Customer> customers;
        private Dictionary<Customer, List<Profile>> customerProfiles;
        private Dictionary<Customer, List<Sale>> customerSales;

        public CatalogueData()
        {
            this.customers = new List<Customer>();
            this.customerProfiles = new Dictionary<Customer, List<Profile>>();
            this.customerSales = new Dictionary<Customer, List<Sale>>();
        }

        public CatalogueData(string fromFile)
        {
            this.customers = new List<Customer>();
            this.customerProfiles = new Dictionary<Customer, List<Profile>>();
            this.customerSales = new Dictionary<Customer, List<Sale>>();

            this.Deserialize(fromFile);
        }

        public void Serialize(string fileName)
        {
            IFormatter f = new BinaryFormatter();

            FileStream fs = new FileStream(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
                + Path.DirectorySeparatorChar + Path.DirectorySeparatorChar + fileName, FileMode.Create);

            f.Serialize(fs, this);
            fs.Dispose();
        }

        private void Deserialize(string fileName)
        {
            IFormatter f = new BinaryFormatter();

            FileStream fs = new FileStream(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
                + Path.DirectorySeparatorChar + Path.DirectorySeparatorChar + fileName, FileMode.Open);

            CatalogueData temp = (CatalogueData)f.Deserialize(fs);

            this.customers = temp.customers;
            this.customerSales = temp.customerSales;
            this.customerProfiles = temp.customerProfiles;

            fs.Close();
        }
        
        public Customer GetCustomer(int id)
        {
            foreach (Customer c in customers)
            {
                if (c.ID == id) return c; 
            }

            return null;
        }
        
        public void Clear()
        {
            customerProfiles.Clear();
            customers.Clear();
            customerSales.Clear();
        }

        public bool Contains(Customer item)
        {
            return customers.Contains(item);
        }

        public void CopyTo(Customer[] array, int arrayIndex)
        {
            customers.CopyTo(array, arrayIndex);
        }

        public int  Count
        {
            get { return customers.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(Customer c)
        {
            return this.RemoveCustomer(c);
        }

        public void Add(Customer item)
        {
            customers.Add(item);
        }

        private bool RemoveCustomer(Customer c)
        {
            customerSales.Remove(c);
            customerProfiles.Remove(c);
            return customers.Remove(c);
        }
        
        public List<Profile> GetProfiles(Customer c)
        {
            if (!customerProfiles.ContainsKey(c))
                return new List<Profile>();
            return customerProfiles[c];
        }

        public List<Sale> GetSales(Customer c)
        {
            if (!customerSales.ContainsKey(c))
                return new List<Sale>();
            return customerSales[c];
        }

        public void Add(Profile p)
        {
            if (!customerProfiles.ContainsKey(p.Owner))
                customerProfiles.Add(p.Owner, new List<Profile>());

            customerProfiles[p.Owner].Add(p);
        }

        public void Remove(Profile p)
        {
            if (customerProfiles.ContainsKey(p.Owner))
            {
                customerProfiles[p.Owner].Remove(p);
                if (customerProfiles[p.Owner].Count == 0)
                    customerProfiles.Remove(p.Owner);
            }
        }
        public void Add(Sale s)
        {
            if (!customerSales.ContainsKey(s.Seller))
                customerSales.Add(s.Seller, new List<Sale>());

            customerSales[s.Seller].Add(s);
        }
        public void Remove(Sale s)
        {
            if (customerSales.ContainsKey(s.Seller))
            {
                customerSales[s.Seller].Remove(s);
                if (customerSales[s.Seller].Count == 0)
                    customerSales.Remove(s.Seller);
            }
        }

        public CustomerInformationWrapper<Sale> Sales
        {
            get { return new CustomerInformationWrapper<Sale>(customerSales.Values); }
        }

        public CustomerInformationWrapper<Profile> Profiles
        {
            get { return new CustomerInformationWrapper<Profile>(customerProfiles.Values); }
        }

        public List<Customer> CustomersWithProfiles
        {
            get { return new List<Customer>(customerProfiles.Keys); } 
        }

        public List<Customer> CustomersWithSales
        {
            get { return new List<Customer>(customerSales.Keys); }
        }
        
        public IEnumerator<Sale> GetSaleEnumerator()
        {
            return new CustomerStuffEnumerator<Sale>(customerSales.Values);
        }

        public IEnumerator<Customer> GetEnumerator()
        {
            return customers.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return customers.GetEnumerator();
        }

        private class CustomerStuffEnumerator<T> : IEnumerator<T>
        {

            IEnumerator<T> currentList;
            IEnumerator<List<T>> currentPos;

            public CustomerStuffEnumerator(Dictionary<Customer, List<T>>.ValueCollection source)
            {
                currentPos = source.GetEnumerator();
            }

            public T Current
            {
                get {
                    if (currentList == null)
                        return default(T);
                    else
                        return currentList.Current;
                }
            }
            
            public void Dispose()
            {
                    
            }

            object IEnumerator.Current
            {
                get {
                    if (currentList == null)
                        return null;
                    else
                        return currentList.Current;
                }
            }

            public bool MoveNext()
            {
                while(currentList == null || !currentList.MoveNext()) 
                {
                    if (currentPos.MoveNext())
                        currentList = currentPos.Current.GetEnumerator();
                    else
                        return false;
                }

                return true;
            }

            public void Reset()
            {
                currentPos.Reset();
                currentList = null;
            }
                        
        }

        public class CustomerInformationWrapper<T> : IEnumerable<T>
        {
            private Dictionary<Customer, List<T>>.ValueCollection collection;

            public CustomerInformationWrapper(Dictionary<Customer, List<T>>.ValueCollection customerSales)
            {
                collection = customerSales;
            }
            
            public IEnumerator<T> GetEnumerator()
            {
                return new CustomerStuffEnumerator<T>(collection);
            }
                
            IEnumerator IEnumerable.GetEnumerator()
            {
                return new CustomerStuffEnumerator<T>(collection);
            }
                        
        }

               
    }
}

---