public object ReadYaml(IParser parser, Type type)
 {
     var scalar = (YamlDotNet.Core.Events.Scalar)parser.Current;
     var bytes = Convert.FromBase64String(scalar.Value);
     parser.MoveNext();
     return bytes;
 }

 public void Download(Uri uri, object metaData, IParser parser)
 {
     uriParserPairs.Add(metaData, parser);
     var request = (HttpWebRequest)WebRequest.Create(uri);
     var state = new RequestState { Request = request, Metadata = metaData };
     request.BeginGetResponse(GetData, state);
 }

		public	ExpEvaluator(IParser _parser)
		{
			//Use IParser to parse it 
			_exp_parser = _parser;

			// TODO: Add constructor logic here
		}

 public StartParsing(IFilePaths filePaths, ILogFileReaderList logfileReaderList, ILogStatisticsRepository logStatisticsRepository, IParser parser)
 {
     _filePaths = filePaths;
     _logfileReaderList = logfileReaderList;
     _logStatisticsRepository = logStatisticsRepository;
     _parser = parser;
 }

		public void Setup()
		{
			ccu = new CodeCompileUnit();
			mocks = new MockRepository();
			engine = Engine.GlobalEngine;
			engine.BinPath = @"C:\Program Files (x86)\MSBuild";
			project = new Project();
			buildEngine = mocks.DynamicMock<MockBuildEngine>(project);

			logger = new NullLogger();
			parserService = mocks.DynamicMock<ISiteTreeGeneratorService>();
			naming = mocks.DynamicMock<INamingService>();
			sourceStorage = mocks.DynamicMock<IParsedSourceStorageService>();
			source = mocks.DynamicMock<ISourceGenerator>();
			typeResolver = mocks.DynamicMock<ITypeResolver>();
			treeService = mocks.DynamicMock<ITreeCreationService>();
			viewSourceMapper = mocks.DynamicMock<IViewSourceMapper>();
			generator = mocks.DynamicMock<IGenerator>();

			task = new GenerateMonoRailSiteTreeTask(logger, parserService, naming, source, sourceStorage, typeResolver,
			                                         treeService, viewSourceMapper, generator);

			item = mocks.DynamicMock<ITaskItem>();
			parsedSource = mocks.DynamicMock<IParser>();
		}

 private IEnumerable<ParsingEvent> EnumerationOf(IParser parser)
 {
     while (parser.MoveNext())
     {
         yield return parser.Current;
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ParserAnalyzer" /> with the specified weight.
        /// </summary>
        /// <param name="parser">The parser.</param>
        /// <param name="weight">The analyzer weight.</param>
        /// <exception cref="System.ArgumentNullException">parser</exception>
        public ParserAnalyzer(IParser parser, float weight)
            : base(weight) {
            if (parser == null)
                throw new ArgumentNullException("parser");

            Parser = parser;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ReportBuilder"/> class.
        /// </summary>
        /// <param name="parser">The IParser to use.</param>
        /// <param name="rendererFactory">The renderer factory.</param>
        /// <param name="targetDirectory">The directory where the generated report should be saved.</param>
        /// <param name="assemblyFilter">The assembly filter.</param>
        public ReportBuilder(IParser parser, IRendererFactory rendererFactory, string targetDirectory, IAssemblyFilter assemblyFilter)
        {
            if (parser == null)
            {
                throw new ArgumentNullException("parser");
            }

            if (rendererFactory == null)
            {
                throw new ArgumentNullException("rendererFactory");
            }

            if (targetDirectory == null)
            {
                throw new ArgumentNullException("targetDirectory");
            }

            if (assemblyFilter == null)
            {
                throw new ArgumentNullException("assemblyFilter");
            }

            this.parser = parser;
            this.rendererFactory = rendererFactory;
            this.targetDirectory = targetDirectory;
            this.assemblyFilter = assemblyFilter;
        }

 public ParserUi(IParser parser,ICGunitHost host)
 {
     InitializeComponent();
     m_parser = parser;
     m_Host = host;
     m_Host.evProjectStatus += new onProjectStatus(Owner_evProjectStatus);
 }

 /// <summary>
 /// Instantiates a build script object.
 /// </summary>
 /// <remarks>
 /// This constructor will attempt to parse the given SQL and determine whether it is valid 
 /// and whether the script creates the object specified by the given identifier.  If the 
 /// script is invalid in anyway, the <see cref="ScriptError"/> property will reflect that.
 /// </remarks>
 /// <param name="scriptObject">The identifier of the database object to build.</param>
 /// <param name="scriptContent">The build script SQL content.</param>
 /// <param name="parser">The sql script parser for reading the SQL script content.</param>
 public ScriptFile(TypedDatabaseObject scriptObject, string scriptContent, IParser parser)
 {
     ScriptObject = scriptObject;
     Content = scriptContent;
     existingDependencies = new HashSet<TypedDatabaseObject>();
     try
     {
         Sql = parser.ParseSqlScript(scriptContent);
         AssertMatchingContent();
     }
     catch (SqlParseException ex)
     {
         ScriptError = new SqlParseError(ex.Message);
         Sql = null;
     }
     catch(EmptyTextException)
     {
         ScriptError = new EmptyTextError();
         Sql = null;
     }
     catch(MultipleStatementException ex)
     {
         ScriptError = new MultipleStatementError(ex.Count, ex.Allotment);
         Sql = null;
     }
     catch(UnexpectedObjectTypeException ex)
     {
         ScriptError = new UnexpectedObjectTypeError(ex.TypeName);
         Sql = null;
     }
 }

 public RazorMailSender(MailAddress sender, Uri baseUri, SmtpClient client, IParser parser)
 {
     Sender = sender;
     BaseUri = baseUri;
     Client = client ?? new SmtpClient("127.0.0.1");
     Parser = parser ?? new HtmlAgilityPackParser(baseUri);
 }

        public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
        {
            var nodeEvent = parser.Peek<NodeEvent>();

            var nodeType = GetTypeFromEvent(nodeEvent, expectedType);

            try
            {
                foreach (var deserializer in deserializers)
                {
                    object value;
                    if (deserializer.Deserialize(parser, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
                    {
                        return value;
                    }
                }
            }
            catch (YamlException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", ex);
            }

            throw new YamlException(
                nodeEvent.Start,
                nodeEvent.End,
                string.Format(
                    "No node deserializer was able to deserialize the node into type {0}",
                    expectedType.AssemblyQualifiedName
                )
            );
        }

		void DoTestEnums (IParser parser)
		{
			ICompilationUnit unit = parser.Parse (null, "a.cs", 
@"enum TestEnum {
	A,
	B,
	C
}").CompilationUnit;
			Assert.AreEqual (1, unit.Types.Count);
			IType type = unit.Types[0];
			Assert.AreEqual (ClassType.Enum, type.ClassType);
			Assert.AreEqual ("TestEnum", type.Name);
			Assert.AreEqual (3, type.FieldCount);
			foreach (IField f in type.Fields) {
				Assert.IsTrue (f.IsConst);
				Assert.IsTrue (f.IsSpecialName);
				Assert.IsTrue (f.IsPublic);
				if (f.Name == "A") {
					Assert.AreEqual (2, f.Location.Line);
				} else if (f.Name == "B") {
					Assert.AreEqual (3, f.Location.Line);
				} else if (f.Name == "C") {
					Assert.AreEqual (4, f.Location.Line);
				} else {
					Assert.Fail ("Unknown field: " + f.Name);
				}
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="ReportGenerator" /> class.
        /// </summary>
        /// <param name="parser">The IParser to use.</param>
        /// <param name="assemblyFilter">The assembly filter.</param>
        /// <param name="classFilter">The class filter.</param>
        /// <param name="renderers">The renderers.</param>
        internal ReportGenerator(IParser parser, IFilter assemblyFilter, IFilter classFilter, IEnumerable<IReportBuilder> renderers)
        {
            if (parser == null)
            {
                throw new ArgumentNullException("parser");
            }

            if (assemblyFilter == null)
            {
                throw new ArgumentNullException("assemblyFilter");
            }

            if (classFilter == null)
            {
                throw new ArgumentNullException("classFilter");
            }

            if (renderers == null)
            {
                throw new ArgumentNullException("renderers");
            }

            this.parser = parser;
            this.assemblyFilter = assemblyFilter;
            this.classFilter = classFilter;
            this.renderers = renderers;
        }

 public FileReader(IParser parser, string path )
 {
     this.parser = parser;
     //TODO make this more generic
     icdString = File.ReadAllText(path);
     parser.ParseIcdCatalog(icdString);
 }

 public ExecutionContext(IParser parser)
 {
     Parser = parser;
     CaseSensitive = false;
     Store = CaseSensitive ? new Dictionary<string, ContextValue>() : new Dictionary<string, ContextValue>(StringComparer.InvariantCultureIgnoreCase);
     Dependencies = CaseSensitive ? new Dictionary<string, HashSet<string>>() : new Dictionary<string, HashSet<string>>(StringComparer.InvariantCultureIgnoreCase);
 }

		public void Add(string path, IParser parser)
		{
			if (cache.ContainsKey(path))
				throw new ArgumentException(String.Format("Source for {0} already cached!", path));
		
			cache[path] = parser;
		}

 public Database Create(FileInfo pathToGit, IParser sqlParser)
 {
     var connectionStr = ConnectionString;
     Func<SqlConnection> connection = () => new SqlConnection(connectionStr);
     var repo = new GitScriptRepository(ScriptsPath, ServerName, DatabaseName, pathToGit, sqlParser);
     return new Database(ServerName, DatabaseName, connection, repo);
 }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="parser">Parser implementation</param>
        /// <param name="printResults">Action to be invoked after the processing has finished</param>
        public ConsumerUnit(IParser<string> parser, Action<IEnumerable<string>> printResults)
        {
            Parser = parser;
            PrintResults = printResults;

            Results = new List<string>();
        }

 public Calculator(ICollection<IExportFactory<IOperation, OperationMetadata>> operationFactories, IParser parser)
 {
     this.parser = parser;
     this.OperationsDictionary = operationFactories.ToDictionary(
         e => e.Metadata.Operation,
         e => e.CreateExport().Value);
 }