public FlightControl(Vessel vessel) { rotation = new Vector(0, 0, 0); translation = new Vector(0, 0, 0); neutral = new Flushable<bool>(); killRotation = new Flushable<bool>(); bound = true; this.vessel = vessel; Vessel.OnFlyByWire += OnFlyByWire; }
public FlightControl(Vessel vessel) { rotation = new Vector(0, 0, 0); translation = new Vector(0, 0, 0); neutral = new Flushable <bool>(); killRotation = new Flushable <bool>(); bound = true; this.vessel = vessel; Vessel.OnFlyByWire += OnFlyByWire; }
public FlightControl(Vessel vessel) { neutral = new Flushable<bool>(); killRotation = new Flushable<bool>(); bound = false; Vessel = vessel; floatSuffixes = new List<string> { "YAW", "PITCH", "ROLL", "STARBOARD", "TOP", "FORE", "MAINTHROTTLE", "WHEELTHROTTLE", "WHEELSTEER" }; vectorSuffixes = new List<string> { "ROTATION", "TRANSLATION" }; }
public FlightControl(Vessel vessel) { neutral = new Flushable <bool>(); killRotation = new Flushable <bool>(); bound = false; Vessel = vessel; floatSuffixes = new List <string> { "YAW", "PITCH", "ROLL", "STARBOARD", "TOP", "FORE", "MAINTHROTTLE", "WHEELTHROTTLE", "WHEELSTEER" }; vectorSuffixes = new List <string> { "ROTATION", "TRANSLATION" }; }
/// <summary> /// Flushes the given object. The same as calling <seealso cref="Flushable.flush()"/>, but /// errors while flushing are silently ignored. /// </summary> public static void flushSilently(Flushable flushable) { try { if (flushable != null) { flushable.flush(); } } catch (IOException ignore) { LOG.debugCloseException(ignore); } }
void OnTriggerEnter2D(Collider2D col) { if (col.gameObject.GetComponent <Flushable>() != null) { Flushable flushable = col.gameObject.GetComponent <Flushable>(); if ((goodReceptacle && flushable.isGood == true) || (!goodReceptacle && flushable.isGood == false)) { Score.AddScore(flushable.scoreValue); Debug.Log("score"); } else { Timer.Penalty(flushable.time); Debug.Log("penalty"); } Debug.Log(col.gameObject); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotCallTransactionClosedOnFailedForceLogToDisk() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotCallTransactionClosedOnFailedForceLogToDisk() { // GIVEN long txId = 3; string failureMessage = "Forces a failure"; FlushablePositionAwareChannel channel = spy(new InMemoryClosableChannel()); IOException failure = new IOException(failureMessage); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.io.Flushable flushable = mock(java.io.Flushable.class); Flushable flushable = mock(typeof(Flushable)); doAnswer(invocation => { invocation.callRealMethod(); return(flushable); }).when(channel).prepareForFlush(); doThrow(failure).when(flushable).flush(); when(_logFile.Writer).thenReturn(channel); TransactionMetadataCache metadataCache = new TransactionMetadataCache(); TransactionIdStore transactionIdStore = mock(typeof(TransactionIdStore)); when(transactionIdStore.NextCommittingTransactionId()).thenReturn(txId); Mockito.reset(_databaseHealth); TransactionAppender appender = Life.add(new BatchingTransactionAppender(_logFiles, NO_ROTATION, metadataCache, transactionIdStore, BYPASS, _databaseHealth)); // WHEN TransactionRepresentation transaction = mock(typeof(TransactionRepresentation)); when(transaction.AdditionalHeader()).thenReturn(new sbyte[0]); try { appender.Append(new TransactionToApply(transaction), _logAppendEvent); fail("Expected append to fail. Something is wrong with the test itself"); } catch (IOException e) { // THEN assertSame(failure, e); verify(transactionIdStore, times(1)).nextCommittingTransactionId(); verify(transactionIdStore, never()).transactionClosed(eq(txId), anyLong(), anyLong()); verify(_databaseHealth).panic(failure); } }
private static void Main() { // create bridge, with default setup // it will lookup jni4net.j.jar next to jni4net.n.dll Bridge.CreateJVM(new BridgeSetup() { Verbose = true }); // here you go! [email protected]("Hello Java world!"); // OK, simple hello is boring, let's play with Java properties // they are Hashtable realy Properties javaSystemProperties = java.lang.System.getProperties(); // let's enumerate all keys. // We use Adapt helper to convert enumeration from java o .NET foreach (java.lang.String key in Adapt.Enumeration(javaSystemProperties.keys())) { [email protected](key); // this is automatic conversion of CLR string to java.lang.String [email protected](" : "); // we use the hashtable Object value = javaSystemProperties.get(key); // and this is CLR ToString() redirected to Java toString() method string valueToString = value.ToString(); [email protected](valueToString); } // Java output is really Stream PrintStream stream = java.lang.System.@out; // it implements java.io.Flushable interface Flushable flushable = stream; flushable.flush(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldBeAbleToWriteACheckPoint() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldBeAbleToWriteACheckPoint() { // Given FlushablePositionAwareChannel channel = mock(typeof(FlushablePositionAwareChannel), RETURNS_MOCKS); Flushable flushable = mock(typeof(Flushable)); when(channel.PrepareForFlush()).thenReturn(flushable); when(channel.PutLong(anyLong())).thenReturn(channel); when(_logFile.Writer).thenReturn(channel); BatchingTransactionAppender appender = Life.add(CreateTransactionAppender()); // When appender.CheckPoint(new LogPosition(1L, 2L), LogCheckPointEvent.NULL); // Then verify(channel, times(1)).putLong(1L); verify(channel, times(1)).putLong(2L); verify(channel, times(1)).prepareForFlush(); verify(flushable, times(1)).flush(); verify(_databaseHealth, never()).panic(any()); }
public long maybeLimitIO(long previousStamp, int recentlyCompletedIOs, Flushable flushable) { return(0); }
// The stamp is in two 32-bit parts: // The high bits are the number of IOs performed since the last pause. // The low bits is the 32-bit timestamp in milliseconds (~25 day range) since the last pause. // We keep adding summing up the IOs until either a quantum elapses, or we've exhausted the IOs we're allowed in // this quantum. If we've exhausted our IOs, we pause for the rest of the quantum. // We don't make use of the Flushable at this point, because IOs from fsyncs have a high priority, so they // might jump the IO queue and cause delays for transaction log IOs. Further, fsync on some file systems also // flush the entire IO queue, which can cause delays on IO rate limited cloud machines. // We need the Flushable to be implemented in terms of sync_file_range before we can make use of it. // NOTE: The check-pointer IOPS setting is documented as being a "best effort" hint. We are making use of that // wording here, and not compensating for over-counted IOs. For instance, if we receive 2 quantums worth of IOs // in one quantum, we are not going to sleep for two quantums. The reason is that such compensation algorithms // can easily over-compensate, and end up sleeping a lot more than what makes sense for other rate limiting factors // in the system, thus wasting IO bandwidth. No, "best effort" here means that likely end up doing a little bit // more IO than what we've been configured to allow, but that's okay. If it's a problem, people can just reduce // their IOPS limit setting a bit more. public override long MaybeLimitIO(long previousStamp, int recentlyCompletedIOs, Flushable flushable) { long state = _stateUpdater.get(this); if (GetDisabledCounter(state) > 0) { return(Org.Neo4j.Io.pagecache.IOLimiter_Fields.INITIAL_STAMP); } long now = CurrentTimeMillis() & _timeMask; long then = previousStamp & _timeMask; if (now - then > QUANTUM_MILLIS) { return(now + ((( long )recentlyCompletedIOs) << TIME_BITS)); } long ioSum = (previousStamp >> TIME_BITS) + recentlyCompletedIOs; if (ioSum >= GetIOPQ(state)) { long millisLeftInQuantum = QUANTUM_MILLIS - (now - then); _pauseNanos.accept(this, TimeUnit.MILLISECONDS.toNanos(millisLeftInQuantum)); return(CurrentTimeMillis() & _timeMask); } return(then + (ioSum << TIME_BITS)); }