Semi generated crawler

using System;
using System.Collections.Generic;
using System.Globalization;
namespace LightWebTestFramework
{
	[Serializable]
	public class WebTestLoop : WebTestConditionalConstruct
	{
		private int m_currentIterationNumber;
		private List<DataSourceDataTablePair> m_effectedDataSources = new List<DataSourceDataTablePair>();
		public LoopConditionalRuleReference LoopConditionalRuleReference
		{
			get
			{
				return (LoopConditionalRuleReference)base.ConditionalRuleReference;
			}
		}
		public int CurrentIterationNumber
		{
			get
			{
				return this.m_currentIterationNumber;
			}
		}
		public WebTestLoop(LoopConditionalRuleReference conditionalRuleReference)
		{
			base.Initialize(conditionalRuleReference);
		}
		public WebTestLoop(ConditionalRule conditionalRule, int maxIterations, bool advanceDataSources)
		{
			LoopConditionalRuleReference loopConditionalRuleReference = new LoopConditionalRuleReference(conditionalRule.GetType());
			WebTestFrameworkHelperMethods.PopulateConditionalRuleReferenceFromInstance(loopConditionalRuleReference, conditionalRule);
			loopConditionalRuleReference.MaxIterations = maxIterations;
			loopConditionalRuleReference.AdvanceDataCursors = advanceDataSources;
			base.Initialize(loopConditionalRuleReference);
		}
		protected WebTestLoop(WebTestLoop copy) : base(copy)
		{
			base.Initialize(copy, new LoopConditionalRuleReference(copy.LoopConditionalRuleReference));
			this.m_effectedDataSources = new List<DataSourceDataTablePair>();
			foreach (DataSourceDataTablePair current in copy.m_effectedDataSources)
			{
				this.m_effectedDataSources.Add(new DataSourceDataTablePair(current));
			}
		}
		public override object Clone()
		{
			return new WebTestLoop(this);
		}
		public override object RuntimeClone()
		{
			WebTestLoop webTestLoop = new WebTestLoop(this);
			webTestLoop.Initialize(new LoopConditionalRuleReference(this.LoopConditionalRuleReference));
			foreach (WebTestItem current in base.Items)
			{
				webTestLoop.Items.Add((WebTestItem)current.RuntimeClone());
			}
			return webTestLoop;
		}
		public void RegisterDataSource(string dataSourceName, string dataTableName)
		{
			DataSourceDataTablePair item = new DataSourceDataTablePair(dataSourceName, dataTableName);
			if (!this.m_effectedDataSources.Contains(item))
			{
				this.m_effectedDataSources.Add(item);
			}
		}
		public override string ToString()
		{
			return this.ToString(this.GetConditionalRuleText());
		}
		public override string ToString(string conditionalRuleText)
		{
			return string.Format(CultureInfo.CurrentCulture, Resources.StringRepresentationForLoop, new object[]
			{
				conditionalRuleText
			});
		}
		public override void ExecuteInitializeConditionalRule(WebTest webTest)
		{
			this.m_currentIterationNumber = 0;
			base.ExecuteInitializeConditionalRule(webTest);
		}
		public override bool ExecuteCheckConditionalRule(WebTest webTest)
		{
			this.m_currentIterationNumber++;
			if (this.LoopConditionalRuleReference.MaxIterations != -1 && this.LoopConditionalRuleReference.MaxIterations < this.m_currentIterationNumber)
			{
				base.ProcessLoopErrorMessage(Resources.ErrorExceededLoopMaxIterations);
				return false;
			}
			if (this.m_currentIterationNumber > 1 && this.LoopConditionalRuleReference.AdvanceDataCursors)
			{
				foreach (DataSourceDataTablePair current in this.m_effectedDataSources)
				{
					try
					{
						webTest.MoveDataTableCursor(current.DataSourceName, current.DataTableName);
					}
					catch (Exception ex)
					{
						base.ProcessLoopErrorMessage(ex.Message);
						return false;
					}
				}
			}
			return base.ExecuteCheckConditionalRule(webTest);
		}
	}
}