void IAlgorithms.Accept(IVisitor visitor)
 {
     foreach (IAlgorithm a in this._lstAlgorithm)
     {
         visitor.Visit(a);
     }
 }

 public override void AcceptVisit(IVisitor visitor)
 {
     visitor.StartVisit<ISimpleFixture>(this);
     MaterialFactory.AcceptVisit(visitor);
     ShapeFactory.AcceptVisit(visitor);
     visitor.EndVisit<ISimpleFixture>(this);
 }

 public override void OnVisitChildNodes(IVisitor visitor)
 {
     if (Condition != null)
         Condition.Visit(visitor);
     if (Code != null)
         Code.Visit(visitor);
 }

 public void Accept(IVisitor visitor)
 {
     foreach (var account in this.accounts)
     {
         account.Accept(visitor);
     }
 }

        private void RunInDepth(WorkFlowContext context, IVisitor visitor)
        {
            if (string.IsNullOrEmpty(context.SourceState))
            {
                return;
            }
            else
            {
                foreach (var item in this.GetActivities(context).OrderBy(x => x.Operation))
                {
                    context.Operation = item.Operation;
                    string newstatus = this.GetNextStatus(context);
                    string laststate = context.SourceState;
                    string transition = string.Format("{0},{1},{2}", context.SourceState, item.Description, newstatus);

                    if (NotPresent(transition))
                    {
                        visitor.Visit(context.SourceState, new Activity { Operation = item.Operation, Description = item.Description }, newstatus);
                        context.SourceState = newstatus;
                        RunInDepth(context, visitor);
                        context.SourceState = laststate;
                    }
                }
            }
        }

        private void RunInWidth(WorkFlowContext context, IVisitor visitor)
        {
            Queue<string> fila = new Queue<string>();
            List<string> mark = new List<string>();

            fila.Enqueue(context.SourceState);
            mark.Add(context.SourceState);

            while (fila.Count != 0)
            {
                string statusfila = fila.Dequeue();
                context.SourceState = statusfila;
                foreach (var item in this.GetActivities(context).OrderBy(x => x.Operation))
                {
                    context.Operation = item.Operation;
                    string newstatus = this.GetNextStatus(context);
                    visitor.Visit(statusfila, new Activity { Operation = item.Operation, Description = item.Description }, newstatus);

                    if (!mark.Contains(newstatus))
                    {
                        fila.Enqueue(newstatus);
                        mark.Add(newstatus);
                    }
                }
            }
        }

 /**
  * Create a new Logger, which has as initial trace a sequence of
  * visiting events where the visitor <code>v</code> visits each of
  * the <code>nodes</code>
  */
 public Logger(IVisitor v, IVisitable[] nodes)
 {
     for (int i = 0; i < nodes.Length; i++)
     {
         log( new Event(v, nodes[i]) );
     }
 }

 public void Visit(IVisitor visitor)
 {
     foreach (var employee in this.employees)
     {
         visitor.Visit(employee);
     }
 }

 public override void OnVisitChildNodes(IVisitor visitor)
 {
     foreach (var n in Content)
     {
         n.Visit(visitor);
     }
 }

        public void Accept(IVisitor visitor)
        {
            visitor.VisitScene(this);

            foreach (IVisitable childScene in this.ChildGraphs)
                childScene.Accept(visitor);
        }

        private bool Accept(IVisitor visitor, Stack<int> inStack, Stack<int> resumeStack)
        {
            if (visitor.VisitEnter(this)) {

                int firstChild = 0;

                if (resumeStack.Count > 0) {
                    firstChild = resumeStack.Pop();
                    if (resumeStack.Count == 0) {
                        // If this is the node we found last time then start looking at the next one
                        firstChild++;
                    }
                }

                for (int i = firstChild; i < Children.Count(); i++) {
                    Composite c = Children.ElementAt(i);
                    if (!c.Accept(visitor, inStack, resumeStack)) {
                        inStack.Push(i);
                        break;
                    }
                }
            }

            return visitor.VisitExit(this);
        }

 public override void Accept(IVisitor visitor)
 {
     if (visitor != null)
     {
         visitor.Visit(this);
     }
 }

		public void Accept(IVisitor visitor)
		{
			foreach (IEntity entity in Entities)
			{
				entity.Accept(visitor);
			}
		}

 public override void OnVisitChildNodes(IVisitor visitor)
 {
     foreach (var e in Expressions)
     {
         e.Visit(visitor);
     }
 }

    public void Accept(IVisitor visitor)
    {
      AdditionVisitor addVisitor = visitor as AdditionVisitor;

      if (addVisitor != null)
        addVisitor.args[Strings.result] =  addVisitor.add();
    }

 public void Accept(IVisitor visitor)
 {
     foreach (var asset in _assets)
     {
         asset.Accept(visitor);
     }
 }

 public void AcceptVisit(IVisitor visitor)
 {
     visitor.StartVisit<ISimulator>(this);
     ActorsFactory.AcceptVisit(visitor);
     ConstraintsFactory.AcceptVisit(visitor);
     visitor.EndVisit<ISimulator>(this);
 }

 public GarbageCollector(List<IMemoryProfile> memoryProfiles, IVisitor visitor)
 {
     foreach (var item in memoryProfiles)
     {
         item.Accept(visitor);
     }
 }

 public override void OnVisitChildNodes(IVisitor visitor)
 {
     foreach (var kp in Values)
     {
         kp.Value.Visit(visitor);
     }
 }

 public void Accept(IVisitor visitor)
 {
     foreach (var employee in this.employees)
     {
         employee.Accept(visitor);
     }
 }