source: branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/GenealogyGraph.cs @ 8555

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab 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 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab 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 HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.EvolutionaryTracking {
  [Item("Genealogy graph", "Generic class for tracking the evolution of objects.")]
  [StorableClass]
  public class GenealogyGraph<T> : NamedItem, IGenealogyGraph<T> where T : GenealogyGraphNode {
    private readonly List<T> nodes; // graph will consist of a set of nodes of type T
    public List<T> Nodes {
      get { return nodes; }
    }

    public GenealogyGraph() {
      nodes = new List<T>();
    }

    public GenealogyGraph(GenealogyGraph<T> g) {
      nodes = new List<T>(g.Nodes);
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new GenealogyGraph<T>(this, cloner);
    }

    public override Image ItemImage {
      get { return Common.Resources.VSImageLibrary.Graph; }
    }

    [StorableConstructor]
    protected GenealogyGraph(bool serializing)
      : base(serializing) {
    }

    protected GenealogyGraph(GenealogyGraph<T> original, Cloner cloner)
      : base(original, cloner) {
      nodes = new List<T>();
    }

    public virtual bool HasNode(T t) {
      return nodes.Contains(t);
    }

    public virtual GenealogyGraphNode GetNode(T t) {
      var node = Nodes.First(x => x == t);
      return node;
    }

    public virtual bool IsEmpty {
      get { return !nodes.Any(); }
    }

    public virtual bool Any(Func<T, bool> predicate) {
      return nodes.Any(predicate);
    }

    public virtual void Clear() {
      nodes.Clear();
    }

    /// <summary>
    /// Adds a node representing an individual
    /// </summary>
    /// <param name="node">The node to add</param>
    public virtual void AddNode(T node) {
      Nodes.Add(node);
    }

    /// <summary>
    /// Remove a node from the graph along with edges associated with it
    /// </summary>
    /// <param name="t">The graph node</param>
    public virtual void RemoveNode(T t) {
      Nodes.Remove(t);
    }

    public double AverageDegree {
      get { return Nodes.Average(x => x.Degree); }
    }

    /// <summary>
    /// Adds a graph arc from a to b
    /// </summary>
    /// <param name="obj1"></param>
    /// <param name="obj2"></param>
    public virtual void AddArc(T srcNode, T destNode, object data1 = null, object data2 = null) {
      if (srcNode == null || destNode == null) return;
      srcNode.AddForwardArc(destNode, data1);
      destNode.AddReverseArc(srcNode, data2);
    }
  }
}