this value straight away and also that we don't need to persist it
197603
public synchronized void initialiseSendWindow(long sendWindow, long definedSendWindow)
    throws SIResourceException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "initialiseSendWindow", new Object[] {Long.valueOf(sendWindow), Long.valueOf(definedSendWindow)} );
     
    
    // Prior to V7 the sendWindow was not persisted unless it was modified due to a change in
    // reachability, otherwise it was stored as INFINITY (Long.MAX_VALUE). Therefore, if the
    // defined sendWindow was modified we could be in the situation where before a restart we
    // had 1000 messages indoubt, then shut the ME down, changes the defined sendWindow to 50
    // and restarted. At that point we'd set the sendWindow to 50 and suddenly we'd have 950
    // available messages again (not indoubt). We'd then be allowed to reallocate them elsewhere!
    
    // Luckily, the ability to modify the sendWindow wasn't correctly exposed prior to V7 (it's
    // now a custom property), so no-one could have modified it. So, we can interpret a value
    // of INFINITY as the original sendWindow value, which is 1000. And use that when we see it.
    if( sendWindow == RangeList.INFINITY )
    {
      this.definedSendWindow = definedSendWindow; 
      this.sendWindow = 1000; // Original default sendWindow
      
      // Now persist the 1000 to make it clearer
      persistSendWindow(this.sendWindow, null);
    }
    else
    {
      this.sendWindow = sendWindow;
      this.definedSendWindow = definedSendWindow;   
    }  
      
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "initialiseSendWindow");
  }
893741
function () {
            var val = this._value;
            if (val >= this._switchThreshold) {
                this._onContainer.style.width = this._cfg.width + "px";
                this._onContainer.style.left = "0px";
                this._offContainer.style.width = "0px";
                this._value = 1;
            } else {
                this._offContainer.style.width = this._cfg.width + "px";
                this._offContainer.style.left = "0px";
                this._onContainer.style.width = "0px";
                this._value = 0;
            }
            if (val !== this._value) {
                this._storeValue();
            }
        }
702260
public T getValue ()
    {
        // if the value is still around and it's expired, clear it
        if (_value != null && System.currentTimeMillis() >= _expires) {
            _value = null;
        }
        // then return the value (which may be cleared to null by now)
        return _value;
    }
1179095
function it_leavesNewEdgeWithNewValue() {
			it("leaves a new edge in the graph with a new value", function () {
				callItWith('k1', 'k2', 'newValue');
				expect(graph.hasEdge('k1', 'k2')).toBeTruthy();
				expect(graph.edgeValue('k1', 'k2')).toBe('newValue');
				expect(graph.edgeCount()).toBe(originalEdgeCount + 1);
			});
		}
976186
def offset(self, value):
        

        self._query = self._query.skip(value)

        return self
891549
function keepAlive(k) {
	if (k) {
		if (++keepAliveIntervalCount === 1) {
			// The actual duration doesn't really matter: it should be large but not too large.
			keepAliveIntervalId = setInterval(() => { }, 24 * 60 * 60 * 1000);
		}
	} else {
		if (--keepAliveIntervalCount === 0) {
			clearInterval(keepAliveIntervalId);
		}
	}
	debug(`keepAlive(${k}) => ${keepAliveIntervalCount}`);
}
1067125
function() {
      var source = this.getSource(),
          average = parseInt((source[0] * 0.3 + source[1] * 0.59 + source[2] * 0.11).toFixed(0), 10),
          currentAlpha = source[3];
      this.setSource([average, average, average, currentAlpha]);
      return this;
    }
853286
def compact(self):
        
        previous_value = object()
        redundant = []
        for time, value in self:
            if value == previous_value:
                redundant.append(time)
            previous_value = value
        for time in redundant:
            del self[time]
470188
function() {

		var binding = this.binding;

		var buffer = this.buffer,
			stride = this.valueSize,

			originalValueOffset = stride * 3;

		binding.getValue( buffer, originalValueOffset );

		// accu[0..1] := orig -- initially detect changes against the original
		for ( var i = stride, e = originalValueOffset; i !== e; ++ i ) {

			buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];

		}

		this.cumulativeWeight = 0;

	}
288786
public final void freeMem() {
    assert isPersisted() || _pojo != null || _key._kb[0]==Key.DVEC;
    _mem = null;
  }
1209766
def save( value )
      offset = 0
      value.class.typecodes.zip( value.values ).each do |t,v|
        @function << "#{@function.indent}*(#{GCCType.new( t ).identifier} *)( #{self} + #{offset} ) = #{v};\n"
        offset += t.storage_size
      end
    end
1031456
def stop(self):
        
        super(SimpleDependency, self).stop()
        if self.reference is not None:
            # Return a tuple of tuple
            return ((self._value, self.reference),)

        return None
899064
def single_val(self):
        
        
        sv_t = self._sv(self._tdsphere)
        sv_p = self._sv(self._tdsphere)
        
        return (sv_t, sv_p)
345115
function (value, offset) {

                if (undefined === offset) {
                    offset = this.offset;
                }

                // new Date(1970, 1, 1).getTime() - new Date(1904, 1, 1).getTime();
                var delta = -2077545600000;

                if (typeof value === 'undefined') {
                    value = delta;
                }
                else if (typeof value.getTime === 'function') {
                    value = value.getTime();
                }
                else if (/^\d+$/.test(value)) {
                    value = +value;
                }
                else {
                    value = Date.parse(value);
                }

                var time = Math.round((value - delta) / 1000);
                this.writeUint32(0, offset);
                this.writeUint32(time, offset + 4);

                return this;
            }
1234854
public function withoutDuplicates(): self
    {
        if (count($this->pairs) === count(array_count_values(array_column($this->pairs, 0)))) {
            return $this;
        }

        $pairs = array_reduce($this->pairs, [$this, 'removeDuplicates'], []);
        if ($pairs === $this->pairs) {
            return $this;
        }

        $clone = clone $this;
        $clone->pairs = $pairs;

        return $clone;
    }
176086
def clean_value(self, value):
    """"""
    if self._clean_value:
      return self._clean_value(value)
    else:
      return self.reduce_value(value)
212437
def value=(value)
      @value = @continuous ? value.to_f : value.round
      @value = [[@value, @range.min].max, @range.max].min
      @handle.x = x + padding_left + ((width - @handle.width) * (@value - @range.min) / (@range.max - @range.min).to_f)
      publish :changed, @value

      @value
    end