FavoriteManager.cs :  » Business-Application » DC » DCSharp » Backend » Managers » C# / CSharp Open Source

/* 
 * Copyright (C) 2004-2005 Jonathan Bindel
 * Copyright (C) 2006-2007 Eskil Bylund
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

using System;
using System.Collections.Generic;
using System.Xml.Serialization;

using DCSharp.Backend.Objects;
using DCSharp.Xml;

namespace DCSharp.Backend.Managers{
  [XmlRoot("Favorites")]
  public class FavoriteManager : IFavoriteHubManager, IFavoriteUserManager
  {
    public FavoriteManager()
    {
      hubs = new List<FavoriteHubInfo>();
      users = new List<FavoriteUserInfo>();
      
      syncRoot = new Object();
    }
    
    [XmlArray("Hubs")]
    [XmlArrayItem("Hub", typeof(FavoriteHubInfo))]
    public List<FavoriteHubInfo> FavoriteHubs
    {
      get { return hubs; }
    }
    private List<FavoriteHubInfo> hubs;
    
    [XmlArray("Users")]
    [XmlArrayItem("User", typeof(FavoriteUserInfo))]
    public List<FavoriteUserInfo> FavoriteUsers
    {
      get { return users; }
    }
    private List<FavoriteUserInfo> users;
    
    [XmlIgnore]
    public object SyncRoot
    {
      get { return syncRoot; }
    }
    private object syncRoot;
    
    #region IFavoriteHubManager
    
    public event EventHandler<FavoriteHubEventArgs> HubAdded;
    public event EventHandler<FavoriteHubEventArgs> HubRemoved;
    public event EventHandler HubsSorted;
    
    [XmlIgnore]
    public int HubCount
    {
      get { return hubs.Count; }
    }
    
    [XmlIgnore]
    public IEnumerable<FavoriteHubInfo> Hubs
    {
      get { return hubs; }
    }
    
    public void Add(FavoriteHubInfo info)
    {
      lock (syncRoot)
      {
        hubs.Add(info);
        OnHubAdded(info);
      }
    }
    
    public void Remove(FavoriteHubInfo info)
    {
      lock (syncRoot)
      {
        hubs.Remove(info);
        OnHubRemoved(info);
      }
    }
    
    public bool Contains(FavoriteHubInfo info)
    {
      return hubs.Contains(info);
    }
    
    public void Sort(IComparer<FavoriteHubInfo> comparer)
    {
      lock (hubs)
      {
        hubs.Sort(comparer);
        OnHubsSorted();
      }
    }
    
    #endregion
    
    #region IFavoriteUserManager
    
    public event EventHandler<FavoriteUserEventArgs> UserAdded;
    public event EventHandler<FavoriteUserEventArgs> UserRemoved;
    
    [XmlIgnore]
    public int UserCount
    {
      get { return users.Count; }
    }
    
    [XmlIgnore]
    public FavoriteUserInfo this[User user]
    {
      get
      {
        lock (syncRoot)
        {
          return users.Find(delegate(FavoriteUserInfo info)
          {
            return info.User == user;
          });
        }
      }
    }
    
    [XmlIgnore]
    public IEnumerable<FavoriteUserInfo> Users
    {
      get { return users; }
    }
    
    public void Add(FavoriteUserInfo info)
    {
      lock (syncRoot)
      {
        users.Add(info);
        info.User.OnlineChanged += OnOnlineChanged;
        
        OnUserAdded(info);
      }
    }
    
    public void Remove(FavoriteUserInfo info)
    {
      lock (syncRoot)
      {
        users.Remove(info);
        info.User.OnlineChanged -= OnOnlineChanged;
        
        OnUserRemoved(info);
      }
    }
    
    public bool Contains(FavoriteUserInfo info)
    {
      return users.Contains(info);
    }
    
    #endregion
    
    private void OnOnlineChanged(object obj, EventArgs args)
    {
      lock (syncRoot)
      {
        FavoriteUserInfo info = this[(User)obj];
        if (info != null)
        {
          info.LastSeen = DateTime.Now;
        }
      }
    }
    
    protected virtual void OnHubAdded(FavoriteHubInfo info)
    {
      if (HubAdded != null)
      {
        HubAdded(this, new FavoriteHubEventArgs(info));
      }
    }
    
    protected virtual void OnHubRemoved(FavoriteHubInfo info)
    {
      if (HubRemoved != null)
      {
        HubRemoved(this, new FavoriteHubEventArgs(info));
      }
    }
    
    protected virtual void OnHubsSorted()
    {
      if (HubsSorted != null)
      {
        HubsSorted(this, EventArgs.Empty);
      }
    }
    
    protected virtual void OnUserAdded(FavoriteUserInfo info)
    {
      if (UserAdded != null)
      {
        UserAdded(this, new FavoriteUserEventArgs(info));
      }
    }
    
    protected virtual void OnUserRemoved(FavoriteUserInfo info)
    {
      if (UserRemoved != null)
      {
        UserRemoved(this, new FavoriteUserEventArgs(info));
      }
    }
    
    public void Save(string filename)
    {
      XmlHelper.Serialize(this, filename);
    }

    public static FavoriteManager Load(string filename)
    {
      return (FavoriteManager)XmlHelper.Deserialize(typeof(FavoriteManager),
        filename);
    }
  }
}