// Create a PageParserFilter and initialize it
    internal static PageParserFilter Create(PagesSection pagesConfig, VirtualPath virtualPath, TemplateParser parser) {
        PageParserFilter pageParserFilter = pagesConfig.CreateControlTypeFilter();
        if (pageParserFilter != null)
            pageParserFilter.InitializeInternal(virtualPath, parser);

        return pageParserFilter;
    }

        private VirtualDirectoryMapping(VirtualPath virtualDirectory, string physicalDirectory, bool isAppRoot, string configFileBaseName) {
            _virtualDirectory = virtualDirectory;
            _isAppRoot = isAppRoot;

            PhysicalDirectory = physicalDirectory;
            ConfigFileBaseName = configFileBaseName;
        }

    internal PageThemeBuildProvider(VirtualPath virtualDirPath) {
        _virtualDirPath = virtualDirPath;

        // 

        SetVirtualPath(virtualDirPath);
    }

        public IView GetView(VirtualPath path)
        {
            if (path.Parts.Count == 0) return null;
            var filename = "../" + path.Parts.Last();

            var candidatePaths = new VirtualPath[] { path }
                .Concat(
                    from ext in _registry.GetRegisteredExtensions()
                    select path.Append(filename + "." + ext)
                );

            var infos =
                from c in candidatePaths
                let info = _registry.GetViewInfo(path)
                let resource = info.Location(info.RelativePath, _serviceLocator)
                where resource != null && resource.IsFile
                select new {
                    Path = c,
                    Resource = resource
                };

            var viewInfo = infos.FirstOrDefault();
            if (viewInfo == null) return null;

            var resourceResolver = new ViewResourceResolver(_registry, _serviceLocator, viewInfo.Resource);
            var extension = viewInfo.Path.Parts.Last().Split('.').Last();
            var viewEngine = _registry.GetViewEngine(extension);
            return viewEngine.GetView(viewInfo.Path, resourceResolver);
        }

    internal BuildResult ReadBuildResultFromFile(VirtualPath virtualPath, string preservationFile, long hashCode, bool ensureIsUpToDate) {

        // Ignore if the preservation file doesn't exist
        if (!FileUtil.FileExists(preservationFile)) {
            Debug.Trace("PreservationFileReader", "Can't find preservation file " + Path.GetFileName(preservationFile));
            return null;
        }

        BuildResult result = null;
        try {
            result = ReadFileInternal(virtualPath, preservationFile, hashCode, ensureIsUpToDate);
        }
        catch (SecurityException) {
            // We eat all exceptions, except for SecurityException's, because they
            // are ususally a sign that something is not set up correctly, and we
            // don't want to lose the stack (VSWhidbey 269566)
            throw;
        }
        catch {
            if (!_precompilationMode) {
                // The preservation file can't be used, so get rid of it
                Util.RemoveOrRenameFile(preservationFile);
            }
        }

        return result;
    }

 public NTFSDirectory(NTFSFileSystemProvider fileSystemProvider, string name, VirtualPath path)
 {
     this.fileSystemProvider = fileSystemProvider;
     Name = name;
     if (path.IsRoot)
         Name = string.Empty;
     Path = path;
 }

 // if appHost is null, we use the site name for the current application
 string IServerConfig.MapPath(IApplicationHost appHost, VirtualPath path) {
     string siteName = (appHost == null) ? _siteNameForCurrentApplication : appHost.GetSiteName();
     string physicalPath = ProcessHostConfigUtils.MapPathActual(siteName, path);
     if (FileUtil.IsSuspiciousPhysicalPath(physicalPath)) {
         throw new InvalidOperationException(SR.GetString(SR.Cannot_map_path, path.VirtualPathString));
     }
     return physicalPath;
 }

 public ResourceMapping(VirtualPath root, IResourceLocation location)
 {
     if (root.Type != VirtualPathType.AppRelative) {
         throw new ArgumentException("The root path must be app-relative.");
     }
     Root = root;
     Location = location;
 }

		protected override string MapPath (VirtualPath virtualPath)
		{
			// We need this hack to support out-of-application wsdl helpers
			if (virtualPath.IsFake)
				return virtualPath.PhysicalPath;

			return base.MapPath (virtualPath);
		}               

 internal BuildProvidersCompiler(VirtualPath configPath, bool supportLocalization, 
     string outputAssemblyName) {
     _configPath = configPath;
     _supportLocalization = supportLocalization;
     _compConfig = MTConfigUtil.GetCompilationConfig(_configPath);
     _referencedAssemblies = BuildManager.GetReferencedAssemblies(CompConfig);
     _outputAssemblyName = outputAssemblyName;
 }

    protected void AddDependency(VirtualPath virtualPath) {
        virtualPath = ResolveVirtualPath(virtualPath);
        Debug.Trace("Template", "Parsed dependency: " + _virtualPath + " depends on " + virtualPath);

        if (_virtualPathDependencies == null)
            _virtualPathDependencies = new CaseInsensitiveStringSet();

        _virtualPathDependencies.Add(virtualPath.VirtualPathString);
    }

    internal CodeBlockBuilder(CodeBlockType blockType, string content, int lineNumber, int column, VirtualPath virtualPath, bool encode) {
        _content = content;
        _blockType = blockType;
        _column = column;
        IsEncoded = encode;

        Line = lineNumber;
        VirtualPath = virtualPath;
    }

        protected override IView CreateView(VirtualPath pathToView, IResourceResolver resolver)
        {
            var resource = resolver.GetResource(pathToView);
            if (resource == null || !resource.IsFile) {
                return null;
            }

            return new NustacheView(this, pathToView, resource, resolver);
        }

 private Template GetChildTemplate(string path)
 {
     var newPath = new VirtualPath(path);
     if (newPath.Type != VirtualPathType.AppRelative) {
         throw new NotSupportedException("The Nustache view engine only supports app-relative paths at present.");
     }
     var result = _engine.GetView(newPath, _resolver) as NustacheView;
     if (result == null) return null;
     return result.Template;
 }

 public DotLiquidView(VirtualPath path, IResource resource, IResourceResolver resolver)
 {
     _path = path;
     _resolver = resolver;
     using (var stream = resource.Open())
     using (var reader = new StreamReader(stream)) {
         string tpl = reader.ReadToEnd();
         _template = Template.Parse(tpl);
     }
 }

		protected override TextReader SpecialOpenReader (VirtualPath virtualPath, out string physicalPath)
		{
			// We need this hack to support out-of-application wsdl helpers
			if (virtualPath.IsFake) {
				physicalPath = virtualPath.PhysicalPath;
				return new StreamReader (physicalPath);
			} else
				physicalPath = null;
			
			return base.SpecialOpenReader (virtualPath, out physicalPath);
		}

 public NustacheView(NustacheViewEngine engine, VirtualPath path, IResource resource, IResourceResolver resolver)
 {
     _engine = engine;
     _path = path;
     _resolver = resolver;
     using (var stream = resource.Open())
     using (var reader = new StreamReader(stream)) {
         Template = new Template();
         Template.Load(reader);
     }
 }

    IHttpHandler IHttpHandlerFactory2.GetHandler(HttpContext context, String requestType,
        VirtualPath virtualPath, String physicalPath) {

        // If it's a derived class, we must call the old (less efficient) GetHandler, in
        // case it was overriden
        if (_isInheritedInstance) {
            return GetHandler(context, requestType, virtualPath.VirtualPathString, physicalPath);
        }

        return GetHandlerHelper(context, requestType, virtualPath, physicalPath);
    }

        public IResource GetResource(VirtualPath path)
        {
            var resourceName = String.Join(".",
                new[] { RootNamespace }.Concat(path.Parts)
            );
            var name = this.Assembly.GetManifestResourceNames().FirstOrDefault
                (x => x.Equals(resourceName, StringComparison.OrdinalIgnoreCase));
            if (name == null) return null;

            return new AssemblyResource(this.Assembly, name);
        }

 public IResource GetResource(VirtualPath path)
 {
     var parts = new string[] { Root }.Concat(path.Parts).ToArray();
     var physicalPath = Path.Combine(parts);
     if (File.Exists(physicalPath)) {
         return new FileResource(physicalPath);
     }
     else {
         return null;
     }
 }