source: branches/Operator Architecture Refactoring/HeuristicLab.Core/3.3/CallGraph.cs @ 2059

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2008 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.Text;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Core {
  public class CallGraph : CallNodeBase, ICallGraph {
    [Storable]
    private Dictionary<ICallNode, List<ICallNode>> transitions;

    [Storable]
    private List<ICallNode> myCallNodes;
    public ICollection<ICallNode> CallNodes {
      get { return myCallNodes.AsReadOnly(); }
    }
    [Storable]
    private ICallNode myInitialCallNode;
    public ICallNode InitialCallNode {
      get { return myInitialCallNode; }
      internal set {
        if (myInitialCallNode != value) {
          myInitialCallNode = value;
          OnInitialCallNodeChanged();
        }
      }
    }

    public CallGraph()
      : base() {
      transitions = new Dictionary<ICallNode, List<ICallNode>>();
      myCallNodes = new List<ICallNode>();
      myInitialCallNode = null;
    }
    public CallGraph(CallGraph parentGraph)
      : base(parentGraph) {
      transitions = new Dictionary<ICallNode, List<ICallNode>>();
      myCallNodes = new List<ICallNode>();
      myInitialCallNode = null;
    }

    public override ICloneable Clone(ICloner cloner) {
      CallGraph clone = (CallGraph)base.Clone(cloner);
      foreach (ICallNode callNode in CallNodes)
        clone.AddCallNode((ICallNode)cloner.Clone(callNode));
      foreach (ICallNode source in CallNodes)
        foreach (ICallNode target in transitions[source])
          clone.AddTransition((ICallNode)cloner.Clone(source), (ICallNode)cloner.Clone(target));
      clone.InitialCallNode = (ICallNode)cloner.Clone(InitialCallNode);

      return base.Clone(cloner);
    }

    public override IView CreateView() {
      return new CallGraphView(this);
    }

    internal void AddCallNode(ICallNode callNode) {
      myCallNodes.Add(callNode);
      transitions.Add(callNode, new List<ICallNode>());
      OnCallNodeAdded(callNode);
    }
    public void RemoveCallNode(ICallNode callNode) {
      if (myCallNodes.Remove(callNode)) {
        foreach (ICallNode node in CallNodes) {  // remove incoming transitions
          while (transitions[node].Contains(callNode))
            RemoveTransition(node, callNode);
        }
        while (transitions[callNode].Count > 0)  // remove outgoing transitions
          RemoveTransition(callNode, transitions[callNode][0]);
        transitions.Remove(callNode);
        OnCallNodeRemoved(callNode);
      }
    }

    public void AddTransition(ICallNode source, ICallNode target) {
      transitions[source].Add(target);
      OnTransitionAdded(source, target);
    }
    public void RemoveTransition(ICallNode source, ICallNode target) {
      if (transitions[source].Remove(target))
        OnTransitionRemoved(source, target);
    }

    internal IList<ICallNode> GetSuccessorNodes(ICallNode callNode) {
      return transitions[callNode].AsReadOnly();
    }

    public event EventHandler<EventArgs<ICallNode>> CallNodeAdded;
    protected virtual void OnCallNodeAdded(ICallNode callNode) {
      if (CallNodeAdded != null)
        CallNodeAdded(this, new EventArgs<ICallNode>(callNode));
    }
    public event EventHandler<EventArgs<ICallNode>> CallNodeRemoved;
    protected virtual void OnCallNodeRemoved(ICallNode callNode) {
      if (CallNodeRemoved != null)
        CallNodeRemoved(this, new EventArgs<ICallNode>(callNode));
    }
    public event EventHandler InitialCallNodeChanged;
    protected virtual void OnInitialCallNodeChanged() {
      if (InitialCallNodeChanged != null)
        InitialCallNodeChanged(this, new EventArgs());
    }
    public event EventHandler<EventArgs<ICallNode, ICallNode>> TransistionAdded;
    protected virtual void OnTransitionAdded(ICallNode source, ICallNode target) {
      if (TransistionAdded != null)
        TransistionAdded(this, new EventArgs<ICallNode,ICallNode>(source, target));
    }
    public event EventHandler<EventArgs<ICallNode, ICallNode>> TransistionRemoved;
    protected virtual void OnTransitionRemoved(ICallNode source, ICallNode target) {
      if (TransistionRemoved != null)
        TransistionRemoved(this, new EventArgs<ICallNode, ICallNode>(source, target));
    }
  }
}