/// <summary> /// Initializes a new instance of the <see cref="TtsEspHelper"/> class. /// </summary> /// <param name="language">Language.</param> /// <param name="voicePath">Voice font path.</param> /// <param name="langDllPath">Language dll path.</param> /// <param name="langDataPath">Language data path.</param> /// <param name="mode">Process mode.</param> public TtsEspHelper(Language language, string voicePath, string langDllPath, string langDataPath, ProcessMode mode) { if (string.IsNullOrEmpty(voicePath)) { voicePath = null; } if (string.IsNullOrEmpty(langDllPath)) { langDllPath = null; } if (string.IsNullOrEmpty(langDataPath)) { langDataPath = null; } _language = language; if (string.IsNullOrEmpty(langDllPath) && string.IsNullOrEmpty(langDataPath)) { _engine = new SP.TtsEngine((SP.Language)language, voicePath); } else if (string.IsNullOrEmpty(langDataPath)) { _engine = new SP.TtsEngine((SP.Language)language, voicePath, langDllPath); } else { _engine = new SP.TtsEngine((SP.Language)language, voicePath, langDllPath, langDataPath); } _mode = mode; }
private void SetDefaultValues() { this.ExecutionMode = ProcessMode.GuidMode; this.ServerIP = "192.168.3.169"; this.TransferMode = TransMode.HTTP; this.PortNumber = "8080"; }
public IProcessor CreateProcessor(ProcessMode mode) { IProcessor processor; switch (mode) { case ProcessMode.compress: { processor = new Compressor(); break; } case ProcessMode.decompress: { processor = new Decompressor(); break; } default: { throw new Exception("Неверный режим работы программы!"); } } return(processor); }
public void JobProcessStress_3(ProcessMode mode) { var archetype = m_Manager.CreateArchetype(typeof(EcsTestData), typeof(EcsTestData2), typeof(EcsTestData3)); var entities = new NativeArray <Entity>(StressTestEntityCount, Allocator.Temp); m_Manager.CreateEntity(archetype, entities); for (int i = 0; i < entities.Length; i++) { m_Manager.SetComponentData(entities[i], new EcsTestData(i)); } Schedule <Process3>(mode); for (int i = 0; i < entities.Length; i++) { Assert.AreEqual(0, m_Manager.GetComponentData <EcsTestData2>(entities[i]).value0); Assert.AreEqual(0, m_Manager.GetComponentData <EcsTestData3>(entities[i]).value0); Assert.AreEqual(0, m_Manager.GetComponentData <EcsTestData3>(entities[i]).value1); Assert.AreEqual(i, m_Manager.GetComponentData <EcsTestData2>(entities[i]).value1); Assert.AreEqual(i, m_Manager.GetComponentData <EcsTestData3>(entities[i]).value2); } entities.Dispose(); }
void DimentionAnalyse() { var control = new DimentionAnalyseControl(); var vm = new DimentionAnalyseControlViewModel() { IsBusy = true }; control.DataContext = vm; OpenView("Dimention Analyse(" + ProcessMode.ToString() + "):" + GetHeader(), control); Task.Factory.StartNew(() => { try { Save(); var rl = TargetObject.GetDimentionAnalyse(); App.Current.Dispatcher.Invoke(() => { vm.LoadData(rl); }); } catch (Exception ex) { LogSupport.Error(ex); } }).ContinueWith((t) => { vm.IsBusy = false; }); }
void Surface() { var control = new SurfaceControl(); var vm = new SurfaceControlViewModel() { IsBusy = true }; control.DataContext = vm; OpenView("3 Matrix Analyse(" + ProcessMode.ToString() + "):" + GetHeader(), control); Task.Factory.StartNew(() => { try { Save(); Dictionary <string, List <Tuple <double, double, double> > > rl = TargetObject.Get3DCurve(); App.Current.Dispatcher.Invoke(() => { vm.LoadData(rl); }); } catch (Exception ex) { LogSupport.Error(ex); } }).ContinueWith((t) => { vm.IsBusy = false; }); }
void TimeTrend() { if (!CanStart()) { return; } var control = new DistributeTrendControl(); var vm = control.DataContext as DistributeTrendViewModel; vm.IsTimeMode = true; OpenView("Trend Time(" + ProcessMode.ToString() + "):" + GetHeader(), control); Task.Factory.StartNew(() => { Save(); var ml = TargetObject.GetMarketDataList(); var tl = TargetObject.GetDistributeTrendByTime(ml); App.Current.Dispatcher.Invoke(() => { vm.LoadData(tl); }); }).ContinueWith((t) => { vm.IsBusy = false; }); }
public NodeScheduler(ProcessMode mode) { ProcessMode = mode; SetProcess(ProcessMode == ProcessMode.Idle); SetPhysicsProcess(ProcessMode == ProcessMode.Physics); }
private void SetLogEntryProperties(Net.Logging.LogEvent entry) { entry.User = CurrentUser.UserName; entry.Computer = ClientIpAddress; entry.Source = ClientApplicationName; entry.Category = ProcessMode.ToString(); }
void MarketSurface() { if (!CanStart()) { return; } var control = new DistributeSurfaceControl(); var vm = new DistributeSurfaceViewModel() { IsBusy = true }; control.DataContext = vm; OpenView("Trend Market(" + ProcessMode.ToString() + "):" + GetHeader(), control); Task.Factory.StartNew(() => { try { Save(); var ml = TargetObject.GetMarketDataList(); var tl = TargetObject.GetDistributeTrendByMarket(ml); App.Current.Dispatcher.Invoke(() => { vm.LoadData(tl); }); } catch (Exception ex) { LogSupport.Error(ex); } }).ContinueWith((t) => { vm.IsBusy = false; }); }
public override int GetHashCode() { int hash = 1; if (Id.Length != 0) { hash ^= Id.GetHashCode(); } if (Name.Length != 0) { hash ^= Name.GetHashCode(); } hash ^= interactions_.GetHashCode(); hash ^= ioMappings_.GetHashCode(); hash ^= tags_.GetHashCode(); if (Description.Length != 0) { hash ^= Description.GetHashCode(); } hash ^= authors_.GetHashCode(); if (ProcessMode != 0) { hash ^= ProcessMode.GetHashCode(); } if (Status != 0) { hash ^= Status.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public void Process(ProcessMode processMode, AnimationClip prioritize, EePreviewAvatar previewSetup) { var clipDictionary = GatherAnimations(processMode); var animationPreviews = ToPrioritizedList(clipDictionary, prioritize); _eeRenderingCommands.GenerateSpecific(animationPreviews, previewSetup); }
private void GetSelected(ProcessMode process) { if (!GetActiveSchoolYear()) { return; } GridView gridView = ListGridControl.FocusedView as GridView; if (gridView == null) { return; } object item = gridView.GetRow(gridView.FocusedRowHandle); campaignGroupBl.MapToViewModel(item); if (process == ProcessMode.Update) { CampaignGroupEditForm editForm = new CampaignGroupEditForm(campaignGroupBl); editForm.ShowDialog(); RefreshWhenChanged(); } else if (process == ProcessMode.Delete) { CampaignGroupDeleteForm deleteForm = new CampaignGroupDeleteForm(campaignGroupBl); deleteForm.ShowDialog(); campaignGroupBl.ResetVmParams(); RefreshWhenChanged(); } //todo create roster management con //todo close this //todo show roster management con }
public SimpleStreamNode(ProcessMode mode, Stream stream) { this.ThreadMainLock = new object(); this.ThreadReadLock = new object(); this.ThreadWriteLock = new object(); this.QueueSyncRoot = new object(); this.ProcessSyncRoot = new object(); this.OpenedWaitHandle = new StateWaitHandle(true, () => this.Connected == true); this.ClosedWaitHandle = new StateWaitHandle(false, () => this.Connected == false); this.Mode = mode; this.BaseStream = stream; this.ThreadMain = null; this.ThreadRead = null; this.ThreadWrite = null; this.Running = false; this.Closing = false; this.Stopping = false; this.Connected = false; this.Queue = new List <PacketOperation <T> >(); this.QueueResetEvent = new ManualResetEventSlim(); }
public void Process(int[] instructions) { State = instructions.ToArray(); for (_pointer = 0, _isProcessing = true; _isProcessing;) { var paramCodeString = ParamCode.ToString().PadLeft(5, Convert.ToChar("0")); var paramCodeArray = paramCodeString.ToArray(); _paramModes = new ProcessMode[3]; string lastTwoFromParamCode = paramCodeArray[3] + paramCodeArray[4].ToString(); _paramModes[0] = GetProcessModeForParam(paramCodeArray[2]); _paramModes[1] = GetProcessModeForParam(paramCodeArray[1]); _paramModes[2] = GetProcessModeForParam(paramCodeArray[0]); var opCode = Int32.Parse(lastTwoFromParamCode); if (_operations.ContainsKey(opCode)) { _operations[opCode](); } else { throw new Exception($"{opCode} OpCode Not Found"); } } }
public static IScheduler GetScheduler([NotNull] this Node node, ProcessMode mode) { Ensure.Any.IsNotNull(node, nameof(node)); IScheduler scheduler; switch (mode) { case ProcessMode.Physics: scheduler = GetPhysicsScheduler(node); break; case ProcessMode.Idle: scheduler = GetIdleScheduler(node); break; case ProcessMode.Disable: scheduler = null; break; default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); } return(scheduler); }
public void AllExportXml() { if (Directory.Exists(m_Window.SettingUI.XmlExportDirectory)) { Directory.Delete(m_Window.SettingUI.XmlExportDirectory, true); AssetDatabase.Refresh(); } if (!Directory.Exists(m_Window.SettingUI.XmlExportDirectory)) { Directory.CreateDirectory(m_Window.SettingUI.XmlExportDirectory); AssetDatabase.Refresh(); } m_ExportProcessMode = ProcessMode.AllExportXml; m_ProcessResults.Clear(); m_ShowCount = 0; m_ProcessResults.Add("###<color=#ffffff>导出Excel为Xml文件</color>"); if (m_ProcessThread != null) { m_ProcessThread.Abort(); m_ProcessThread = null; } m_ProcessThread = new Thread(ExportXmlProcess); m_ProcessThread.Start(); }
private void rbCommandMode_Checked(object sender, RoutedEventArgs e) { RadioButton rb = (sender as RadioButton); switch (rb.Name) { case "rbDefault": processMode = ProcessMode.Default; break; case "rbShotAt": processMode = ProcessMode.ShotAt; break; case "rbCreatedAt": processMode = ProcessMode.CreatedAt; break; case "rbUpdateAt": processMode = ProcessMode.UpdatedAt; break; default: break; } }
private void GetSelected(ProcessMode process) { GridView gridView = ListGridControl.FocusedView as GridView; if (gridView == null) { return; } object item = gridView.GetRow(gridView.FocusedRowHandle); sectionBl.MapToViewModel(item); if (process == ProcessMode.Update) { SectionEditForm editForm = new SectionEditForm(sectionBl); editForm.ShowDialog(); RefreshWhenChanged(); } else { SectionDeleteForm deleteForm = new SectionDeleteForm(sectionBl); deleteForm.ShowDialog(); sectionBl.ResetVmParams(); RefreshWhenChanged(); } }
public SampleAttribute( string key, string displayName, Option <string> description, Option <Texture> icon, string target, TimeSpan period, ProcessMode processMode, ITimeSource timeSource, Map <string, IAttribute> children, bool active, ILoggerFactory loggerFactory) : base( key, displayName, description, icon, target, false, children, active, loggerFactory) { Ensure.That(timeSource, nameof(timeSource)).IsNotNull(); Period = period; ProcessMode = processMode; TimeSource = timeSource; }
public AnimationStateManager( AnimationPlayer player, AnimationTree animationTree, Option <IAnimationGraphFactory> graphFactory, Option <IAnimationControlFactory> controlFactory, ProcessMode processMode, ITimeSource timeSource, bool active, ILoggerFactory loggerFactory) : base(player, processMode, timeSource, active, loggerFactory) { Ensure.That(animationTree, nameof(animationTree)).IsNotNull(); AnimationTree = animationTree; GraphFactory = graphFactory.IfNone(() => new AnimationGraphFactory()); ControlFactory = controlFactory.IfNone(() => new AnimationControlFactory()); Context = new AnimationGraphContext( Player, AnimationTree, OnAdvance, GraphFactory, ControlFactory, loggerFactory); _graph = GraphFactory.TryCreate((AnimationRootNode)AnimationTree.TreeRoot, Context).IfNone(() => throw new ArgumentException( "Failed to create animation graph from the specified animation tree.", nameof(animationTree))); AnimationTree.ProcessMode = AnimationTree.AnimationProcessMode.Manual; this.LogDebug("Using graph factory: {}.", GraphFactory); this.LogDebug("Using control factory: {}.", ControlFactory); }
public async Task ProcessAsync(ProcessMode processMode, CancellationToken token) { var start = await _cursorService.GetValueAsync(_processor.CursorName); var end = await _cursorService.GetMinimumAsync(_processor.DependencyCursorNames); int commitCount; do { var commits = await _enumerator.GetCommitsAsync( start, end, _processor.BatchSize); var entityCount = commits.Sum(x => x.Entities.Count); commitCount = commits.Count; if (commits.Any()) { var min = commits.Min(x => x.CommitTimestamp); var max = commits.Max(x => x.CommitTimestamp); start = max; _logger.LogInformation( "Fetched {CommitCount} commits ({EntityCount} {EntityName}) between {Min:O} and {Max:O}.", commitCount, entityCount, typeof(TEntity).Name, min, max); } else { _logger.LogInformation("No more commits were found within the bounds."); } switch (processMode) { case ProcessMode.Sequentially: await ProcessSequentiallyAsync(commits, token); break; case ProcessMode.TaskQueue: await ProcessTaskQueueAsync(commits, token); break; default: throw new NotImplementedException(); } if (commits.Any()) { _logger.LogInformation("Cursor {CursorName} moving to {Start:O}.", _processor.CursorName, start); await _cursorService.SetValueAsync(_processor.CursorName, start); } }while (commitCount > 0); }
public Parameters(string[] args) { Validation(args); Mode = (ProcessMode)Enum.Parse(typeof(ProcessMode), args[0]); PathToSourceFile = args[1]; PathToResultFile = args[2]; }
public void JobProcessStress_4_WithEntity(ProcessMode mode, [Values(0, 1, 1000)] int entityCount) { var entities = PrepareData(entityCount); Schedule <Process4Entity>(mode); CheckResultsAndDispose(entities, 4, true); }
public ProcessManager(string inputFile, string outputFile, ProcessMode mode) { m_inputFile = inputFile; m_outputFile = outputFile; m_processMode = mode; m_compressor = new Compressors.GZipCompressor(); InitializePlan(); }
public void JobProcessStress_3(ProcessMode mode, [Values(0, 1, 1000)] int entityCount) { var entities = PrepareData(entityCount); Schedule <Process3>(mode); CheckResultsAndDispose(entities, 3, false); }
/// <summary> /// Initializes a new instance of the <see cref="TtsEspHelper"/> class. /// </summary> /// <param name="serviceProvider">ServiceProvider.</param> /// <param name="language">Language.</param> /// <param name="mode">Process mode.</param> public TtsEspHelper(SP.ServiceProvider serviceProvider, Language language, ProcessMode mode) { Helper.ThrowIfNull(serviceProvider); _serviceProvider = serviceProvider; _engine = serviceProvider.Engine; _language = language; _mode = mode; }
public void JobProcessMixedStress_6([Values] CallMode call, [Values] ProcessMode mode, [Values(0, 1, 1000)] int entityCount) { var archetype = m_Manager.CreateArchetype(typeof(EcsIntElement), typeof(EcsIntElement2), typeof(EcsIntElement3), typeof(EcsTestData), typeof(EcsTestData2), typeof(EcsTestData3)); var entities = new NativeArray <Entity>(entityCount, Allocator.Temp); m_Manager.CreateEntity(archetype, entities); if (call == CallMode.System) { if (mode == ProcessMode.Parallel) { (new Process6Mixed()).Schedule(EmptySystem).Complete(); } else if (mode == ProcessMode.Run) { (new Process6Mixed()).Run(EmptySystem); } else { (new Process6Mixed()).ScheduleSingle(EmptySystem).Complete(); } } else { var query = m_Manager.CreateEntityQuery(typeof(EcsIntElement), typeof(EcsIntElement2), typeof(EcsIntElement3), typeof(EcsTestData), typeof(EcsTestData2), typeof(EcsTestData3)); if (mode == ProcessMode.Parallel) { (new Process6Mixed()).Schedule(query).Complete(); } else if (mode == ProcessMode.Run) { (new Process6Mixed()).Run(query); } else { (new Process6Mixed()).ScheduleSingle(query).Complete(); } } for (int i = 0; i < entities.Length; i++) { { var expectedResult = 1; Assert.AreEqual(expectedResult, m_Manager.GetBuffer <EcsIntElement>(entities[i]).Length); Assert.AreEqual(expectedResult, m_Manager.GetBuffer <EcsIntElement2>(entities[i]).Length); Assert.AreEqual(expectedResult, m_Manager.GetBuffer <EcsIntElement3>(entities[i]).Length); } { var expectedResult = entities[i].Index + i; Assert.AreEqual(expectedResult, m_Manager.GetComponentData <EcsTestData>(entities[i]).value); Assert.AreEqual(expectedResult, m_Manager.GetComponentData <EcsTestData2>(entities[i]).value1); Assert.AreEqual(expectedResult, m_Manager.GetComponentData <EcsTestData3>(entities[i]).value2); } } entities.Dispose(); }
public ImmediateLocomotion( Spatial target, ProcessMode processMode, ITimeSource timeSource, bool active, ILoggerFactory loggerFactory) : base(target, timeSource, active, loggerFactory) { ProcessMode = processMode; }
public ProcessClass(object filelist, ProcessMode mode, int SampleRate, int CodeRate, string Formate) { Environment.CurrentDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); PValue = -1; Mode = mode; FileList = filelist; SR = SampleRate; CR = CodeRate; FM = Formate; }
public void JobProcessStress_4_WithEntity([Values] ProcessMode mode, [Values(0, 1, 1000)] int entityCount) { var entities = PrepareData(entityCount); #if UNITY_ZEROPLAYER (new Process4Entity()).Schedule(EmptySystem); #else Schedule <Process4Entity>(mode); #endif CheckResultsAndDispose(entities, 4, true); }
private void RadioButton_Checked(object sender, RoutedEventArgs e) { if ((sender as RadioButton).Tag != null) { this.Mode = (ProcessMode)Int32.Parse((sender as RadioButton).Tag.ToString()); learnTypeStack.IsEnabled = this.Mode != ProcessMode.ProcessLearned; } else { this.Mode = ProcessMode.Learn; } }
protected void readXml(string fileName) { StreamReader sr = new StreamReader(fileName); XmlDocument doc = new XmlDocument(); doc.LoadXml(sr.ReadToEnd()); sr.Close(); XmlNode node = null; foreach (XmlNode n in doc.ChildNodes) { if (n.Name == "instances") { _dataSetName = n.Attributes[0].Value; _dataSourceName = n.Attributes[1].Value; if (n.Attributes[2].Value == "text") _media = MediaType.Text; else if (n.Attributes[2].Value == "image") _media = MediaType.Image; else if (n.Attributes[2].Value == "video") _media = MediaType.Video; else if (n.Attributes[2].Value == "audio") _media = MediaType.Audio; if (n.Attributes[3].Value == "learn") _opMode = OperationMode.Learn; else if (n.Attributes[3].Value == "validate") _opMode = OperationMode.Validate; else if (n.Attributes[3].Value == "classify") _opMode = OperationMode.Classify; if (n.Attributes[4].Value == "batch") _procMode = ProcessMode.Batch; else if (n.Attributes[4].Value == "online") _procMode = ProcessMode.Batch; node = n; break; } } //parse the IOs foreach (XmlNode n in node.ChildNodes) { if (n.Name == "input") { _sc.InputConditioners.Add(new ScaleAndOffset( double.Parse(n.Attributes[1].Value), double.Parse(n.Attributes[2].Value))); } else if (n.Name == "output") { _sc.OutputConditioners.Add(new ScaleAndOffset( double.Parse(n.Attributes[1].Value), double.Parse(n.Attributes[2].Value))); } } }
private void Parse(string[] args) { int numargs = args.Length; string arg; if (numargs == 0) { this._showHelp = true; return; } for (int i = 0; i < numargs; i++) { arg = args[i]; switch (arg) { case "-internaluse": this._internalUse = true; break; case "-installvs2005": this._installVS2005 = true; break; case "-tc": case "-testconnection": this._mode = ProcessMode.MyMeta; if (numargs > (i + 2)) { this._connType = args[++i]; this._connString = args[++i]; } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-aio": case "-addintrinsicobject": if (numargs > (i+3)) { string assembly = args[++i]; string classpath = args[++i]; string varname = args[++i]; ZeusIntrinsicObject iobj = new ZeusIntrinsicObject(assembly, classpath, varname); this._intrinsicObjects.Add(iobj); } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-rio": case "-removeintrinsicobject": if (numargs > (i + 1)) { string varname = args[++i]; foreach (ZeusIntrinsicObject zio in ZeusConfig.Current.IntrinsicObjects) { if (zio.VariableName == varname && !_intrinsicObjectsToRemove.Contains(zio)) { this._intrinsicObjectsToRemove.Add(zio); break; } } } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-r": case "-relative": this._makeRelative = true; break; case "-s": case "-silent": this._silent = true; break; case "-?": case "-h": case "-help": this._showHelp = true; break; case "-l": case "-logfile": this._enableLog = true; if (numargs > (i+1)) this._pathLog = args[++i]; else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-o": case "-outfile": if (numargs > (i+1)) this._pathOutput = args[++i]; else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-p": case "-project": this._mode = ProcessMode.Project; if (numargs > (i+1)) this._pathProject = args[++i]; else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-mumd": case "-mergeusermetadata": this._mode = ProcessMode.MyMeta; this._metaDataMerge = true; if (numargs > (i + 5)) { this._metaDataFile1 = args[++i]; this._metaDatabase1 = args[++i]; this._metaDataFile2 = args[++i]; this._metaDatabase2 = args[++i]; this._metaDataFileMerged = args[++i]; } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-m": case "-pf": case "-module": case "-projectfolder": if (numargs > (i+1)) { string data = args[++i]; if (!_moduleNames.Contains(data)) this._moduleNames.Add(data); } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-rti": case "-recordtemplateinstance": if (numargs > (i + 1)) { this._projectItemToRecord = args[++i]; this._mode = ProcessMode.Project; } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-ti": case "-templateinstance": if (numargs > (i + 1)) { string data = args[++i]; if (!_projectItems.Contains(data)) this._projectItems.Add(data); } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-i": case "-inputfile": this._mode = ProcessMode.Template; if (numargs > (i+1)) this._pathXmlData = args[++i]; else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-t": case "-template": this._mode = ProcessMode.Template; if (numargs > (i+1)) this._pathTemplate = args[++i]; else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-c": case "-collect": this._mode = ProcessMode.Template; if (numargs > (i+1)) this._pathCollectXmlData = args[++i]; else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; case "-e": case "-timeout": if (numargs > (i+1)) { try { this._timeout = Int32.Parse(args[++i]); } catch { this._timeout = -1; } } else { this._valid = false; this._errorMessage = "Invalid switch usage: " + arg; } break; default: _valid = false; this._errorMessage = "Invalid argument: " + arg; break; } } if (this._makeRelative) { if (this._pathCollectXmlData != null) this._pathCollectXmlData = Zeus.FileTools.MakeAbsolute(this._pathCollectXmlData, FileTools.ApplicationPath); if (this._pathLog != null) this._pathLog = Zeus.FileTools.MakeAbsolute(this._pathLog, FileTools.ApplicationPath); if (this._pathOutput != null) this._pathOutput = Zeus.FileTools.MakeAbsolute(this._pathOutput, FileTools.ApplicationPath); if (this._pathProject != null) this._pathProject = Zeus.FileTools.MakeAbsolute(this._pathProject, FileTools.ApplicationPath); if (this._pathTemplate != null) this._pathTemplate = Zeus.FileTools.MakeAbsolute(this._pathTemplate, FileTools.ApplicationPath); if (this._pathXmlData != null) this._pathXmlData = Zeus.FileTools.MakeAbsolute(this._pathXmlData, FileTools.ApplicationPath); if (this._metaDataFile1 != null) this._metaDataFile1 = Zeus.FileTools.MakeAbsolute(this._metaDataFile1, FileTools.ApplicationPath); if (this._metaDataFile2 != null) this._metaDataFile2 = Zeus.FileTools.MakeAbsolute(this._metaDataFile2, FileTools.ApplicationPath); if (this._metaDataFileMerged != null) this._metaDataFileMerged = Zeus.FileTools.MakeAbsolute(this._metaDataFileMerged, FileTools.ApplicationPath); } // Validate required fields are filled out for the selected mode. if (_valid) { if (this.Mode == ProcessMode.MyMeta) { if (this._metaDataMerge) { if (!System.IO.File.Exists(_metaDataFile1) || !System.IO.File.Exists(_metaDataFile2)) { _valid = false; this._errorMessage = "The two source files must exist for the merge to work!"; } } } else if (this._mode == ProcessMode.Project) { if (this._pathProject == null) { _valid = false; this._errorMessage = "Project Path Required"; } else { try { this._project = new ZeusProject(this._pathProject); this._project.Load(); } catch (Exception ex) { this._project = null; this._valid = false; this._errorMessage = ex.Message; } } if (this._pathTemplate != null) { try { this._template = new ZeusTemplate(this._pathTemplate); } catch (Exception ex) { this._template = null; this._valid = false; this._errorMessage = ex.Message; } } } else if (this._mode == ProcessMode.Template) { if ( (this._pathTemplate == null) && (this._pathXmlData == null) ) { _valid = false; this._errorMessage = "Template path or XML input path required."; } else { if (this._pathTemplate != null) { try { this._template = new ZeusTemplate(this._pathTemplate); } catch (Exception ex) { this._template = null; this._valid = false; this._errorMessage = ex.Message; } } if ( (this._valid) && (this._pathXmlData != null) ) { try { this._savedInput = new ZeusSavedInput(this._pathXmlData); this._savedInput.Load(); if (this._template == null) { this._template = new ZeusTemplate(this._savedInput.InputData.TemplatePath); } } catch (Exception ex) { this._savedInput = null; this._template = null; this._valid = false; this._errorMessage = ex.Message; } } if ( (this._valid) && (this._pathCollectXmlData != null) ) { try { this._inputToSave = new ZeusSavedInput(this._pathCollectXmlData); this._inputToSave.InputData.TemplatePath = this._template.FilePath + this._template.FileName; this._inputToSave.InputData.TemplateUniqueID = this._template.UniqueID; } catch (Exception ex) { this._inputToSave = null; this._valid = false; this._errorMessage = ex.Message; } } } } } }
} // GetChildItems /// <summary> /// Since we can't do include and exclude filtering on items we have to /// do the recursion ourselves. We get each child name and see if it matches /// the include and exclude filters. If the child is a container we recurse /// into that container. /// </summary> /// /// <param name="providerInstance"> /// The instance of the provider to use. /// </param> /// /// <param name="path"> /// The path to the item to get the children from. /// </param> /// /// <param name="recurse"> /// Recurse into sub-containers when getting children. /// </param> /// /// <param name="context"> /// The context under which the command is running. /// </param> /// /// <param name="childrenNotMatchingFilterCriteria"> /// The count of items that do not match any include/exclude criteria. /// </param> /// /// <param name="processMode">Indicates if this is a Enumerate/Remove operation</param> /// /// <param name="skipIsItemContainerCheck">a hint used to skip IsItemContainer checks</param> /// /// <exception cref="ProviderNotFoundException"> /// If the <paramref name="path"/> refers to a provider that could not be found. /// </exception> /// /// <exception cref="DriveNotFoundException"> /// If the <paramref name="path"/> refers to a drive that could not be found. /// </exception> /// /// <exception cref="NotSupportedException"> /// If the provider that the <paramref name="path"/> refers to does /// not support this operation. /// </exception> /// /// <exception cref="ProviderInvocationException"> /// If the provider threw an exception. /// </exception> /// private void ProcessPathItems( CmdletProvider providerInstance, string path, bool recurse, CmdletProviderContext context, out int childrenNotMatchingFilterCriteria, ProcessMode processMode = ProcessMode.Enumerate, bool skipIsItemContainerCheck = false) { ContainerCmdletProvider containerCmdletProvider = GetContainerProviderInstance(providerInstance); childrenNotMatchingFilterCriteria = 0; Dbg.Diagnostics.Assert( providerInstance != null, "The caller should have verified the providerInstance"); Dbg.Diagnostics.Assert( path != null, "The caller should have verified the path"); Dbg.Diagnostics.Assert( context != null, "The caller should have verified the context"); // Construct the include filter Collection<WildcardPattern> includeMatcher = SessionStateUtilities.CreateWildcardsFromStrings( context.Include, WildcardOptions.IgnoreCase); // Construct the exclude filter Collection<WildcardPattern> excludeMatcher = SessionStateUtilities.CreateWildcardsFromStrings( context.Exclude, WildcardOptions.IgnoreCase); // If the item is a container we have to filter its children // Use a hint + lazy evaluation to skip a container check if (skipIsItemContainerCheck || IsItemContainer(providerInstance, path, context)) { CmdletProviderContext newContext = new CmdletProviderContext(context); Collection<PSObject> childNameObjects = null; System.Collections.Generic.Dictionary<string, bool> filteredChildNameDictionary = null; try { // Get all the child names GetChildNames( providerInstance, path, (recurse) ? ReturnContainers.ReturnAllContainers : ReturnContainers.ReturnMatchingContainers, newContext); newContext.WriteErrorsToContext(context); childNameObjects = newContext.GetAccumulatedObjects(); // The code above initially retrieves all of the containers so that it doesn't limit the recursion, // but then emits the non-matching container further down. The public API doesn't support a way to // differentiate the two, so we need to do a diff. // So if there was a filter, do it again to get the fully filtered items. if (recurse && (providerInstance.IsFilterSet())) { newContext.RemoveStopReferral(); newContext = new CmdletProviderContext(context); filteredChildNameDictionary = new System.Collections.Generic.Dictionary<string, bool>(); GetChildNames( providerInstance, path, ReturnContainers.ReturnMatchingContainers, newContext); var filteredChildNameObjects = newContext.GetAccumulatedObjects(); foreach (PSObject filteredChildName in filteredChildNameObjects) { string filteredName = filteredChildName.BaseObject as string; if (filteredName != null) { filteredChildNameDictionary[filteredName] = true; } } } } finally { newContext.RemoveStopReferral(); } // Now loop through all the child objects matching the filters and recursing // into containers for (int index = 0; index < childNameObjects.Count; ++index) { // Making sure to obey the StopProcessing. if (context.Stopping) { return; } string childName = childNameObjects[index].BaseObject as string; if (childName == null) { continue; } // Generate the provider path for the child string qualifiedPath = MakePath(providerInstance, path, childName, context); if (qualifiedPath == null) { continue; } bool isIncludeMatch = !context.SuppressWildcardExpansion && SessionStateUtilities.MatchesAnyWildcardPattern( childName, includeMatcher, true); if (isIncludeMatch) { if (!SessionStateUtilities.MatchesAnyWildcardPattern( childName, excludeMatcher, false)) { bool emitItem = true; if (filteredChildNameDictionary != null) { bool isChildNameInDictionary = false; emitItem = filteredChildNameDictionary.TryGetValue(childName, out isChildNameInDictionary); } if (emitItem) { if (processMode == ProcessMode.Delete) { containerCmdletProvider.RemoveItem(qualifiedPath, false, context); } else if (processMode != ProcessMode.Delete) { // The object is a match so get it and write it out. GetItemPrivate(providerInstance, qualifiedPath, context); } } } else { childrenNotMatchingFilterCriteria++; } } else { childrenNotMatchingFilterCriteria++; } // Now recurse if it is a container if (recurse && IsItemContainer(providerInstance, qualifiedPath, context)) { // Making sure to obey the StopProcessing. if (context.Stopping) { return; } // The item is a container so recurse into it. ProcessPathItems(providerInstance, qualifiedPath, recurse, context, out childrenNotMatchingFilterCriteria, processMode, skipIsItemContainerCheck: true); } } // for each childName } else { // The path is not a container so write it out if its name // matches the filter string childName = path; childName = GetChildName(providerInstance, path, context, true); // Write out the object if it is a match bool isIncludeMatch = SessionStateUtilities.MatchesAnyWildcardPattern( childName, includeMatcher, true); if (isIncludeMatch) { if (!SessionStateUtilities.MatchesAnyWildcardPattern( childName, excludeMatcher, false)) { if (processMode != ProcessMode.Delete) { // The object is a match so get it and write it out. GetItemPrivate(providerInstance, path, context); } else { // The object is a match so, remove it. containerCmdletProvider.RemoveItem(path, recurse, context); } } } } } // ProcessPathItems
private void ProcessAllInternal(IEnumerable<IEntity> data, ProcessMode mode, SqliteTransaction tran, bool inTran) { string[] columns = null; var cmd = new SqliteCommand[4]; String tableName = null; try { foreach (IEntity obj in data) { if (cmd[0] == null) { EntityType type = obj.EntityType; columns = GetColumns(type); String fNames = ""; String fParameters = ""; String fFields = ""; foreach (string column in columns) { if (!String.IsNullOrEmpty(fNames)) { fNames = fNames + ","; fParameters = fParameters + ","; fFields = fFields + ","; } fNames = fNames + column; fParameters = fParameters + "@" + column; fFields = fFields + String.Format("[{0}] = @{0}", column); } fNames = fNames + ",IsTombstone,IsDirty"; fParameters = fParameters + ",@IsTombstone,@IsDirty"; fFields = fFields + ",[IsTombstone] = @IsTombstone, [IsDirty] = @IsDirty"; tableName = type.TableName; cmd[0] = new SqliteCommand(String.Format("INSERT INTO [_{0}]({1}) VALUES({2})", tableName, fNames, fParameters), ActiveConnection, tran); cmd[1] = new SqliteCommand(String.Format("UPDATE [_{0}] SET {1} WHERE [Id] = @Id", tableName, fFields), ActiveConnection, tran); foreach (string column in columns) { cmd[0].Parameters.Add("@" + column, _supportedTypes[GetType(type.GetPropertyType(column))].DbType); cmd[1].Parameters.Add("@" + column, _supportedTypes[GetType(type.GetPropertyType(column))].DbType); } cmd[0].Parameters.Add("@IsTombstone", System.Data.DbType.Boolean); cmd[0].Parameters.Add("@IsDirty", System.Data.DbType.Boolean); cmd[1].Parameters.Add("@IsTombstone", System.Data.DbType.Boolean); cmd[1].Parameters.Add("@IsDirty", System.Data.DbType.Boolean); cmd[2] = new SqliteCommand(String.Format("SELECT Id FROM [_{0}] WHERE [Id] = @Id", tableName), ActiveConnection, tran); cmd[2].Parameters.Add("@Id", System.Data.DbType.String); cmd[3] = new SqliteCommand(String.Format("DELETE FROM [_{0}] WHERE [Id] = @Id", tableName), ActiveConnection, tran); cmd[3].Parameters.Add("@Id", System.Data.DbType.String); } //row id DbRef id; if (mode == ProcessMode.InitialLoad || mode == ProcessMode.ServerChanges) id = DbRef.CreateInstance(tableName, ((ISqliteEntity)obj).EntityId); else id = DbRef.FromString(obj.GetValue(columns[0]).ToString()); int idx = 0; //insert if (mode != ProcessMode.InitialLoad) { if (((ISqliteEntity)obj).IsTombstone) { idx = mode == ProcessMode.ServerChanges ? 3 : 1; } else { cmd[2].Parameters[0].Value = id; if (cmd[2].ExecuteScalar() != null) idx = 1; //update } } //assign values if (idx > 2) //delete { cmd[idx].Parameters[0].Value = id; } else { int n = 0; foreach (string column in columns) { cmd[idx].Parameters[n].Value = obj.GetValue(column); n++; } cmd[idx].Parameters[n].Value = ((ISqliteEntity)obj).IsTombstone ? 1 : 0; //IsTombstone var entity = (ISqliteEntity)obj; cmd[idx].Parameters[n + 1].Value = mode == ProcessMode.LocalChanges && (entity.IsNew() || entity.IsModified()) ? 1 : 0; //isDirty } if (mode == ProcessMode.LocalChanges && inTran) CopyTranObject(obj, tran, tableName, id.ToString(), idx); cmd[idx].ExecuteNonQuery(); } } finally { foreach (var c in cmd) { c.Dispose(); } } foreach (SqliteCommand c in cmd) { if (c != null) c.Dispose(); } }
public void ProcessData(IEnumerable<IEntity> data, ProcessMode mode, SqliteTransaction tran = null) { bool inTran = tran != null; var toRemoveFromCache = new List<Guid>(); try { foreach (IEnumerable<IEntity> lst in GetBlock(data.GetEnumerator())) { if (!inTran) tran = ActiveConnection.BeginTransaction(); ProcessAllInternal(lst, mode, tran, mode == ProcessMode.LocalChanges); if (!inTran) tran.Commit(); if (mode == ProcessMode.ServerChanges) { foreach (ISqliteEntity e in lst) toRemoveFromCache.Add(e.EntityId); } GC.Collect(); } Cache.Clear(toRemoveFromCache); } catch { if (tran != null && !inTran) tran.Rollback(); throw; } }
/// <summary> /// Initializes a new instance of the <see cref="TtsEspHelper"/> class. /// </summary> /// <param name="language">Language.</param> /// <param name="voicePath">Voice font path.</param> /// <param name="mode">Process mode.</param> public TtsEspHelper(Language language, string voicePath, ProcessMode mode) : this(language, voicePath, string.Empty, string.Empty, mode) { }