private string fromString(string line) { if (checkPreproccess(line)) { return(string.Empty); } return(Insertion.Replace(line, (Match m) => { string value = m.Value.Substring(1, m.Value.Length - 2); if (value.Contains(":")) { string[] splits = value.Split(":"); if (splits.Length <= 1) { throw new IllegalPipeException(); } string result = Values.ContainsKey(splits[0]) ? (string)Values[splits[0]] : splits[0]; System.Diagnostics.Debug.WriteLineIf(Values.ContainsKey(result), Values.Where(kv => kv.Key == result).Select(kv => kv.Value).FirstOrDefault()); foreach (string pipeId in splits.Skip(1)) { string[] pipeAndArg = pipeId.Split(','); if (!Pipes.ContainsKey(pipeAndArg[0])) { throw new IllegalPipeException(pipeAndArg[0]); } result = Pipes[pipeAndArg[0]](result, pipeAndArg.Skip(1).ToArray()); } System.Diagnostics.Debug.WriteLine(result); return result; } else { if (Values.ContainsKey(value)) { if (Values[value] is DateTime dt) { if (Values.ContainsKey("dateTimeFormat")) { return dt.ToString((string)Values["dateTimeFormat"]); } return dt.ToShortDateString(); } return Values[value].ToString(); } return value; } })); }
void FollowPipe(Pipes chosenPipe) { //playerObject.transform.position = chosenPipe.endLocation.position; //for(int i = 0; i < chosenPipe.followPoints.Count; i++) //{ // Vector3 positionPoints = chosenPipe.followPoints[i].position; // if(move) // { // if(stepsTaken < amountSteps) // { // Debug.Log("Loop"); // playerObject.transform.position = new Vector3(Mathf.Lerp(playerObject.transform.position.x, positionPoints.x, lerpSpeed), // Mathf.Lerp(playerObject.transform.position.y, positionPoints.y, lerpSpeed), // playerObject.transform.position.z); // stepsTaken++; // } // else // { // move = false; // stepsTaken = 0; // } // } //} }
// Reloads the level and reinitializes Mario to his default state. public void Reset() { Enemies.Clear(); Blocks.Clear(); Pipes.Clear(); Coins.Clear(); Checkpoints.Clear(); Flagpoles.Clear(); levelData.Clear(); InvisibleBarrier = new InvisibleBarrier(Vector2.Zero); CoinRoomPosition = Vector2.Zero; DynamicObjects.Clear(); StaticObjects.Clear(); PowerUpState = false; Mario.Instance.ResetPlayer(); SoundManager.Instance.gameOverPlayOnce = true; levelData = ParseLevelCSV(fileName); BuildLevel(levelData); }
public static void TestPipeArgDeserialization() { var jsonV1 = new PipeArgs(new[] { new PipeArg("cancel", ArgMode.Inject, 2) }).ToJson(Pipes.ArgJCfg); var jsonV0 = @"{ ""$type"": ""Mutuo.Etl.Pipe.PipeArg[], Mutuo.Etl"", ""$values"": [ { ""$type"": ""Mutuo.Etl.Pipe.PipeArg, Mutuo.Etl"", ""name"": ""options"", ""value"": { ""$type"": ""YtReader.UpdateOptions, YtReader"" } }, { ""$type"": ""Mutuo.Etl.Pipe.PipeArg, Mutuo.Etl"", ""name"": ""cancel"", ""argMode"": 2 } ] }".ParseJObject(); var v2 = Pipes.LoadInArgs(jsonV0); v2.Version.Should().Be(PipeArgs.Versions.V1); v2.Values.First(v => v.Name == "cancel").ArgMode.Should().Be(ArgMode.Inject); }
public void SwitchingPipes() { //checks if each pipe is out of the screen and resets it with diffrent highet if (Canvas.GetLeft(pipeDown1._img) < -100) { borad.Children.Remove(pipeDown1._img); borad.Children.Remove(pipeUp1._img); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp1 = new Pipes(0, 1960, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown1 = new Pipes(700 - hieghtPipeDown, 1960, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown1.Addtocanvas(borad); pipeUp1.Addtocanvas(borad); isOverPipeDown1 = false; } if (Canvas.GetLeft(pipeDown1._img) < -100) { borad.Children.Remove(pipeDown1._img); borad.Children.Remove(pipeUp1._img); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp1 = new Pipes(0, 1960, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown1 = new Pipes(700 - hieghtPipeDown, 1960, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown1.Addtocanvas(borad); pipeUp1.Addtocanvas(borad); isOverPipeDown1 = false; } if (Canvas.GetLeft(pipeDown2._img) < -100) { borad.Children.Remove(pipeDown2._img); borad.Children.Remove(pipeUp2._img); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp2 = new Pipes(0, 1960, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown2 = new Pipes(700 - hieghtPipeDown, 1960, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown2.Addtocanvas(borad); pipeUp2.Addtocanvas(borad); isOverPipeDown2 = false; } if (Canvas.GetLeft(pipeDown3._img) < -100) { borad.Children.Remove(pipeDown3._img); borad.Children.Remove(pipeUp3._img); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp3 = new Pipes(0, 1960, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown3 = new Pipes(700 - hieghtPipeDown, 1960, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown3.Addtocanvas(borad); pipeUp3.Addtocanvas(borad); isOverPipeDown3 = false; } if (Canvas.GetLeft(pipeDown4._img) < -100) { borad.Children.Remove(pipeDown4._img); borad.Children.Remove(pipeUp4._img); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp4 = new Pipes(0, 1960, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown4 = new Pipes(700 - hieghtPipeDown, 1960, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown4.Addtocanvas(borad); pipeUp4.Addtocanvas(borad); isOverPipeDown4 = false; } }
public static void Main() { Pipes waterPipes = new Pipes(); Pipes.ManualInput(waterPipes); waterPipes.Game(); }
public void LoadWorld(string levelName, Game1 game, bool clearMario = true) { var state = (game.Mario == null) ? null : game.Mario.State; game.LevelName = levelName; game.Map = null; game.Mario = null; Items.Clear(); Enemies.Clear(); Fireballs.Clear(); Pipes.Clear(); Background.Clear(); Texts.Clear(); MovingTexts.Clear(); Achievements.Clear(); Game1.Camera.Position = Vector2.Zero; LevelName = levelName; string level = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName) + "\\Content\\Levels\\" + levelName + ".csv"; new LevelLoader(game, level); if (!clearMario) { if (state.Name == "Big") { game.Mario.ToBig(); } else if (state.Name == "Fire") { game.Mario.ToFire(); } } }
private void CheckForCollisions() { if (Bird.IsOnGround()) { GameOver(); } // 1. Check for a pipe in the middle var centeredPipe = Pipes.FirstOrDefault(p => p.IsCentered()); // 2. If there is a pipe, check for collisions with: if (centeredPipe != null) { bool hasCollidedWithBottom = Bird.DistanceFromGround < centeredPipe.GapBottom - 150; bool hasCollidedWithTop = Bird.DistanceFromGround + 45 > centeredPipe.GapTop - 150; if (hasCollidedWithBottom || hasCollidedWithTop) { GameOver(); } } // 2a. Bottom pipe // 2b. Top pipe }
private void Load(string fileName) { Processors.Clear(); Pipes.Clear(); try { //var serializer = new XmlSerializer(typeof(Pipeline)); using (var stream = new FileStream(fileName, FileMode.Open)) { Model = _serializer.ReadObject(stream) as Pipeline ?? new Pipeline(); foreach (var target in Model.Targets) { AddNode(target); } BuildPipeViewModels(Model); } } catch (Exception e) { ExceptionMessageBox.ShowException(e, String.Format("Could not load pipeline. {0}.", e.Message)); } Name = fileName; }
public void CheckForCollisions() { //check if the bird is on the ground if (Bird.IsOnGround()) { GameOver(); } //the first pipe in pipes that has a value of true for IsCentered() (otherwise var is null value) var centeredPipe = Pipes.FirstOrDefault(p => p.IsCentered()); //if there is a pipe in the center collision zone... if (centeredPipe != null) { //true if the bottom of the bird's distance to ground is beneath the bottom of the gap minus the height of the ground bool hasCollidedWithBottom = Bird.DistanceFromGround < centeredPipe.GapBottom - 150; //true if the top of the bird's distance to the ground is greater than the top of the gap minus the ground height bool hasCollidedWithTop = Bird.DistanceFromGround + 45 > centeredPipe.GapTop - 150; if (hasCollidedWithBottom || hasCollidedWithTop) { GameOver(); } } }
public void pipeSettings() { isBegining = true; #region Pipe settings RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp1 = new Pipes(0, 1260, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown1 = new Pipes(700 - hieghtPipeDown, 1260, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown1.Addtocanvas(borad); pipeUp1.Addtocanvas(borad); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp2 = new Pipes(0, 1760, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown2 = new Pipes(700 - hieghtPipeDown, 1760, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown2.Addtocanvas(borad); pipeUp2.Addtocanvas(borad); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp3 = new Pipes(0, 2260, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown3 = new Pipes(700 - hieghtPipeDown, 2260, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown3.Addtocanvas(borad); pipeUp3.Addtocanvas(borad); RandomHieghtPipes(out hieghtPipeDown, out hieghtPipeUp); pipeUp4 = new Pipes(0, 2760, "ms-appx:///Assets/pipeUP.png", hieghtPipeUp, 100); pipeDown4 = new Pipes(700 - hieghtPipeDown, 2760, "ms-appx:///Assets/pipeDown.png", hieghtPipeDown, 100); pipeDown4.Addtocanvas(borad); pipeUp4.Addtocanvas(borad); #endregion }
public PipeGroup Copy() { return(new PipeGroup { Pipes = Pipes?.Select(x => x.Copy()).ToArray(), Zone = Zone, AvgElevation = AvgElevation, InputAvgPressure = InputAvgPressure, InFlow = InFlow, Usage = Usage, AnhydrouAmount = AnhydrouAmount, Col6 = Col6, Col7 = Col7, Col8 = Col8, Col9 = Col9, RuptureLeakage = RuptureLeakage, Leakage = Leakage, MinPressure = MinPressure, MaxPressure = MaxPressure, AvgPressure = AvgPressure, StDevPressure = StDevPressure, MinVelocity = MinVelocity, MaxVelocity = MaxVelocity, AvgVelocity = AvgVelocity, StDevVelocity = StDevVelocity, }); }
public async Task Connect() { _serverAliveCheck = new Timer((s) => { if (ServerProcessUtil.IsServerDown(_pid) == false) { return; } Console.WriteLine($"RavenDB server process PID {_pid} exited."); _exitCode = 1; Stop(); }, null, 0, ServerAliveCheckInterval); try { var pipeName = Pipes.GetPipeName(Pipes.LogStreamPipePrefix, _pid); _client = new NamedPipeClientStream(pipeName); WorkaroundSetPipePathForPosix(_client, pipeName); try { _client.Connect(3000); } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(Environment.NewLine + "Couldn't connect to " + pipeName); Console.ResetColor(); Console.WriteLine(); Console.WriteLine(ex); Environment.Exit(2); } Console.WriteLine("Connected to RavenDB server. Tailing logs..."); var reader = new StreamReader(_client); var buffer = new char[8192]; var stdOut = Console.Out; while (true) { var readCount = await reader.ReadAsync(buffer, 0, buffer.Length); if (readCount > 0) { await stdOut.WriteAsync(buffer, 0, readCount); } } } catch (ObjectDisposedException) { // closing } catch (Exception e) { Console.WriteLine(e); throw; } }
private void BuildPipeViewModels(Pipeline pipeline) { foreach (var source in pipeline.Targets) { foreach (var target in source.Targets) { Pipes.Add(new PipeViewModel(source, target)); } } }
public ProcessTreeContext(Guid payloadGuid, SafeHandle reportPipe, ArraySegment <byte> payload, string dllNameX64, string dllNameX86, LoggingContext loggingContext) { // We cannot create this object in a wow64 process Contract.Assume( !ProcessUtilities.IsWow64Process(), "ProcessTreeContext:ctor - Cannot run injection server in a wow64 32 bit process"); SafeFileHandle childHandle = null; m_loggingContext = loggingContext; // This object will be the server for the tree. CreateSourceFile the pipe server. try { SafeFileHandle injectorHandle; // Create a pipe for the requests Pipes.CreateInheritablePipe(Pipes.PipeInheritance.InheritWrite, Pipes.PipeFlags.ReadSideAsync, out injectorHandle, out childHandle); // Create the injector. This will duplicate the handles. Injector = ProcessUtilities.CreateProcessInjector(payloadGuid, childHandle, reportPipe, dllNameX86, dllNameX64, payload); // Create the request reader. We don't start listening until requested var injectionRequestFile = AsyncFileFactory.CreateAsyncFile( injectorHandle, FileDesiredAccess.GenericRead, ownsHandle: true, kind: FileKind.Pipe); m_injectionRequestReader = new AsyncPipeReader(injectionRequestFile, InjectCallback, Encoding.Unicode, BufferSize); } catch (Exception exception) { if (Injector != null) { Injector.Dispose(); Injector = null; } if (m_injectionRequestReader != null) { m_injectionRequestReader.Dispose(); m_injectionRequestReader = null; } throw new BuildXLException("Process Tree Context injector could not be created", exception); } finally { // Release memory. Since the child handle is duplicated, it can be released if (childHandle != null && !childHandle.IsInvalid) { childHandle.Dispose(); } } }
private void ManagePipes() { if (!Pipes.Any() || Pipes.Last().DistanceFromLeft < GameWidth / 2) { Pipes.Add(new PipeModel(GameWidth)); } if (Pipes.First().IsOffScreen()) { Pipes.Remove(Pipes.First()); } }
private void ManagePipes() { if (Pipes.Count == 0 || Pipes.Last().DistanceFromLeft <= 250) { Pipes.Add(new PipeModel()); } if (Pipes[0].IsOffScreen()) { Pipes.Remove(Pipes[0]); } }
void ManagePipes() { if (!Pipes.Any() || Pipes.Last().DistanceFromleft <= 250) { Pipes.Add(new PipeModel()); } if (Pipes.First().IsOffScreen()) { Pipes.Remove(Pipes.First()); } }
private void Awake() { pipes = new Pipes[pipeCount]; for (int i = 0; i < pipes.Length; i++) { Pipes pipe = pipes[i] = Instantiate <Pipes>(pipePrefab); pipe.transform.SetParent(transform, false); if (i > 0) { pipe.AlignWith(pipes[i - 1]); } } }
public void Dispose() { GC.SuppressFinalize(this); if (Pipes != null) { Pipes.DeletePipes(); } if (WebSocket != null) { WebSocket.Close(); WebSocket = null; } }
public void AlignWith(Pipes pipe) { float relativeRotation = Random.Range(0, curveSegmentCount) * 360f / pipeSegmentCount; transform.SetParent(pipe.transform, false); transform.localPosition = Vector3.zero; transform.localRotation = Quaternion.Euler(0f, 0f, -pipe.curveAngle); transform.Translate(0f, pipe.curveRadius, 0f); transform.Rotate(relativeRotation, 0f, 0f); transform.Translate(0f, -curveRadius, 0f); transform.SetParent(pipe.transform.parent); }
private void GeneratePipes() { var newPipes = pipes.Where(p => !p.IsAlive).FirstOrDefault(); if (newPipes == null) { newPipes = new Pipes(this); pipes.Add(newPipes); } var pipesY = (int)(rnd.NextDouble() * 200 - 100); newPipes.Reset(width + 20, pipesY); }
public void MoveObjects() { //make the Bird fall Bird.Fall(_gravity); //make the Pipe mode //Pipe.Move(_speed); //Move each pipe in the collection of pipes //foreach(var pipe in Pipes) //{ // pipe.Move(_speed); //} Pipes.ForEach(x => x.Move(_speed)); //shorthand }
public void Dispose() { GC.SuppressFinalize(this); if (Pipes != null) { Pipes.DeletePipes(); } if (WebSockets.Count > 0) { foreach (var webSocket in WebSockets) { webSocket.Close(); } } }
internal void AddPipe(BaseProcessor source, BaseProcessor target) { var sourceHasTarget = source.Targets.Any(t => Equals(t, target)); var targetHasSource = target.Sources.Any(s => Equals(s, source)); // Do not pipe only once if (sourceHasTarget && targetHasSource) { return; } source.Targets.Add(target); target.Sources.Add(source); Pipes.Add(new PipeViewModel(source, target)); }
void Start() { Menu.menu.scorePanel = scorePanel; Menu.menu.scoreText = menuScoreText; _randomSpawn = GetComponent <RandomSpawn>(); _tower = GameObject.Find("Tower"); _towerComponent = _tower.GetComponent <Tower>(); _pipeDirection = _tower.GetComponent <PipeDirectionController>(); _pipes = _tower.GetComponent <Pipes>(); _towerComponent.SetScore(0); Spawn(); }
public void Run(object aCommandReceived) { LastRun = DateTime.Now; CommandReceivedDelegate CommandReceived = (CommandReceivedDelegate) aCommandReceived; for (Running = true; Running; ) { itsPipes = new Pipes( new System.IO.Pipes.NamedPipeClientStream(".", "XervBackup.Pipe.Out", System.IO.Pipes.PipeDirection.In), new System.IO.Pipes.NamedPipeClientStream(".", "XervBackup.Pipe.In", System.IO.Pipes.PipeDirection.Out)); while (Running && !itsPipes.Out.IsConnected) { try { itsPipes.Out.Connect(10000); } //1000); } catch { } } itsPipes.In.Connect(); itsWriter = new System.IO.StreamWriter(itsPipes.Out); itsWriter.AutoFlush = true; // !! Debug.WriteLine("CONNECTED"); if (ConnectedChanged != null) ConnectedChanged(IsConnected); System.Media.SystemSounds.Beep.Play(); using (System.Timers.Timer KeepAlive = new System.Timers.Timer(1000)) using (System.IO.StreamReader Reader = new System.IO.StreamReader(itsPipes.In)) { KeepAlive.Elapsed += new System.Timers.ElapsedEventHandler( delegate(object sender, System.Timers.ElapsedEventArgs e) { SendCommand(string.Empty); // Send empty keepalive }); while (Running && itsPipes.In.IsConnected) { try { string Line = Reader.ReadLine(); if (!string.IsNullOrEmpty(Line)) // Keepalive is empty CommandReceived(Line); } catch (Exception Ex) { Debug.WriteLine(Ex); } } itsPipes.Close(); } Debug.WriteLine("Exiting pipe thread"); if (ConnectedChanged != null) ConnectedChanged(IsConnected); } }
void SpawnNewPipes() { spawnTimer -= Time.deltaTime; if (spawnTimer > 0f) { return; } centerHeight = Random.Range(0.3f, 3.0f); Pipes newPipe = Instantiate(pipePrefab, transform.position, Quaternion.identity); newPipe.transform.Translate(Vector3.up * centerHeight); pipes.Add(newPipe); spawnTimer = secondsBetweenSpawns; }
public void ManagePipes() { //if the list of pipes don't have any objects in it... //OR if the last pipe in the list is halfway across the screen... if (!Pipes.Any() || Pipes.Last().DistanceFromLeft <= 250) { //add another pipe to the list Pipes.Add(new PipeModel()); } //if it is true that the first pipe in the list if off the screen... if (Pipes.First().IsOffScreen()) { //remove the pipe from the list of pipes Pipes.Remove(Pipes.First()); } }
private void OnStrokeCollected(SenderAwareEventArgs e) { var container = e.Sender as FrameworkElement; var eventArgs = e.OriginalEventArgs as StrokeEventArgs; Debug.Assert(eventArgs != null, "event args need to be != null"); var pg = PathGeometry.CreateFromGeometry(eventArgs.Stroke.GetGeometry()); var elementsInGeometry = HitTestHelper.GetElementsInGeometry <PipeView>(pg, container); var linksToDelete = elementsInGeometry.Select(view => view.DataContext).OfType <PipeViewModel>().ToArray(); // As user if pipes should be deleted. if (linksToDelete.Any()) { var deletePipes = MessageBox.Show("Do you want to delete pipes?", "Delete Pipes", MessageBoxButton.YesNo, MessageBoxImage.Question); if (deletePipes != MessageBoxResult.Yes) { return; } } // TODO: add method to model, which is capable of deleting more than one link safely foreach (var vm in linksToDelete) { var source = vm.Source as BaseProcessor; var target = vm.Target as BaseProcessor; if (source != null) { source.Targets.Remove(target); } if (target != null) { target.Sources.Remove(source); } Pipes.Remove(vm); } }
void CheckForCollisions() { if (Bird.IsOnGround()) { GameOver(); } var centeredPipe = Pipes.FirstOrDefault(p => p.IsCentered()); if (centeredPipe != null) { bool hasColidedWithBottom = Bird.DistanceFromGround < centeredPipe.GapBottom - 150; bool hasColidedWithTop = Bird.DistanceFromGround + 45 > centeredPipe.GapTop - 150; if (hasColidedWithBottom || hasColidedWithTop) { GameOver(); } } }
public static SystemCallResults WaitOnPipeCreate(Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass, out int NewPipeId) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.WaitOnPipeCreate, (uint)Class, (uint)Subclass, 0, ref Return1, ref Return2, ref Return3, ref Return4); NewPipeId = (int)Return2; return (SystemCallResults)Return1; }
/// <summary> /// Gets the number of available outpoints of the specified class and subclass. /// </summary> /// <param name="numOutpoints">Out : The number of outpoints (correct iff SysCallResult is OK).</param> /// <param name="SysCallResult">Out : The result of the system call. Check this is set to OK.</param> /// <param name="Class">The class of pipe to search for.</param> /// <param name="Subclass">The subclass of pipe to search for.</param> public static void GetNumPipeOutpoints(out int numOutpoints, out SystemCallResults SysCallResult, Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass) { SysCallResult = SystemCalls.GetNumPipeOutpoints(Class, Subclass, out numOutpoints); switch (SysCallResult) { case SystemCallResults.Unhandled: //BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Unhandled!"); break; case SystemCallResults.Fail: //BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Failed!"); break; case SystemCallResults.OK: //BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Succeeded."); //BasicConsole.Write("BasicServerHelpers > Num pipe outpoints: "); //BasicConsole.WriteLine(numOutpoints); break; default: //BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Unexpected system call result!"); break; } }
public virtual bool CanPushIMessage(Pipes.Interfaces.IMessage item) { return true; }
public static SystemCallResults ReadPipe(Pipes.ReadPipeRequest* Request, out int BytesRead) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.ReadPipe, (uint)Request, 0, 0, ref Return1, ref Return2, ref Return3, ref Return4); BytesRead = (int)Return2; return (SystemCallResults)Return1; }
public void Install(Pipes.StreamString pipeStream) { Thread installThread = new Thread(new ParameterizedThreadStart(InstallCallback)); installThread.Name = "Installation Thread"; installThread.IsBackground = true; installThread.Priority = ThreadPriority.Normal; installThread.Start(pipeStream); }
public void Setup() { _pipes = new Pipes(); }
private void InstallComponent(int index, Pipes.StreamString pipeStream) { pipeStream.WriteString("[Component]" + components[index].Name); // Subscribe to the ProgressUpdate event, and update the installer pages' progress bar components[index].ProgressUpdate += delegate(object sender, ProgressUpdateEventArgs e) { pipeStream.WriteString("[Progress]" + e.Percent); }; components[index].StatusUpdate += delegate(object sender, StatusUpdateEventArgs e) { pipeStream.WriteString("[Status]" + e.Status); }; components[index].InstallComplete += delegate(object sender, EventArgs e) { if (index + 1 < components.Count) { InstallComponent(index + 1, pipeStream); } else { if (InstallComplete != null) InstallComplete(this, EventArgs.Empty); } }; switch (Mode) { case InstallMode.Install: { components[index].Install(); } break; case InstallMode.Repair: { components[index].Repair(destinationDirectory); } break; } }
public static SystemCallResults WritePipe(Pipes.WritePipeRequest* Request) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.WritePipe, (uint)Request, 0, 0, ref Return1, ref Return2, ref Return3, ref Return4); return (SystemCallResults)Return1; }
public static SystemCallResults CreatePipe(uint OutProcessId, Pipes.CreatePipeRequest* RequestPtr) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.CreatePipe, OutProcessId, (uint)RequestPtr, 0, ref Return1, ref Return2, ref Return3, ref Return4); return (SystemCallResults)Return1; }
public void Setup() { _pipes = new Pipes(); _selected = _pipes as ISelectedCollection<IPipe>; }
/// <summary> /// Gets the outpoint desciptors of the available outpoints of the specified class and subclass. /// </summary> /// <param name="numOutpoints">The known number of available outpoints. Use GetNumPipeOutpoints to obtain this number.</param> /// <param name="SysCallResult">Out : The result of the system call. Check this is set to OK.</param> /// <param name="OutpointDescriptors">Out : The array of outpoint descriptors.</param> /// <param name="Class">The class of pipe to search for.</param> /// <param name="Subclass">The subclass of pipe to search for.</param> public static void GetOutpointDescriptors(int numOutpoints, out SystemCallResults SysCallResult, out Pipes.PipeOutpointDescriptor[] OutpointDescriptors, Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass) { OutpointDescriptors = new Pipes.PipeOutpointDescriptor[numOutpoints]; Pipes.PipeOutpointsRequest* RequestPtr = (Pipes.PipeOutpointsRequest*)Heap.AllocZeroed((uint)sizeof(Pipes.PipeOutpointsRequest), "BasicServerHelpers : Alloc PipeOutpointsRequest"); if (RequestPtr != null) { try { RequestPtr->MaxDescriptors = numOutpoints; RequestPtr->Outpoints = (Pipes.PipeOutpointDescriptor*)((byte*)Utilities.ObjectUtilities.GetHandle(OutpointDescriptors) + FOS_System.Array.FieldsBytesSize); if (RequestPtr->Outpoints != null) { SysCallResult = SystemCalls.GetPipeOutpoints(Class, Subclass, RequestPtr); switch (SysCallResult) { case SystemCallResults.Unhandled: //BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Unhandled!"); break; case SystemCallResults.Fail: //BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Failed!"); break; case SystemCallResults.OK: //BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Succeeded."); break; default: //BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Unexpected system call result!"); break; } } else { SysCallResult = SystemCallResults.Fail; //BasicConsole.WriteLine("BasicServerHelpers > RequestPtr->Outpoints null! No memory allocated."); ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicServerHelpers : Couldn't allocate memory outpoints list in outpoints request!")); } } finally { Heap.Free(RequestPtr); } } else { SysCallResult = SystemCallResults.Fail; //BasicConsole.WriteLine("BasicServerHelpers > RequestPtr null! No memory allocated."); ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicServerHelpers : Couldn't allocate memory get outpoints request!")); } }
private void BeginConnect() { itsPipes = new Pipes(); itsPipes.Out.BeginWaitForConnection(new AsyncCallback(Connected), null); }
public static SystemCallResults RegisterPipeOutpoint(Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass, int MaxConnections) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.RegisterPipeOutpoint, (uint)Class, (uint)Subclass, (uint)MaxConnections, ref Return1, ref Return2, ref Return3, ref Return4); return (SystemCallResults)Return1; }
public static SystemCallResults GetNumPipeOutpoints(Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass, out int NumOutpoints) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.GetNumPipeOutpoints, (uint)Class, (uint)Subclass, 0, ref Return1, ref Return2, ref Return3, ref Return4); NumOutpoints = (int)Return2; return (SystemCallResults)Return1; }
public static SystemCallResults GetPipeOutpoints(Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass, Pipes.PipeOutpointsRequest* RequestPtr) { uint Return1 = 0; uint Return2 = 0; uint Return3 = 0; uint Return4 = 0; Call(SystemCallNumbers.GetPipeOutpoints, (uint)Class, (uint)Subclass, (uint)RequestPtr, ref Return1, ref Return2, ref Return3, ref Return4); return (SystemCallResults)Return1; }