public void Add(IImporter importer)
 {
     if (importer == null)
         throw new ArgumentNullException("importer");
     
     base.Add(importer);
 }

 public Parser(int optimization, IStylizer stylizer, IImporter importer, bool debug = false)
 {
     Stylizer = stylizer;
     Importer = importer;
     Debug = debug;
     Tokenizer = new Tokenizer(optimization);
 }

        public Url(Node value, IImporter importer)
        {
            Importer = importer;
            ImportPaths = importer.GetCurrentPathsClone();

            Value = value;
        }

 public void Put(IImporter importer)
 {
     if (importer == null)
         throw new ArgumentNullException("importer");
     
     Remove(importer.OutputType);
     Add(importer);
 }

 public void Initialize(
     IVhptUserControlFactory vhptUserControlFactory,
     IEnumerable<VhptIdentification> vhpts,
     IImporter importer)
 {
     this.InitializeJokeImport(importer);
     this.InitializeVhpts(vhpts, vhptUserControlFactory);
 }

        public object ImportContent(Stream stream, string fileExt, IImporter importer = null)
        {
            if (importer == null)
            {
                importer = GetDefaultImporter(fileExt);
            }

            return importer.Import(stream);
        }

 public Plugin(IXmlReader xmlReader, IImporter importer, IExporter exporter)
 {
     _xmlReader = xmlReader;
     _importer = importer;
     _exporter = exporter;
     Name = "ISO Plugin";
     Version = "0.1.1";
     Owner = "AgGateway & Contributors";
 }

        private ImportAction GetImportAction(IImporter importer)
        {
            if (!_importAction.HasValue)
            {
                _importAction = importer.Import(this);
            }

            return _importAction.Value;
        }

        private Import(string path, IImporter importer, Value features)
        {
            if (path == null)
                throw new ParserException("Imports do not allow expressions");

            Importer = importer;
            Path = path;
            Features = features;

            ImportAction = Importer.Import(this); // it is assumed to be css if it cannot be found as less
        }

        public Url(Node value, IImporter importer)
        {
            if (value is TextNode)
            {
                var textValue = value as TextNode;
                if (!Regex.IsMatch(textValue.Value, @"^(([a-zA-Z]+:)|(\/))") && importer.Paths.Any())
                {
                    textValue.Value = importer.Paths.Concat(new[] { textValue.Value }).AggregatePaths(importer.CurrentDirectory);
                }
            }

            Value = value;
        }

        public Url(Node value, IImporter importer)
        {
            if (value is TextNode)
            {
                var textValue = value as TextNode;
                if (!Regex.IsMatch(textValue.Value, @"^(([a-zA-Z]+:)|(\/))"))
                {
                    textValue.Value = importer.AlterUrl(textValue.Value);
                }
            }

            Value = value;
        }

        private Import(string path, IImporter importer)
        {
            Importer = importer;
            Path = path;

            if (path.EndsWith(".css"))
            {
                Css = true;
            } else
            {
                Css = !Importer.Import(this); // it is assumed to be css if it cannot be found as less

                if (Css && path.EndsWith(".less"))
                {
                    throw new ParsingException("Cannot find less file", Index);
                }
            }
        }

        private Import(string path, IImporter importer, Value features)
        {
            Importer = importer;
            Path = path;
            Features = features;

            if (path.EndsWith(".css"))
            {
                Css = true;
            } else
            {
                Css = !Importer.Import(this); // it is assumed to be css if it cannot be found as less

                if (Css && path.EndsWith(".less"))
                {
                    throw new FileNotFoundException("You are importing a file ending in .less that cannot be found.", path);
                }
            }
        }

		void select_SelectedIndexChanged(object sender, EventArgs e) {
			ImporterItem item = (select.SelectedItem as ImporterItem);
			if (item != null) {
				if (importer != null) {
					UnwireImporterEvents();
					importer.Dispose();
				}

				IImporterUI<IBilingualDictionary> newUI = null;

				if (item.Type.GetInterfaces().Contains(typeof(IDictionarySectionImporter))) {
					var si = (IDictionarySectionImporter)item.Type.GetConstructor(new Type[] { }).Invoke(new object[] { });
					var dsi = new DualSectionImporter();
					newUI = new Controls.DictionarySectionUI(dsi, si);
					importer = dsi;
				} else if(item.Type.IsSubclassOf(typeof(IBilingualDictionary))) {
					importer = (IImporter<IBilingualDictionary>)item.Type.GetConstructor(new Type[] { }).Invoke(new object[] { });

					foreach (Type t in importer.GetType().Assembly.GetTypes()) {
						var attr = Attribute.GetCustomAttribute(t, typeof(ImporterUIAttribute)) as ImporterUIAttribute;
						if (attr != null) {
							newUI = (IImporterUI<IBilingualDictionary>)Activator.CreateInstance(t, importer);
							break;
						}
					}
				}

				WireImporterEvents();
				
				if (newUI == null) {
					CurrentUI = new Controls.ErrorUI("No UI for " + item.Name, "");
					UnwireImporterEvents();
					importer.Dispose();
					importer = null;
					return;
				}

				newUI.Finished += this.ImporterUIFinished;
				CurrentUI = (Control)newUI;
			}
		}

 public Parser(int optimization, IStylizer stylizer, IImporter importer)
     : this(optimization, stylizer, importer, defaultDebug)
 {
 }

 public Url Url(Node value, IImporter importer, NodeLocation location)
 {
   return new Url(value, importer) { Location = location };
 }

 public Import Import(Quoted path, IImporter importer, int index)
 {
     return new Import(path, importer) { Index = index };
 }

 public Import Import(Quoted path, IImporter importer, Value features, bool isOnce, NodeLocation location)
 {
     return new Import(path, importer, features, isOnce) { Location = location };
 }

 /// <summary>
 /// This is constructor of Form1 instance.
 /// </summary>
 /// <param name="exporter"></param>
 /// <param name="importer"></param>
 public Form1(IExporter exporter, IImporter importer)
 {
     InitializeComponent();
     this.exporter = exporter;
     this.importer = importer;
 }

 private bool Import(IImporter importer, object ownerViewModel, string fileName, Action<object, Stream> importAction)
 {
     object importSettingsViewModel;
     if (GetImportSettings(ownerViewModel, importer, out importSettingsViewModel))
     {
         _busyService.ShowBusyIndicatorUntilFinishDrawing();
         try
         {
             using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
                 importAction(importSettingsViewModel, stream);
             return true;
         }
         catch (IOException ioe)
         {
             _dialogService.ShowError(ownerViewModel, string.Format("Error importing file:\n{0}", ioe.Message), "Cog");
         }
         catch (ImportException ie)
         {
             _dialogService.ShowError(ownerViewModel, string.Format("Error importing file:\n{0}", ie.Message), "Cog");
         }
     }
     return false;
 }