public void EndNode(AstNode node) { if (nodeStack.Pop() != node) { throw new InvalidOperationException(); } if (!(node.Annotation <MethodDebugInfoBuilder>() is null)) { Debug2.Assert(!(currentMethodDebugInfoBuilder is null)); if (context.CalculateILSpans) { foreach (var ns in context.UsingNamespaces) { currentMethodDebugInfoBuilder.Scope.Imports.Add(ImportInfo.CreateNamespace(ns)); } } output.AddDebugInfo(currentMethodDebugInfoBuilder.Create()); currentMethodDebugInfoBuilder = parentMethodDebugInfoBuilder.Pop(); } var mms = node.Annotation <List <Tuple <MethodDebugInfoBuilder, List <ILSpan> > > >(); if (!(mms is null)) { Debug.Assert(mms == multiMappings); if (mms == multiMappings) { foreach (var mm in mms) { output.AddDebugInfo(mm.Item1.Create()); } multiMappings = null; } } }
/// <summary> /// Adds a child ImportInfo to this ImportInfo. /// </summary> /// <param name="importInfo">The child ImportInfo to add.</param> /// <returns>The added and updated ImportInfo.</returns> public ImportInfo AddChild(ImportInfo importInfo) { Childs.Add(importInfo); importInfo.Parent = this; return(importInfo); }
private static void AddAdjustmentChild(Transaction parent, Transactions availableTransactions, decimal amount , TransactionReason transactionReason, string adjustmentTag) { ImportInfo matcherImportInfo; if (availableTransactions.HasImportInfo(ImportInfoId)) { matcherImportInfo = availableTransactions.GetImportInfo(ImportInfoId); } else { matcherImportInfo = new ImportInfo(ImportInfoId, ImportInfoId, null, null, ImportInfoId, null); //TODO: how can we accomodate manufatured import? } AccountInfo accountInfo = availableTransactions.GetAccountInfo(parent.AccountId); if (amount != 0) { var tx = new Transaction(matcherImportInfo.Id, accountInfo, new Transaction.ImportedValues() { Amount = amount, EntityName = "{0} - {1}".FormatEx(adjustmentTag, parent.EntityName), EntityNameNormalized = "{0} - {1}".FormatEx(adjustmentTag, parent.EntityName), InstituteReference = "{0}.{1}".FormatEx(adjustmentTag, parent.InstituteReference), RequiresParent = true, SubAccountName = parent.SubAccountName, TransactionDate = parent.TransactionDate, TransactionReason = transactionReason, LineNumber = null }); availableTransactions.AddNew(tx, accountInfo, matcherImportInfo, false); availableTransactions.RelateParentChild(parent.Id, tx.Id); } }
public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry()); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); var context = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection); using (var plugin = new GrassCoverErosionInwardsPlugin()) { ImportInfo importInfo = GetImportInfo(plugin); // Call bool isEnabled = importInfo.IsEnabled(context); // Assert Assert.IsTrue(isEnabled); } mocks.VerifyAll(); }
public void CreateFileImporter_Always_ReturnFileImporter() { // Setup var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks); mocks.ReplayAll(); var context = new StabilityPointStructuresCalculationGroupContext(new CalculationGroup(), null, new StabilityPointStructuresFailureMechanism(), assessmentSection); using (var plugin = new StabilityPointStructuresPlugin()) { ImportInfo info = GetImportInfo(plugin); // Call IFileImporter fileImporter = info.CreateFileImporter(context, "test"); // Assert Assert.IsInstanceOf <StabilityPointStructuresCalculationConfigurationImporter>(fileImporter); } mocks.VerifyAll(); }
public void VerifyUpdates_NoProbabilisticCalculations_ReturnsTrue() { // Setup var mocks = new MockRepository(); var inquiryHelper = mocks.StrictMock <IInquiryHelper>(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new SemiProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput() }); var context = new PipingFailureMechanismSectionsContext(failureMechanism, assessmentSection); ImportInfo <PipingFailureMechanismSectionsContext> importInfo = GetImportInfo(inquiryHelper); // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert Assert.IsTrue(updatesVerified); mocks.VerifyAll(); }
private void ImportData() { var info = new ImportInfo { inputFilename = importDataPanel.FullFilename, outputFilename = importDataPanel.GetOutputFilename(), fieldIndex = importDataPanel.fieldDropdown.value, site = importDataPanel.Site, newSiteName = importDataPanel.SiteName, group = importDataPanel.Group, newGroupName = importDataPanel.GroupName, layer = importDataPanel.Layer, newLayerName = importDataPanel.LayerName, newLayerColor = importDataPanel.LayerColor, level = importDataPanel.Level, year = importDataPanel.Year, month = importDataPanel.Month, units = importDataPanel.Units, resolution = importDataPanel.Resolution, needsResampling = importDataPanel.NeedsResampling, metadata = importDataPanel.GetMetadata(), OnFinishImport = OnFinishImport }; InitInfoCategories(info); var dataImporter = new GameObject("DataImporter").AddComponent <DataImporter>(); dataImporter.Import(info); wizardDlg.CloseDialog(DialogAction.Ok); }
public void VerifyUpdates_CalculationWithOutputs_AlwaysReturnsExpectedInquiryMessage(bool isActionConfirmed) { // Setup string expectedInquiryMessage = "Als u een vakindeling importeert, dan worden de resultaten van alle probabilistische piping berekeningen verwijderd." + $"{Environment.NewLine}{Environment.NewLine}Weet u zeker dat u wilt doorgaan?"; var mocks = new MockRepository(); var inquiryHelper = mocks.StrictMock <IInquiryHelper>(); inquiryHelper.Expect(ih => ih.InquireContinuation(expectedInquiryMessage)) .Return(isActionConfirmed); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new PipingFailureMechanism(); var calculationWithOutput = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput); var context = new PipingFailureMechanismSectionsContext(failureMechanism, assessmentSection); ImportInfo <PipingFailureMechanismSectionsContext> importInfo = GetImportInfo(inquiryHelper); // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert Assert.AreEqual(isActionConfirmed, updatesVerified); mocks.VerifyAll(); }
public void IsEnabled_ReferenceLineWithoutGeometry_ReturnFalse() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine()); mocks.ReplayAll(); var failureMechanism = new HeightStructuresFailureMechanism(); var context = new HeightStructuresContext(failureMechanism.HeightStructures, failureMechanism, assessmentSection); using (var plugin = new HeightStructuresPlugin()) { ImportInfo importInfo = GetImportInfo(plugin); // Call bool isEnabled = importInfo.IsEnabled(context); // Assert Assert.IsFalse(isEnabled); } mocks.VerifyAll(); }
/// <summary> /// Imports a mod to the current selected KSP install path. /// </summary> /// <param name="importInfo">The ImportInfo </param> /// <param name="copyDest">Flag to determine if the destination should be copied or if the auto destination detection should be used.</param> /// <param name="addOnly">Flag to determine if the mod should be installed or only added to the ModSelection.</param> private static void ImportMod(ImportInfo importInfo, bool copyDest, bool addOnly) { ModInfo modInfo = importInfo.ModInfo; ModNode addedMod = ModSelectionController.AddMods(new ModInfo[] { modInfo }, false).FirstOrDefault(); if (addedMod != null) { if (copyDest) { // remove all destinations and uncheck all nodes. ModNodeHandler.SetDestinationPaths(addedMod, string.Empty); addedMod._Checked = false; // copy destination UpdateMessage(string.Format(Messages.MSG_COPY_MOD_DESTINATION_0, addedMod.Name)); if (!ModNodeHandler.TryCopyDestToMatchingNodes(importInfo, addedMod)) { UpdateMessage(string.Format(Messages.MSG_COPY_MOD_0_DESTINATION_FAILED, addedMod.Name)); UpdateMessage(string.Format(Messages.MSG_IMPORT_0_FAILED, importInfo.Name), importInfo); return; } } // install the mod. if (!addOnly) { UpdateMessage(string.Format(Messages.MSG_INSTALLING_MOD_0, addedMod.Name)); ModSelectionController.ProcessMods(new ModNode[] { addedMod }); } } else { UpdateMessage(string.Format(Messages.MSG_IMPORT_0_FAILED, importInfo.Name), importInfo); } }
/// <summary> /// Shows the import form and returns the values of the fields to the caller /// </summary> /// <param name="defaultImportSettings">Values to pre-populate the dialog</param> /// <returns>The values selected in the form</returns> public static ImportDialogResult Execute(ImportInfo defaultImportSettings) { lock (_instanceLock) { if (__instance == null) { __instance = new ImportFileForm(); } __instance._importResult = new ImportDialogResult(); __instance._importResult.DialogResult = DialogResult.Cancel; if (defaultImportSettings != null && defaultImportSettings.Parser != null) { SelectBoxItemByText(defaultImportSettings.Parser.Name, __instance._boxParserDll); __instance._importResult.ImportInfo = defaultImportSettings; if (defaultImportSettings.Sender != null) { __instance._checkSender.Visible = true; if ((defaultImportSettings.Parser.ImportSupport & ImportMode.Objects) != 0) { __instance._checkSender.Checked = true; } else { __instance._checkSender.Checked = false; __instance._boxTargetPath.Text = String.Join("|", __instance._importResult.ImportInfo.TargetFiles.ToArray()); } } } __instance.ShowDialog(); } return(__instance._importResult); }
public void VerifyUpdates_CalculationWithoutOutputs_ReturnsTrue() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); var mainWindow = mocks.Stub <IMainWindow>(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.MainWindow).Return(mainWindow); mocks.ReplayAll(); using (var plugin = new HeightStructuresPlugin()) { plugin.Gui = gui; var failureMechanism = new HeightStructuresFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new StructuresCalculation <HeightStructuresInput>()); var structures = new StructureCollection <HeightStructure>(); var context = new HeightStructuresContext(structures, failureMechanism, assessmentSection); ImportInfo importInfo = GetImportInfo(plugin); // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert Assert.IsTrue(updatesVerified); mocks.VerifyAll(); } }
public void CreateFileImporter_Always_ReturnFileImporter() { // Setup var mocks = new MockRepository(); var failureMechanism = mocks.Stub <ICalculatableFailureMechanism>(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine()); mocks.ReplayAll(); var foreshoreProfiles = new ForeshoreProfileCollection(); var importTarget = new ForeshoreProfilesContext(foreshoreProfiles, failureMechanism, assessmentSection); using (var plugin = new RiskeerPlugin()) { ImportInfo importInfo = GetImportInfo(plugin); // Call IFileImporter importer = importInfo.CreateFileImporter(importTarget, "test"); // Assert Assert.IsInstanceOf <ProfilesImporter <ForeshoreProfileCollection> >(importer); } mocks.VerifyAll(); }
public void CreateFileImporter_Always_ReturnFileImporter() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine()); mocks.ReplayAll(); var failureMechanism = new HeightStructuresFailureMechanism(); var importTarget = new HeightStructuresContext(failureMechanism.HeightStructures, failureMechanism, assessmentSection); using (var plugin = new HeightStructuresPlugin()) { ImportInfo importInfo = GetImportInfo(plugin); // Call IFileImporter importer = importInfo.CreateFileImporter(importTarget, "test"); // Assert Assert.IsInstanceOf <HeightStructuresImporter>(importer); } mocks.VerifyAll(); }
public void ImportOn_MultipleSupportedImportInfos_ShowsDialogWithOptions(bool hasFileFilterGenerator) { // Setup const string importInfoAName = "nameA"; var importInfoA = new ImportInfo <object> { Name = importInfoAName, FileFilterGenerator = hasFileFilterGenerator ? new FileFilterGenerator("extensionA") : null }; const string importInfoBName = "nameB"; var importInfoB = new ImportInfo <object> { Name = importInfoBName, FileFilterGenerator = hasFileFilterGenerator ? new FileFilterGenerator("extensionB") : null }; var mockRepository = new MockRepository(); var inquiryHelper = mockRepository.Stub <IInquiryHelper>(); mockRepository.ReplayAll(); var listViewItems = new ListViewItem[0]; DialogBoxHandler = (name, wnd) => { using (new FormTester(name)) { var listView = (ListView) new ControlTester("listViewItemTypes").TheObject; listViewItems = listView.Items.OfType <ListViewItem>().ToArray(); } }; using (var form = new TestViewParentForm()) { var importHandler = new GuiImportHandler(form, Enumerable.Empty <ImportInfo>(), inquiryHelper); // Call importHandler.ImportOn(new object(), new ImportInfo[] { importInfoA, importInfoB }); } // Assert Assert.AreEqual(2, listViewItems.Length); string expectedItemNameA = hasFileFilterGenerator ? $"{importInfoA.Name} (*.{importInfoA.FileFilterGenerator.Extension})" : importInfoA.Name; Assert.AreEqual(expectedItemNameA, listViewItems[0].Name); string expectedItemNameB = hasFileFilterGenerator ? $"{importInfoB.Name} (*.{importInfoB.FileFilterGenerator.Extension})" : importInfoB.Name; Assert.AreEqual(expectedItemNameB, listViewItems[1].Name); mockRepository.VerifyAll(); }
private async Task GetCodeActionsAsync(IDocumentAnalysis analysis, Diagnostic[] diagnostics, Input input, List <CodeAction> codeActions, CancellationToken cancellationToken) { var importFullNameMap = new Dictionary <string, ImportInfo>(); await AddCandidatesFromIndexAsync(analysis, input.Identifier, importFullNameMap, cancellationToken); var interpreter = analysis.Document.Interpreter; var pathResolver = interpreter.ModuleResolution.CurrentPathResolver; // find installed modules matching the given name. this will include submodules var languageVersion = Parsing.PythonLanguageVersionExtensions.ToVersion(interpreter.LanguageVersion); var includeImplicit = !ModulePath.PythonVersionRequiresInitPyFiles(languageVersion); foreach (var moduleFullName in pathResolver.GetAllImportableModulesByName(input.Identifier, includeImplicit)) { cancellationToken.ThrowIfCancellationRequested(); importFullNameMap[moduleFullName] = new ImportInfo(moduleImported: false, memberImported: false, isModule: true); } // find members matching the given name from modules already loaded. var moduleInfo = new ModuleInfo(analysis); foreach (var module in interpreter.ModuleResolution.GetImportedModules(cancellationToken)) { if (module.ModuleType == ModuleType.Unresolved) { continue; } // module name is full module name that you can use in import xxxx directly CollectCandidates(moduleInfo.Reset(module), input.Identifier, importFullNameMap, cancellationToken); Debug.Assert(moduleInfo.NameParts.Count == 1 && moduleInfo.NameParts[0] == module.Name); } // check quick bail out case where we know what module we are looking for if (input.ModuleFullNameOpt != null) { if (importFullNameMap.ContainsKey(input.ModuleFullNameOpt)) { // add code action if the module exist, otherwise, bail out empty codeActions.AddIfNotNull(CreateCodeAction(analysis, input.Context, input.ModuleFullNameOpt, diagnostics, locallyInserted: false, cancellationToken)); } return; } // regular case FilterCandidatesBasedOnContext(analysis, input.Context, importFullNameMap, cancellationToken); // this will create actual code fix with certain orders foreach (var fullName in OrderFullNames(importFullNameMap)) { cancellationToken.ThrowIfCancellationRequested(); codeActions.AddIfNotNull(CreateCodeAction(analysis, input.Context, fullName, diagnostics, locallyInserted: false, cancellationToken)); } }
public void Path_With_Brackets() { var file = @"c:\Program Files(x86)\test\child.cs"; var info = new ImportInfo($"{file.EscapeDirectiveDelimiters()},preserve_main", null); Assert.Equal(file, info.file); Assert.True(info.preserveMain); }
public PageImportViewModel() { ClickImportCommand = new DelegateCommand(new Action(ClickImportExecute)); Info = new ImportInfo(); Info.BtnVisibility = Visibility.Visible; Info.TipsVisibility = Visibility.Hidden; Info.Info = string.Empty; }
public override bool Walk(ImportStatement node) { var iinfo = new ImportInfo("", node.Span); GlobalScope.Imports[node] = iinfo; int len = Math.Min(node.Names.Count, node.AsNames.Count); for (int i = 0; i < len; i++) { var impNode = node.Names[i]; var newName = node.AsNames[i]; var strImpName = impNode.MakeString(); iinfo.Types.Add(new[] { strImpName, newName }); var saveName = (String.IsNullOrEmpty(newName)) ? strImpName : newName; ModuleReference modRef; var def = Scopes[Scopes.Length - 1].CreateVariable(impNode, _unit, saveName); if (!ProjectState.Modules.TryGetValue(strImpName, out modRef)) { var builtinModule = ProjectState.ImportModule(strImpName, impNode.Names.Count > 1 && !String.IsNullOrEmpty(newName)); if (builtinModule != null) { builtinModule.InterpreterModule.Imported(_unit.DeclaringModule.InterpreterContext); def.AddTypes(impNode, _unit, builtinModule.SelfSet); continue; } } if (modRef != null) { if (modRef.Module != null) { ModuleInfo mi = modRef.Module as ModuleInfo; if (mi != null) { mi.ModuleDefinition.AddDependency(_unit); } BuiltinModule builtinModule = modRef.Module as BuiltinModule; if (builtinModule != null) { builtinModule.InterpreterModule.Imported(_unit.DeclaringModule.InterpreterContext); } def.AddTypes(impNode, _unit, modRef.Module.SelfSet); continue; } } else { ProjectState.Modules[strImpName] = modRef = new ModuleReference(); } } return(true); }
public TrafficViewerForm(ImportInfo startupImportInfo, string startupTVF) { InitializeComponent(); _nameAndVersion = String.Format("{0} {1} ({2} {3})", TrafficViewerConstants.APP_NAME, TrafficViewerConstants.VERSION, Resources.Build, TrafficViewerConstants.BUILD); //initialize the progress dialog _progressDialog = new ProgressDialog(); //create a callback to be passed to asyncroneus operations to stop the progress dialog _asyncCallback = new AsyncCallback(BackgroundOperationCallback); //create a new traffic viewer file NewTVF(); //attach a handler to when the user modifies a request to know that the current //traffic data has changed _requestViewer.TrafficView.SaveRequested += new RequestTrafficViewSaveEvent(TrafficViewSaveRequested); //attach stop load command to request list _requestsList.StopLinkClick += new EventHandler(RequestsListOnStopLinkClicked); //points the unpacked folder dialog to the temp folder _dialogFolderBrowser.SelectedPath = Environment.GetEnvironmentVariable("temp"); //initializes the analysis modules menu LoadAnalysisModules(); //initializes the exploiters menu LoadExploiters(); _menuStrip.ExploiterItemClicked += ExploiterItemClicked; //hooks a method to the analysis module click event _menuStrip.AnalysisModuleClicked += new AnalysisModuleClickEvent(MenuStripAnalysisModuleClicked); //hook up to the traffic visualizer click _menuStrip.VisualizeTraffic += new EventHandler(VisualizeTraffic); TrafficViewer.Instance.ExceptionMessageHandler = new ErrorBox(); //search _searchForm = new SearchForm(); _searchForm.SearchIndexChanged += new SearchIndexChangedEvent(SearchIndexChanged); _searchForm.SearchExecuted += new SearchExecutedEvent(SearchExecuted); _searchForm.ReplaceRequestedEvent += new ReplaceEvent(ReplaceRequested); //initialize the request trap with the request trap form //HttpTrap.Instance.RequestTrapped += new RequestTrapEvent(RequestTrapEvent); //HttpTrap.Instance.ResponseTrapped += new RequestTrapEvent(ResponseTrapEvent); HttpTrap.Instance.TrapOn += HttpTrapOn; HttpTrap.Instance.TrapOff += HttpTrapOff; //initialize the arguments, they will be processed on LOAD _startupImportInfo = startupImportInfo; _currentTVFilePath = startupTVF; HttpAuthenticationManager.Instance.CredentialsProvider = new CredentialsForm(this); }
public void Path_With_MainPreserve_CompactArgs() { var file = @"c:\test dir\child.cs"; var info = new ImportInfo($"\"{file}\",preserve_main", null); Assert.Equal(file, info.file); Assert.True(info.preserveMain); }
public void Path_WithSpaces() { var file = @"c:\test dir\child.cs"; var info = new ImportInfo($"\"{file}\"", null); Assert.Equal(file, info.file); Assert.False(info.preserveMain); }
public void Path_Simple() { var file = @"c:\test\child.cs"; var info = new ImportInfo($"{file}", "parent.cs"); Assert.Equal(file, info.file); Assert.False(info.preserveMain); }
/// <summary> /// Gets the ImportInfos from a XmlNode. /// </summary> /// <param name="mod">The XmlNode to get the ImportInfos from.</param> /// <returns>The ImportInfos from a XmlNode.</returns> private static ImportInfo GetImportInfo(XmlNode mod) { ImportInfo importInfo = new ImportInfo(); if (mod.Attributes == null) { return(null); } foreach (XmlAttribute att in mod.Attributes) { if (att.Name == Constants.KEY) { importInfo.LocalPath = att.Value; } else if (att.Name == Constants.NAME) { importInfo.Name = att.Value; } else if (att.Name == Constants.VERSIONCONTROLERNAME) { importInfo.SiteHandlerName = att.Value; } else if (att.Name == Constants.PRODUCTID) { importInfo.ProductID = att.Value; } else if (att.Name == Constants.MODURL) { importInfo.ModURL = att.Value; } else if (att.Name == Constants.FORUMURL) { importInfo.AdditionalURL = att.Value; } else if (att.Name == Constants.ISFILE) { importInfo.IsFile = (att.Value == ONE); } else if (att.Name == Constants.INSTALL) { importInfo.Install = (att.Value == ONE); } else if (att.Name == Constants.INSTALLDIR) { importInfo.InstallDir = att.Value; } } foreach (XmlNode child in mod.ChildNodes) { importInfo.AddChild(GetImportInfo(child)); } return(importInfo); }
public override bool Walk(FromImportStatement node) { ModuleReference moduleRef; Namespace userMod = null; var modName = node.Root.MakeString(); if (!ProjectState.Modules.TryGetValue(modName, out moduleRef)) { userMod = ProjectState.ImportModule(modName); } if (moduleRef != null) { userMod = moduleRef.Module; } else if (userMod == null) { moduleRef = ProjectState.Modules[modName] = new ModuleReference(); } var asNames = node.AsNames ?? node.Names; var impInfo = new ImportInfo(node.Root.MakeString(), node.Span); GlobalScope.Imports[node] = impInfo; int len = Math.Min(node.Names.Count, asNames.Count); for (int i = 0; i < len; i++) { var impName = node.Names[i]; var newName = asNames[i]; if (impName == null) { // incomplete import statement continue; } else if (impName == "*") { // Handle "import *" if (userMod != null) { foreach (var varName in GetModuleKeys(userMod)) { WalkFromImportWorker(node, userMod, varName, null); } } } else { WalkFromImportWorker(node, userMod, impName, newName); } } return(true); }
/// <summary> /// Starts an asyncroneus import operation /// </summary> /// <param name="parser"></param> /// <param name="pathsToFilesToImport"></param> /// <param name="options"></param> /// <param name="callback"></param> public void BeginImport(ITrafficParser parser, List <string> pathsToFilesToImport, ParsingOptions options, AsyncCallback callback) { ImportInfo info = new ImportInfo(); info.Parser = parser; info.TargetFiles = pathsToFilesToImport; info.Profile = options; BeginImport(info, callback); }
/// <summary> /// Starts an asyncroneus import operation /// </summary> /// <param name="parser"></param> /// <param name="sender"></param> /// <param name="options"></param> /// <param name="callback"></param> public void BeginImport(ITrafficParser parser, object sender, ParsingOptions options, AsyncCallback callback) { ImportInfo info = new ImportInfo(); info.Parser = parser; info.Sender = sender; info.Profile = options; BeginImport(info, callback); }
public void VerifyUpdates_CalculationWithOutputs_AlwaysReturnsExpectedInquiryMessage(bool isActionConfirmed) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); var mainWindow = mocks.Stub <IMainWindow>(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.MainWindow).Return(mainWindow); mocks.ReplayAll(); using (var plugin = new GrassCoverErosionInwardsPlugin()) { plugin.Gui = gui; var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation { Output = new TestGrassCoverErosionInwardsOutput() }); var dikeProfiles = new DikeProfileCollection(); var context = new DikeProfilesContext(dikeProfiles, failureMechanism, assessmentSection); ImportInfo importInfo = GetImportInfo(plugin); string textBoxMessage = null; DialogBoxHandler = (name, wnd) => { var helper = new MessageBoxTester(wnd); textBoxMessage = helper.Text; if (isActionConfirmed) { helper.ClickOk(); } else { helper.ClickCancel(); } }; // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert string expectedInquiryMessage = "Als u dijkprofielen importeert, " + "dan worden alle rekenresultaten van dit faalmechanisme " + $"verwijderd.{Environment.NewLine}{Environment.NewLine}Weet u zeker dat u wilt doorgaan?"; Assert.AreEqual(expectedInquiryMessage, textBoxMessage); Assert.AreEqual(isActionConfirmed, updatesVerified); mocks.VerifyAll(); } }
public void ImportOn(object target, IEnumerable <ImportInfo> supportedImportInfos) { ImportInfo importInfo = SelectImportInfo(target, supportedImportInfos.ToArray()); if (importInfo == null) { return; } ImportItemsUsingDialog(importInfo, target); }
private static bool AreCompatible(ImportInfo import, ExportInfo export) { if (!import.Options.IncludeNamedExportsFromUnnamedImports && export.Name != null && import.Name == null) { return(false); } return(export.Name == import.Name || import.Name == null); }
/// <summary> /// Builds ASymbol. /// </summary> /// <param name="shape">The shape of the AType.</param> /// <param name="symbolLengths">The lengths of the ASymbols contained by the AType.</param> /// <param name="info">The class containing the informations for importing.</param> /// <returns></returns> private AType BuildSymbolArray(List<int> shape, IEnumerable<int> symbolLengths, ImportInfo info) { AType result = Utils.ANull(); if (shape.Count == 0) { StringBuilder toSymbol = new StringBuilder(); int length = symbolLengths.First(); for (int i = 0; i < length; i++) { toSymbol.Append((char)info.Data[info.DataIndex]); info.DataIndex++; } result = ASymbol.Create(toSymbol.ToString()); } else { List<int> nextShape = (shape.Count > 1) ? shape.GetRange(1, shape.Count - 1) : new List<int>(); int subDimensionLength = nextShape.Product(); for (int i = 0; i < shape[0]; i++) { IEnumerable<int> nextSymbolLengths = symbolLengths.Skip(i * subDimensionLength).Take(subDimensionLength); result.Add(BuildSymbolArray(nextShape, nextSymbolLengths, info)); // advance the bytestream further. } } return result; }
/// <summary> /// Imports an AType from a byte array. /// </summary> /// <param name="argument">The byte array.</param> /// <returns>The AType created from the byte array.</returns> public AType Import(byte[] argument) { if (argument.Length < HeaderStartIndex || argument[0] != CDRConstants.CDRFlag) { throw new Error.Domain("sys.imp"); } ImportInfo info = new ImportInfo(argument) { HeaderIndex = HeaderStartIndex }; // the first 4 byte of the header contains the cdr flag, plus the length of the message. byte[] headerByteLength = { 0, argument[1], argument[2], argument[3] }; int headerLength = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(headerByteLength, 0)); info.DataIndex = headerLength; return ExtractItems(info); }
/// <summary> /// Creates a new import using the specified import info /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='collectionName'> /// The workspace collection name /// </param> /// <param name='workspaceId'> /// The workspace id /// </param> /// <param name='datasetDisplayName'> /// The display name of the dataset /// </param> /// <param name='importInfo'> /// The import to post /// </param> /// <param name='nameConflict'> /// Determines what to do if a dataset with the same name already exists /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task<Import> PostImportAsync(this IImports operations, string collectionName, string workspaceId, string datasetDisplayName, ImportInfo importInfo, string nameConflict = default(string), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.PostImportWithHttpMessagesAsync(collectionName, workspaceId, datasetDisplayName, importInfo, nameConflict, null, cancellationToken).ConfigureAwait(false)) { return _result.Body; } }
public ActionResult SaveNewProduct(ImportInfo info) { ImportInfoList list = ImportInfoList.NewProductImportInfoList(); list.Add(info); ImportWizard.ImportProductList(list); Product product = Product.GetProductByName(string.Empty); return this.Direct(new {}); }
void TryImportDraggedClips() { int i; ImportInfo info; for( i = 0; i < _draggedClips.Count; i++ ) { info = new ImportInfo( _draggedClips[ i ] ); if( _soundBank.Contains( info.GUID ) ) { EditorGUIUtility.PingObject( info.Clip ); if( EditorUtility.DisplayDialog( "Cannot Import", string.Format( "AudioClip {0} is already in Sound Bank!", info.Clip.name ), "Skip", "Cancel" ) ) { continue; } else return; } else { if( info.PathInResources == null ) { EditorGUIUtility.PingObject( info.Clip ); if( EditorUtility.DisplayDialog( "Cannot Import", string.Format( "Cannot import AudioClip {0}, it is not in a Resources folder.", info.Clip.name ), "Skip", "Cancel" ) ) { continue; } else return; } #if UNITY_5 AudioImporterSampleSettings sampleSettings = info.Importer.defaultSampleSettings; if( sampleSettings.loadType != AudioClipLoadType.DecompressOnLoad ) { EditorGUIUtility.PingObject( info.Clip ); if( EditorUtility.DisplayDialog( "Cannot Import", string.Format( "AudioClip {0}'s load type import settings should be set to * load into memory *.", info.Clip.name ), "Fix", "Cancel" ) ) { sampleSettings.loadType = AudioClipLoadType.DecompressOnLoad; info.Importer.defaultSampleSettings = sampleSettings; } else return; } #else if( info.Importer.format == AudioImporterFormat.Native ) { if( info.Importer.loadType == AudioImporterLoadType.StreamFromDisc ) { EditorGUIUtility.PingObject( info.Clip ); if( EditorUtility.DisplayDialog( "Cannot Import", string.Format( "AudioClip {0}'s load type import settings should be set to * load into memory *.", info.Clip.name ), "Fix", "Cancel" ) ) { info.Importer.loadType = AudioImporterLoadType.DecompressOnLoad; } else return; } } else if( info.Importer.loadType != AudioImporterLoadType.DecompressOnLoad ) { EditorGUIUtility.PingObject( info.Clip ); if( EditorUtility.DisplayDialog( "Cannot Import", string.Format( "AudioClip {0}'s load type import settings should be set to * decompress on load *.", info.Clip.name ), "Fix", "Cancel" ) ) { info.Importer.loadType = AudioImporterLoadType.DecompressOnLoad; } else return; } #endif if( info.Clip.frequency != _soundBank.SampleRate ) { EditorGUIUtility.PingObject( info.Clip ); if( EditorUtility.DisplayDialog( "Cannot Import", string.Format( "AudioClip {0}'s sample rate does not match the Sound Bank's.", info.Clip.name ), "Skip", "Cancel" ) ) { continue; } else return; } } _soundBank.AddSample( info.PathInResources, info.GUID, info.Clip.channels, info.Clip.samples, info.IsStreamingAsset ); //AssetDatabase.ImportAsset( info.Path ); } EditorUtility.SetDirty( _soundBank ); _draggedClips.Clear(); }
/// <summary> /// Builds a box/boxarray. /// </summary> /// <param name="shape">The shape of the AType.</param> /// <param name="info">The class containing the informations for importing.</param> /// <returns></returns> private AType BuildBox(List<int> shape, ImportInfo info) { AType result; if (shape.Count == 0) { result = ABox.Create(ExtractItems(info)); } else { List<int> subshape = shape.GetRange(1, shape.Count - 1); result = AArray.Create(ATypes.ABox); for (int i = 0; i < shape[0]; i++) { result.Add(BuildBox(subshape, info)); } } return result; }
/// <summary> /// Gets the ImportInfos from a XmlNode. /// </summary> /// <param name="mod">The XmlNode to get the ImportInfos from.</param> /// <returns>The ImportInfos from a XmlNode.</returns> private static ImportInfo GetImportInfo(XmlNode mod) { ImportInfo importInfo = new ImportInfo(); if (mod.Attributes == null) return null; foreach (XmlAttribute att in mod.Attributes) { if (att.Name == Constants.KEY) importInfo.LocalPath = att.Value; else if (att.Name == Constants.NAME) importInfo.Name = att.Value; else if (att.Name == Constants.VERSIONCONTROLERNAME) importInfo.SiteHandlerName = att.Value; else if (att.Name == Constants.PRODUCTID) importInfo.ProductID = att.Value; else if (att.Name == Constants.MODURL) importInfo.ModURL = att.Value; else if (att.Name == Constants.FORUMURL) importInfo.AdditionalURL = att.Value; else if (att.Name == Constants.ISFILE) importInfo.IsFile = (att.Value == ONE); else if (att.Name == Constants.INSTALL) importInfo.Install = (att.Value == ONE); else if (att.Name == Constants.INSTALLDIR) importInfo.InstallDir = att.Value; } foreach (XmlNode child in mod.ChildNodes) importInfo.AddChild(GetImportInfo(child)); return importInfo; }
/// <summary> /// Gets the ModInfo from a ImportInfo class. /// </summary> /// <param name="importInfo">The ImportInfo class to get the ModInfos from.</param> /// <returns>The ModInfo from a ImportInfo class.</returns> private static ModInfo GetModInfo(ImportInfo importInfo) { ModInfo modInfo = new ModInfo(); if (importInfo.ModInfo != null) modInfo = importInfo.ModInfo; else { modInfo.ModURL = importInfo.ModURL; modInfo.AdditionalURL = importInfo.AdditionalURL; modInfo.LocalPath = importInfo.LocalPath; modInfo.Name = importInfo.Name; modInfo.ProductID = importInfo.ProductID; modInfo.SiteHandlerName = importInfo.SiteHandlerName; } return modInfo; }
/// <summary> /// Imports a mod to the current selected KSP install path. /// </summary> /// <param name="importInfo">The ImportInfo </param> /// <param name="copyDest">Flag to determine if the destination should be copied or if the auto destination detection should be used.</param> /// <param name="addOnly">Flag to determine if the mod should be installed or only added to the ModSelection.</param> private static void ImportMod(ImportInfo importInfo, bool copyDest, bool addOnly) { ModInfo modInfo = importInfo.ModInfo; ModNode addedMod = ModSelectionController.AddMods(new ModInfo[] { modInfo }, false).FirstOrDefault(); if (addedMod != null) { if (copyDest) { // remove all destinations and uncheck all nodes. ModNodeHandler.SetDestinationPaths(addedMod, string.Empty); addedMod._Checked = false; // copy destination UpdateMessage(string.Format(Messages.MSG_COPY_MOD_DESTINATION_0, addedMod.Name)); if (!ModNodeHandler.TryCopyDestToMatchingNodes(importInfo, addedMod)) { UpdateMessage(string.Format(Messages.MSG_COPY_MOD_0_DESTINATION_FAILED, addedMod.Name)); UpdateMessage(string.Format(Messages.MSG_IMPORT_0_FAILED, importInfo.Name), importInfo); return; } } // install the mod. if (!addOnly) { UpdateMessage(string.Format(Messages.MSG_INSTALLING_MOD_0, addedMod.Name)); ModSelectionController.ProcessMods(new ModNode[] { addedMod }); } } else { UpdateMessage(string.Format(Messages.MSG_IMPORT_0_FAILED, importInfo.Name), importInfo); } }
/// <summary> /// Determines the lengths of the ASymbols to build, and then calls BuildSymbolArray to build it. /// </summary> /// <param name="shape">The shape of the AType.</param> /// <param name="info">The class containing the informations for importing.</param> /// <returns></returns> private AType BuildSymbol(List<int> shape, ImportInfo info) { int numberOfSymbols = shape.Product(); int totalLength = 0; List<int> symbolLengths = new List<int>(); for (int i = 0; i < numberOfSymbols; i++) { // because of the structure of the CDR type descriptor int actualLength = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(info.Data, info.HeaderIndex)); info.HeaderIndex += ASymbolDescriptorLength; totalLength += actualLength; symbolLengths.Add(actualLength); } AType result = BuildSymbolArray(shape, symbolLengths, info); return result; }
/// <summary> /// Adds a child ImportInfo to this ImportInfo. /// </summary> /// <param name="importInfo">The child ImportInfo to add.</param> /// <returns>The added and updated ImportInfo.</returns> public ImportInfo AddChild(ImportInfo importInfo) { Childs.Add(importInfo); importInfo.Parent = this; return importInfo; }
/// <summary> /// Downloads the mod from ModURL. /// </summary> /// <param name="importInfo">The ImportInfo of the mod to download.</param> /// <returns>True if download was successful, otherwise false.</returns> private static bool DownloadMod(ref ImportInfo importInfo) { ISiteHandler siteHandler = importInfo.SiteHandler; if (siteHandler != null) { ModInfo modInfo = siteHandler.GetModInfo(importInfo.ModURL); importInfo.DownloadSuccessfull = siteHandler.DownloadMod(ref modInfo); importInfo.ModInfo = modInfo; } return importInfo.DownloadSuccessfull; }
/// <summary> /// Creates a new import using the specified import info /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='collectionName'> /// The workspace collection name /// </param> /// <param name='workspaceId'> /// The workspace id /// </param> /// <param name='datasetDisplayName'> /// The display name of the dataset /// </param> /// <param name='importInfo'> /// The import to post /// </param> /// <param name='nameConflict'> /// Determines what to do if a dataset with the same name already exists /// </param> public static Import PostImport(this IImports operations, string collectionName, string workspaceId, string datasetDisplayName, ImportInfo importInfo, string nameConflict = default(string)) { return Task.Factory.StartNew(s => ((IImports)s).PostImportAsync(collectionName, workspaceId, datasetDisplayName, importInfo, nameConflict), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult(); }
protected override void OnError(string message, Exception exception, ImportInfo import) { BackgroundErrorLogger.Log(exception, "Static Dependency Injection - " + message, "Rock.Core", "ImportInfo:\r\n" + import); base.OnError(message, exception, import); }
/// <summary> /// Extract the AType elements from the header and the data. /// </summary> /// <param name="info">The class containing the informations for importing.</param> /// <returns>The AType created from the import informations.</returns> private AType ExtractItems(ImportInfo info) { AType result; List<int> shape = new List<int>(); // The format of the CDR type descriptor int count = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(info.Data, info.HeaderIndex)); info.HeaderIndex += SizeOfCount; short typeCode = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(info.Data, info.HeaderIndex)); info.HeaderIndex += SizeOfType; short rank = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(info.Data, info.HeaderIndex)); info.HeaderIndex += SizeOfRank; for (short i = 0; i < rank; i++) { shape.Add(IPAddress.NetworkToHostOrder(BitConverter.ToInt32(info.Data, info.HeaderIndex))); info.HeaderIndex += SizeOfShape; } if (typeCode == CDRConstants.CDRBoxShort) { if (count == 0) { // if an item is ANull, the header contains 20 bytes (more in CDR spec) result = Utils.ANull(); info.HeaderIndex += ANullDescriptorLength; } else { short nestedType = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(info.Data, info.HeaderIndex + 4)); // `sym is always boxed (see more in CDR spec) if (nestedType == CDRConstants.CDRSymShort) { result = BuildSymbol(shape, info); } else { result = BuildBox(shape, info); } } } else if (typeCode == CDRConstants.CDRSymShort) { result = BuildSymbol(shape, info); } else { int length = shape.Product(); ATypes type; if (CDRConstants.IntegerTypes.Contains(typeCode)) { length *= sizeof(Int32); type = ATypes.AInteger; } else if (CDRConstants.FloatTypes.Contains(typeCode)) { length *= sizeof(Double); type = ATypes.AFloat; } else if (typeCode == CDRConstants.CDRCharShort) { length *= sizeof(Char) / 2; // sizeof(Char) == 2 in C# type = ATypes.AChar; } else { throw new Error.Domain("sys.imp"); } byte[] data = info.Data; result = ATypeConverter.Instance.BuildArray(shape, ref data, type, info.DataIndex); info.DataIndex += length; } return result; }