void Update() { if (!Application.isPlaying) { return; } if (Action == null) { return; } if (Action.HasEnded) { CurrentEvent = null; if (HasReachedMaxTriggerCount()) { m_currState = HandlerState.TERMINATED; } else { m_currState = HandlerState.SLEEPING; } return; } if (Action.IsRunning) { Action.Update(); } }
protected override bool HandleByte(byte messageByte) { switch (currentState) { case HandlerState.StartEnd: currentState = HandlerState.SysexCommand; return(true); case HandlerState.SysexCommand: currentState = HandlerState.PinMapping; return(true); case HandlerState.PinMapping: if (messageByte == MessageConstants.SYSEX_END) { messageBroker.CreateEvent(message); Reset(); return(false); } if (messageByte > 127) { throw new MessageHandlerException(BaseExceptionMessage + "This is not a valid mapping"); } message.PinMappings.Add(messageByte); return(true); default: throw new ArgumentOutOfRangeException(); } }
private void TriggerAction() { m_currState = HandlerState.RUNNING; m_triggerCount++; Action.Trigger(); }
public bool Start() { lock (_lockObject) { // Do not start if handler is in failed state if (_handlerState == HandlerState.Failed) { return(false); } if (_handlerProxy == null) { _appDomain = CreateDomain(); RunningHandlerProxy proxy; var initResult = InitializeAndStartRunningHandler(out proxy); if (initResult.HasError) { _logger.Error("Handler: Init failed: {0}: {1}", initResult.ErrorReason, initResult.ErrorMessage); SetFailed(); return(false); } _handlerProxy = proxy; _lastStartTime = DateTime.Now; _handlerMessage = String.Empty; } _handlerState = HandlerState.Running; } return(true); }
private void AbortExecution(HandlerState state) { bool canAbort; lock (state) { if (state.IsExited) { // The handler has already exited. return; } // Check if we can call Thread.Abort() or if the handler thread is // currently in a critical section and needs to abort himself when // leaving the critical section. canAbort = !state.IsCriticalSection; state.AbortState = canAbort ? AbortState.IsAborting : AbortState.ShouldAbort; } if (canAbort) { /* The handler thread is not in a critical section so we can * directly abort it. * This needs to be done outside of the lock because Abort() could * block if the thread is currently in a finally handler (and * trying to lock on the state object), which could lead to a * deadlock. */ state.HandlerThread.Abort(state); } }
public override bool Handle(byte messageByte) { if (!CanHandle(messageByte)) { Reset(); throw new MessageHandlerException("Error with the incoming byte. This is not a valid DigitalMessage"); } switch (currentHandlerState) { case HandlerState.StartEnd: message.Port = messageByte & MessageConstants.MESSAGEPINMASK; currentHandlerState = HandlerState.LSB; return(true); case HandlerState.LSB: LSBCache = messageByte; currentHandlerState = HandlerState.MSB; return(true); case HandlerState.MSB: message.PinStates = BitHelper.PortVal2PinVals((byte)BitHelper.BytesToInt(LSBCache, messageByte)); messageBroker.CreateEvent(message); Reset(); return(false); default: throw new ArgumentOutOfRangeException(); } }
public void AssociationInitializeMethod() { ISemanticData _testISemanticData = new TestISemanticData(); Assert.IsNotNull(_testISemanticData); TestAssociation _nt = new TestAssociation(_testISemanticData, "AssociationInitializeMethod"); Assert.IsNotNull(_nt); int _eventsCount = 0; HandlerState _lastState = default(HandlerState); _nt.StateChangedEventHandler += (x, y) => { _eventsCount++; _lastState = y.State; }; Assert.AreEqual <HandlerState>(HandlerState.NoConfiguration, _nt.State.State); Assert.AreEqual <int>(0, _eventsCount); _nt.Initialize(); Assert.AreEqual <int>(1, _eventsCount); Assert.IsNotNull(_lastState); Assert.AreEqual <HandlerState>(HandlerState.Disabled, _lastState); Assert.AreEqual <HandlerState>(HandlerState.Disabled, _nt.State.State); _nt.State.Enable(); Assert.AreEqual <int>(2, _eventsCount); Assert.IsNotNull(_lastState); Assert.AreEqual <HandlerState>(HandlerState.Operational, _lastState); Assert.AreEqual <HandlerState>(HandlerState.Operational, _nt.State.State); _nt.State.Disable(); Assert.AreEqual <int>(3, _eventsCount); Assert.IsNotNull(_lastState); Assert.AreEqual <HandlerState>(HandlerState.Disabled, _lastState); Assert.AreEqual <HandlerState>(HandlerState.Disabled, _nt.State.State); }
/// <summary> /// Constructor /// </summary> public HandlerInstance(Logger logger, PackageManager packageManager) { _logger = logger; _packageManager = packageManager; Id = Guid.NewGuid(); _handlerState = HandlerState.Stopped; }
protected override bool HandleByte(byte messageByte) { switch (currentHandlerState) { case HandlerState.StartEnd: currentHandlerState = HandlerState.StringDataCommand; return(true); case HandlerState.StringDataCommand: // MAX_DATA bytes AFTER the command byte currentByteCount = 0; currentHandlerState = HandlerState.String; return(true); case HandlerState.String: if (messageByte == 0xF7) { // Get the string we have been building all along message.Message = stringBuilder.ToString(); messageBroker.CreateEvent(message); Reset(); return(false); } HandleChar(messageByte); return(true); default: throw new MessageHandlerException("Unknown SysexMessage handler state"); } }
/// <summary> /// This method is used to disable an already enabled <see cref="Association" /> object. /// This method call shall be rejected if the current State is <see cref="HandlerState.Disabled" /> or <see cref="HandlerState.NoConfiguration" />. /// </summary> /// <exception cref="System.ArgumentException">Wrong state</exception> public void Disable() { if (State != HandlerState.Operational) { throw new ArgumentException("Wrong state"); } State = HandlerState.Disabled; }
private void RecordPropertyHandler(HandlerState propertyHandlerState, string guid, string title) { PropertyHandlerState = propertyHandlerState; PropertyHandlerGuid = guid; PropertyHandlerTitle = title; OnPropertyChanged("PropertyHandlerDisplay"); OnPropertyChanged("Weight"); }
/// <summary> /// Stops the handler and does not start it again /// </summary> public bool Disable() { lock (_lockObject) { Stop(); _handlerState = HandlerState.Disabled; } return(true); }
private void RaiseHandlerState(HandlerState state) { EventHandler <AssociationStateChangedEventArgs> _hc = StateChangedEventHandler; if (_hc != null) { _hc(this, new AssociationStateChangedEventArgs(state)); } }
/// <summary> /// This method is used to enable a configured <see cref="Association" /> object. If a normal operation is possible, the state changes into <see cref="HandlerState.Operational" /> state. /// In the case of an error situation, the state changes into <see cref="HandlerState.Error" />. The operation is rejected if the current <see cref="State" /> is not <see cref="HandlerState.Disabled" />. /// </summary> /// <exception cref="System.ArgumentException">Wrong state</exception> public void Enable() { if (State != HandlerState.Disabled) { throw new ArgumentException("Wrong state"); } State = HandlerState.Operational; m_Parent.OnEnable(); }
/// <summary> /// Constructs and initializes the handler /// </summary> /// <param name = "model"></param> public AbstractHandler(ComponentModel model) { this.model = model; state = HandlerState.Valid; InitializeCustomDependencies(); if (model.ExtendedProperties.Contains("component_resolving_handler") == false) return; resolvingHandler = model.ExtendedProperties["component_resolving_handler"] as ComponentResolvingDelegate; }
public bool SetFinished() { lock (_lockObject) { _handlerState = HandlerState.Finished; CleanupProxy(false); CleanupAppDomain(); } return(true); }
public bool Stop() { lock (_lockObject) { _handlerState = HandlerState.Stopped; CleanupProxy(true); CleanupAppDomain(); } return(true); }
protected override bool HandleByte(byte messageByte) { switch (currentHandlerState) { case HandlerState.StartEnd: currentHandlerState = HandlerState.StartSysex; return(true); case HandlerState.StartSysex: // MAX_DATA bytes AFTER the command byte currentByteCount = 0; currentHandlerState = HandlerState.QueryFirmware; return(true); case HandlerState.QueryFirmware: if (messageByte > 127) { currentHandlerState = HandlerState.StartEnd; throw new MessageHandlerException(BaseExceptionMessage + "Major Version should be < 128"); } currentHandlerState = HandlerState.MajorVersion; message.MajorVersion = messageByte; return(true); case HandlerState.MajorVersion: if (messageByte > 127) { currentHandlerState = HandlerState.StartEnd; throw new MessageHandlerException(BaseExceptionMessage + "Minor Version should be < 128"); } currentHandlerState = HandlerState.MinorVersion; message.MinorVersion = messageByte; return(true); case HandlerState.MinorVersion: currentHandlerState = HandlerState.FirmwareName; HandleChar(messageByte); return(true); case HandlerState.FirmwareName: if (messageByte == MessageConstants.SYSEX_END) { // Get the string we have been building all along message.FirmwareName = stringBuilder.ToString(); messageBroker.CreateEvent(message); Reset(); return(false); } HandleChar(messageByte); return(true); default: throw new MessageHandlerException("Unknown SysexMessage handler state"); } }
public Controller() { SetEnabled = true; IsStoped = true; OnceTime = false; Log = new Stopwatch(); Timing = new Stopwatch(); State = new HandlerState(); Timeout = new TimeSpan(0, 0, 0); Intervel = new TimeSpan(1, 0, 0); }
public Controller() { SetEnabled = true; IsStoped = true; OnceTime = false; Log = new Stopwatch(); Timing = new Stopwatch(); State = new HandlerState(); Timeout = new TimeSpan(0, 0, 0); Intervel = new TimeSpan(1, 0, 0); }
/// <summary> /// Tells the handler to keep running but without generating additional jobs /// </summary> public bool Pause() { lock (_lockObject) { if (_handlerState == HandlerState.Running || _handlerState == HandlerState.Idle) { _handlerState = HandlerState.Paused; return(true); } } return(false); }
/// <summary> /// Re-enables the handler so it could start again /// </summary> public bool Enable() { lock (_lockObject) { if (_handlerState == HandlerState.Disabled) { _handlerState = HandlerState.Stopped; return(true); } } return(false); }
public async Task Sync_handler_correctly_calls_handler_method_and_wraps_with_completed_task() { var method = typeof(IHandler).GetMethod("B") !; var handler = Substitute.For <IHandler>(); var state = new HandlerState(method, handler); var args = new object[] { 1 }; await HandlerSubscriber.SyncHandler(args, state); handler.Received() .B(1); }
public async Task Async_handler_correctly_calls_handler_method() { var method = typeof(IHandler).GetMethod("A") !; var handler = Substitute.For <IHandler>(); var state = new HandlerState(method, handler); var args = new object[] { 1, "s" }; await HandlerSubscriber.AsyncHandler(args, state); await handler.Received() .A(1, "s"); }
protected override bool HandleByte(byte messageByte) { switch (currentState) { case HandlerState.StartEnd: currentState = HandlerState.SysexCommand; return(true); case HandlerState.SysexCommand: currentState = HandlerState.PinMode; return(true); case HandlerState.PinMode: // If the message has finished Reset and return that we won't handle other bytes if (messageByte == MessageConstants.SYSEX_END) { Reset(); messageBroker.CreateEvent(new CapabilitiesFinishedMessage()); return(false); } // We finished with a pin so create a capability message for this pin // we don't change the currentState because the next byte could be // a mode byte, or a finish message byte if (messageByte == MessageConstants.FINISHED_PIN_CAPABILITIES) { message.PinNo = currentPin++; messageBroker.CreateEvent(message); message = new CapabilityMessage(); return(true); } // Some assurance that we get an actual mode if (messageByte > Enum.GetValues(typeof(PinModes)).Length) { Reset(); throw new MessageHandlerException(BaseExceptionMessage + "There is no such pin mode"); } currentMode = (PinModes)messageByte; currentState = HandlerState.PinResolution; return(true); case HandlerState.PinResolution: message.Modes[currentMode] = messageByte; currentState = HandlerState.PinMode; return(true); default: throw new ArgumentOutOfRangeException(); } }
/// <summary> /// Start handler /// </summary> public void Start() { if (BluetoothRadio.IsSupported) { State = HandlerState.Working; Thread thread = new Thread(EstabilishBtConnection); thread.Start(); } else MessageBox.Show(@"Error to start SingleHandler. Reasons: 1. Bluetooth-module is not supported. 2. Bluetooth is turn off. "); }
protected override bool HandleByte(byte messageByte) { switch (currentHandlerState) { case HandlerState.StartEnd: currentHandlerState = HandlerState.Command; return(true); case HandlerState.Command: currentHandlerState = HandlerState.PinNo; return(true); case HandlerState.PinNo: if (messageByte > MessageConstants.MAX_PINS) { throw new MessageHandlerException(BaseExceptionMessage + "The pin number is wrong"); } message.PinNo = messageByte; currentHandlerState = HandlerState.PinMode; return(true); case HandlerState.PinMode: if (messageByte >= Enum.GetValues(typeof(PinModes)).Length) { throw new MessageHandlerException(BaseExceptionMessage + "This is no valid PinMode"); } message.Mode = (PinModes)messageByte; currentHandlerState = HandlerState.PinState; return(true); case HandlerState.PinState: if (messageByte == MessageConstants.SYSEX_END) { if (stateBytesReceived == 0) { throw new MessageHandlerException(BaseExceptionMessage + "There was no state in the message for pin " + message.PinNo); } messageBroker.CreateEvent(message); Reset(); return(false); } message.State |= messageByte << (stateBytesReceived * 7); stateBytesReceived++; return(true); default: throw new ArgumentOutOfRangeException(); } }
/// <summary> /// Start handler /// </summary> public void Start() { if (BluetoothRadio.IsSupported) { State = HandlerState.Working; Thread thread = new Thread(EstabilishBtConnection); thread.Start(); } else { MessageBox.Show(@"Error to start SingleHandler. Reasons: 1. Bluetooth-module is not supported. 2. Bluetooth is turn off. "); } }
private async Task RunMonitoringTask(HandlerState state, int timeout) { // Wait until the handler thread entered the try-block. // Use a synchronous wait because we expect this to be a very short // period of time. state.WaitSemaphore.Wait(); // Now asynchronously wait until the specified time has passed or the // semaphore has been released. In the latter case there is no need to // call AbortExecution(). bool completed = await state.WaitSemaphore.WaitAsync(timeout); // Abort the handler thread. if (!completed) { AbortExecution(state); } }
/// <summary> /// Connect to device and handle received packets from connected device. /// </summary> private void EstabilishBtConnection() { bool isConnected = false; while (State != HandlerState.Finished) { // Try listen. if (isConnected) { NetworkStream stream = _client.GetStream(); byte[] data = new byte[PacketSize]; // If device is disconnected... infinity loop, i guess. Because value of ReadTimeout is -1. stream.Read(data, 0, PacketSize); stream.Flush(); Action(data); } else // Try connect, if is not connected { isConnected = IsGlove ? ConnectArduino(ref _client, MacAddress) : ConnectAndroid(ref _listener, ref _client); if (isConnected) { isConnected = _client != null && _client.Connected; } } } if (_client != null) { _client.GetStream().Close(); _client.Dispose(); } if (_listener != null) { _listener.Server.Dispose(); _listener.Stop(); } State = HandlerState.Finished; }
/// <summary> /// Checks for idle time and sets the status appropriately /// </summary> public void CheckIdle() { bool isInIdleTime = false; if (_idleInfo != null) { // Set to idle if needed var now = DateTime.Now.TimeOfDay; if (_idleInfo.Start < _idleInfo.End) { if (now >= _idleInfo.Start && now <= _idleInfo.End) { isInIdleTime = true; } } else { if (now >= _idleInfo.Start || now <= _idleInfo.End) { isInIdleTime = true; } } } lock (_lockObject) { // Check if we're outside the idletime but the handler is still idle if (!isInIdleTime && _handlerState == HandlerState.Idle) { // Set it to running _handlerState = HandlerState.Running; } // We're inside the idle time but the handler is still running if (isInIdleTime && _handlerState == HandlerState.Running) { // Set it to idle _handlerState = HandlerState.Idle; } } }
static bool Compare(ref HandlerState handler, ref HandlerState composite) { var hhashes = handler.BlockSigInfos[handler.BlockIndex].Hashes; int hi = handler.HashIndex; var chashes = composite.BlockSigInfos[composite.BlockIndex].Hashes; int ci = composite.HashIndex; while (true) { if (hi >= hhashes.Count && ci >= chashes.Count) { break; } if (hi >= hhashes.Count) { if (handler.BlockSigInfos[handler.BlockIndex].EndsInRet) { break; } } if (hi >= hhashes.Count || ci >= chashes.Count) { return(false); } var hhash = hhashes[hi++]; var chash = chashes[ci++]; if (chash != hhash) { return(false); } } handler.HashIndex = hi; composite.HashIndex = ci; return(true); }
public override bool Handle(byte messageByte) { if (!CanHandle(messageByte)) { Reset(); throw new MessageHandlerException(BaseExceptionMessage); } switch (currentHandlerState) { case HandlerState.StartEnd: currentHandlerState = HandlerState.MajorVersion; return(true); case HandlerState.MajorVersion: if (messageByte > 127) { currentHandlerState = HandlerState.StartEnd; throw new MessageHandlerException(BaseExceptionMessage + "Major Version should be < 128."); } message.MajorVersion = messageByte; currentHandlerState = HandlerState.MinorVersion; return(true); case HandlerState.MinorVersion: if (messageByte > 127) { currentHandlerState = HandlerState.StartEnd; throw new MessageHandlerException(BaseExceptionMessage + "Minor Version should be < 128."); } message.MinorVersion = messageByte; messageBroker.CreateEvent(message); Reset(); return(false); default: throw new ArgumentOutOfRangeException(); } }
static bool Compare(ref HandlerState handler, ref HandlerState composite) { var hinstrs = handler.Blocks[handler.BlockIndex].Instructions; int hi = handler.InstructionIndex; var cinstrs = composite.Blocks[composite.BlockIndex].Instructions; int ci = composite.InstructionIndex; while (true) { if (hi >= hinstrs.Count && ci >= cinstrs.Count) break; if (hi >= hinstrs.Count || ci >= cinstrs.Count) return false; var hinstr = hinstrs[hi++]; var cinstr = cinstrs[ci++]; if (hinstr.OpCode.Code == Code.Nop || cinstr.OpCode.Code == Code.Nop) { if (hinstr.OpCode.Code != Code.Nop) hi--; if (cinstr.OpCode.Code != Code.Nop) ci--; continue; } if (hi == hinstrs.Count && hinstr.OpCode.Code == Code.Ret) { if (cinstr.OpCode.Code != Code.Br && cinstr.OpCode.Code != Code.Ret) ci--; break; } if (hinstr.OpCode.Code != cinstr.OpCode.Code) return false; if (hinstr.OpCode.Code == Code.Ldfld && hi + 1 < hinstrs.Count && ci + 1 < cinstrs.Count) { var hfield = hinstr.Operand as FieldDef; var cfield = cinstr.Operand as FieldDef; if (hfield != null && cfield != null && !hfield.IsStatic && !cfield.IsStatic && hfield.DeclaringType == handler.HandlerMethod.Method.DeclaringType && cfield.DeclaringType == composite.HandlerMethod.Method.DeclaringType && SignatureEqualityComparer.Instance.Equals(hfield.Signature, cfield.Signature)) { cinstr = cinstrs[ci++]; hinstr = hinstrs[hi++]; if (cinstr.OpCode.Code != Code.Ldc_I4 || hinstr.OpCode.Code != Code.Ldc_I4) return false; continue; } } if (!CompareOperand(hinstr.OpCode.OperandType, cinstr.Operand, hinstr.Operand)) return false; } handler.InstructionIndex = hi; composite.InstructionIndex = ci; return true; }
public FindHandlerState(HandlerState compositeState, Dictionary<int, bool> visitedCompositeBlocks, bool done) { this.CompositeState = compositeState; this.VisitedCompositeBlocks = new Dictionary<int, bool>(visitedCompositeBlocks); this.Done = done; }
protected void SetNewState(HandlerState newState) { if (state != newState) { state = newState; RaiseHandlerStateChanged(); } }
/// <summary> /// Constructs and initializes the handler /// </summary> /// <param name = "model"></param> protected AbstractHandler(ComponentModel model) { this.model = model; state = HandlerState.Valid; InitializeCustomDependencies(); }
/// <summary> /// Initializes a new instance of the <see cref="AssociationStateChangedEventArgs"/> class. /// </summary> /// <param name="state">The state of the configurable object state <see cref="HandlerState"/>.</param> public AssociationStateChangedEventArgs(HandlerState state) { State = state; }
private void RaiseHandlerState(HandlerState state) { EventHandler<AssociationStateChangedEventArgs> _hc = StateChangedEventHandler; if (_hc != null) _hc(this, new AssociationStateChangedEventArgs(state)); }
protected void SetNewState(HandlerState newState) { state = newState; }
public void InitState() { _state = new HandlerState { socket = new MessageWebSocket(), subbedChannels = new List<string>() }; _state.socket.Closed += (sender, args) => _state.closed = true; _state.socket.MessageReceived += (sender, args) => { try { JArray messages; using (var reader = args.GetDataReader()) { messages = JArray.Parse(reader.ReadString(reader.UnconsumedBufferLength)); } foreach (var message in messages) { ProcessMessage(message); } } catch { _state.socket.Dispose(); _state.closed = true; OnDisconnect(); } }; }
static bool Compare(ref HandlerState handler, ref HandlerState composite) { var hhashes = handler.BlockSigInfos[handler.BlockIndex].Hashes; int hi = handler.HashIndex; var chashes = composite.BlockSigInfos[composite.BlockIndex].Hashes; int ci = composite.HashIndex; while (true) { if (hi >= hhashes.Count && ci >= chashes.Count) break; if (hi >= hhashes.Count) { if (handler.BlockSigInfos[handler.BlockIndex].EndsInRet) break; } if (hi >= hhashes.Count || ci >= chashes.Count) return false; var hhash = hhashes[hi++]; var chash = chashes[ci++]; if (chash != hhash) return false; } handler.HashIndex = hi; composite.HashIndex = ci; return true; }
/// <summary> /// This method is used to enable a configured <see cref="Association" /> object. If a normal operation is possible, the state changes into <see cref="HandlerState.Operational" /> state. /// In the case of an error situation, the state changes into <see cref="HandlerState.Error" />. The operation is rejected if the current <see cref="State" /> is not <see cref="HandlerState.Disabled" />. /// </summary> /// <exception cref="System.ArgumentException">Wrong state</exception> public void Enable() { if (State != HandlerState.Disabled) throw new ArgumentException("Wrong state"); State = HandlerState.Operational; m_Parent.OnEnable(); }
bool Matches(List<BlockSigInfo> handler, ref FindHandlerState findState) { HandlerState? nextState = null; stack.Clear(); stack.Push(new MatchState(new HandlerState(handler, 0, 0), findState.CompositeState)); while (stack.Count > 0) { var matchState = stack.Pop(); if (matchState.CompositeState.HashIndex == 0) { if (findState.VisitedCompositeBlocks.ContainsKey(matchState.CompositeState.BlockIndex)) continue; findState.VisitedCompositeBlocks[matchState.CompositeState.BlockIndex] = true; } else { if (!findState.VisitedCompositeBlocks.ContainsKey(matchState.CompositeState.BlockIndex)) throw new ApplicationException("Block hasn't been visited"); } if (!Compare(ref matchState.OtherState, ref matchState.CompositeState)) return false; var hblock = matchState.OtherState.BlockSigInfos[matchState.OtherState.BlockIndex]; var hinstrs = hblock.Hashes; int hi = matchState.OtherState.HashIndex; var cblock = matchState.CompositeState.BlockSigInfos[matchState.CompositeState.BlockIndex]; var cinstrs = cblock.Hashes; int ci = matchState.CompositeState.HashIndex; if (hi < hinstrs.Count) return false; if (ci < cinstrs.Count) { if (hblock.Targets.Count != 0) return false; if (hblock.EndsInRet) { if (nextState != null) return false; nextState = matchState.CompositeState; } } else { if (cblock.Targets.Count != hblock.Targets.Count) return false; if (cblock.HasFallThrough != hblock.HasFallThrough) return false; for (int i = 0; i < cblock.Targets.Count; i++) { var hs = new HandlerState(handler, hblock.Targets[i], 0); var cs = new HandlerState(findState.CompositeState.BlockSigInfos, cblock.Targets[i], 0); stack.Push(new MatchState(hs, cs)); } } } if (nextState == null && findState.VisitedCompositeBlocks.Count != findState.CompositeState.BlockSigInfos.Count) nextState = GetNextHandlerState(ref findState); if (nextState == null) { if (findState.VisitedCompositeBlocks.Count != findState.CompositeState.BlockSigInfos.Count) return false; findState.Done = true; return true; } else { if (findState.CompositeState.BlockIndex == nextState.Value.BlockIndex && findState.CompositeState.HashIndex == nextState.Value.HashIndex) return false; findState.CompositeState = nextState.Value; if (findState.CompositeState.HashIndex == 0) findState.VisitedCompositeBlocks.Remove(findState.CompositeState.BlockIndex); return true; } }
private void HotKeyPressed(object sender, HotKeyManager.HotKeyEventArgs e) { bool lockTaken = false; try { m_SpinLock.Enter(ref lockTaken); if (e.Modifiers == 0 && m_CurrentItem != null) { SpinWait.SpinUntil(() => !HotKeyManager.IsKeyPressed(e.Key)); if (m_KeyHook_KEYS.Contains(e.Key)) { long buyPrice = m_CurrentItem.BuyPrice + 1; if (CopperValue >= 0) { buyPrice = (long)((Math.Floor(m_CurrentItem.BuyPrice / 100.0) * 100) + CopperValue); if (buyPrice <= m_CurrentItem.BuyPrice + 1) buyPrice += 100; } long buyPriceC = (buyPrice % 100); long buyPriceS = (long)(Math.Floor(buyPrice / 100.0) % 100); long buyPriceG = (long)(Math.Floor(buyPrice / 10000.0)); switch (m_CurrentState) { case HandlerState.SEARCH: SendKeys.Send(m_CurrentItem.Name); m_CurrentState = HandlerState.ENTERG; break; case HandlerState.ENTERG: SendKeys.Send(buyPriceG.ToString()); m_CurrentState = HandlerState.ENTERS; break; case HandlerState.ENTERS: SendKeys.Send(buyPriceS.ToString()); m_CurrentState = HandlerState.ENTERC; break; case HandlerState.ENTERC: SendKeys.Send(buyPriceC.ToString()); m_CurrentState = HandlerState.NEXT; break; case HandlerState.NEXT: m_CurrentItem = null; m_CurrentState = HandlerState.SEARCH; break; } } else if (m_KeyHook_KEYS_SKIP.Contains(e.Key)) { m_CurrentItem = null; m_CurrentState = HandlerState.SEARCH; } } } finally { if (lockTaken) m_SpinLock.Exit(); } }
/// <summary> /// Connect to device and handle received packets from connected device. /// </summary> private void EstabilishBtConnection() { bool isConnected = false; while (State != HandlerState.Finished) { // Try listen. if (isConnected) { NetworkStream stream = _client.GetStream(); byte[] data = new byte[PacketSize]; // If device is disconnected... infinity loop, i guess. Because value of ReadTimeout is -1. stream.Read(data, 0, PacketSize); stream.Flush(); Action(data); } else // Try connect, if is not connected { isConnected = IsGlove ? ConnectArduino(ref _client, MacAddress) : ConnectAndroid(ref _listener, ref _client); if (isConnected) isConnected = _client != null && _client.Connected; } } if (_client != null) { _client.GetStream().Close(); _client.Dispose(); } if (_listener != null) { _listener.Server.Dispose(); _listener.Stop(); } State = HandlerState.Finished; }
/// <summary> /// Constructs and initializes the handler /// </summary> /// <param name="model"></param> public AbstractHandler(ComponentModel model) { this.model = model; state = HandlerState.Valid; customParameters = new HybridDictionary(true); }
public FindHandlerState(HandlerState compositeState) { this.CompositeState = compositeState; this.VisitedCompositeBlocks = new Dictionary<int, bool>(); this.Done = false; }
/// <summary> /// Continue to get data from external device to queue, but do not processing. /// Action`s data from external device is saved for future processing. /// </summary> public void Pause() { State = HandlerState.Pause; }
/// <summary> /// Get data but do not save actions in queue. Ignore = Save in SingleHandler, not MultiHandler. /// </summary> public void Ignore() { State = HandlerState.Ignoring; }
public MatchState(HandlerState OtherState, HandlerState CompositeState) { this.OtherState = OtherState; this.CompositeState = CompositeState; }
/// <summary> /// This method is used to disable an already enabled <see cref="Association" /> object. /// This method call shall be rejected if the current State is <see cref="HandlerState.Disabled" /> or <see cref="HandlerState.NoConfiguration" />. /// </summary> /// <exception cref="System.ArgumentException">Wrong state</exception> public void Disable() { if (State != HandlerState.Operational) throw new ArgumentException("Wrong state"); State = HandlerState.Disabled; }