Push pin to component
483019
def <<(pin_)
      if pin_.kind_of?(Input)
        @inputs << pin_
      elsif pin_.kind_of?(Output)
        @outputs << pin_
      elsif pin_.kind_of?(Array) 
        # push an array of pin
        pin_.each { |p|
          self << p
        }
      end
      pin_.set_component(self)
    end
458238
void pin() {
		while (true) {
			int refCnt = pendingReferences.get();

			if (refCnt >= 0) {
				if (pendingReferences.compareAndSet(refCnt, refCnt + subpartitions.length)) {
					break;
				}
			}
			else {
				throw new IllegalStateException("Released.");
			}
		}
	}
1052957
function pushToEditUrl(sSegment) {
				if (sSegment.includes("($uid=")) {
					prepareKeyPredicate(stripPredicate(sSegment));
				} else {
					aEditUrl.push(sSegment);
				}
			}
1355078
final void push(UniCompletion<?,?> c) {
        if (c != null) {
            while (result == null && !tryPushStack(c))
                lazySetNext(c, null); // clear on failure
        }
    }
374080
def insertComponent(self, index, comp):
        """"""
        # new component needs to be wrapped
        if self.columnCountForRow(index.row()) == 0:
            self.beginInsertRows(QtCore.QModelIndex(), index.row(), index.row())
            self._stim.insertComponent(comp, index.row(), index.column())
            self.endInsertRows()
        else:
            self._stim.insertComponent(comp, index.row(), index.column())

        self.samplerateChanged.emit(self._stim.samplerate())
489653
private void pushProductOfIntArrayOnStack() {
    Label beginScopeLabel = new Label();
    Label endScopeLabel = new Label();

    int dimsArrayIndex = newLocal("[I", beginScopeLabel, endScopeLabel);
    int counterIndex = newLocal("I", beginScopeLabel, endScopeLabel);
    int productIndex = newLocal("I", beginScopeLabel, endScopeLabel);
    Label loopLabel = new Label();
    Label endLabel = new Label();

    super.visitLabel(beginScopeLabel);

    // stack: ... intArray
    super.visitVarInsn(Opcodes.ASTORE, dimsArrayIndex);
    // -> stack: ...

    // counter = 0
    super.visitInsn(Opcodes.ICONST_0);
    super.visitVarInsn(Opcodes.ISTORE, counterIndex);
    // product = 1
    super.visitInsn(Opcodes.ICONST_1);
    super.visitVarInsn(Opcodes.ISTORE, productIndex);
    // loop:
    super.visitLabel(loopLabel);
    // if index >= arraylength goto end:
    super.visitVarInsn(Opcodes.ILOAD, counterIndex);
    super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex);
    super.visitInsn(Opcodes.ARRAYLENGTH);
    super.visitJumpInsn(Opcodes.IF_ICMPGE, endLabel);
    // product = product * max(array[counter],1)
    super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex);
    super.visitVarInsn(Opcodes.ILOAD, counterIndex);
    super.visitInsn(Opcodes.IALOAD);
    super.visitInsn(Opcodes.DUP);
    Label nonZeroDimension = new Label();
    super.visitJumpInsn(Opcodes.IFNE, nonZeroDimension);
    super.visitInsn(Opcodes.POP);
    super.visitInsn(Opcodes.ICONST_1);
    super.visitLabel(nonZeroDimension);
    super.visitVarInsn(Opcodes.ILOAD, productIndex);
    super.visitInsn(Opcodes.IMUL); // if overflow happens it happens.
    super.visitVarInsn(Opcodes.ISTORE, productIndex);
    // iinc counter 1
    super.visitIincInsn(counterIndex, 1);
    // goto loop
    super.visitJumpInsn(Opcodes.GOTO, loopLabel);
    // end:
    super.visitLabel(endLabel);
    // re-push dimensions array
    super.visitVarInsn(Opcodes.ALOAD, dimsArrayIndex);
    // push product
    super.visitVarInsn(Opcodes.ILOAD, productIndex);

    super.visitLabel(endScopeLabel);
  }
86571
@Override
    public void setValue(Pin pin, Number value) {
        super.setValue(pin, value.doubleValue());
    }
736958
def write(self, pin, value):
        
        port, pin = self.pin_to_port(pin)
        portname = 'A'
        if port == 1:
            portname = 'B'
        self._update_register('GPIO' + portname, pin, value)
        self.sync()
355977
function ( PinRange ) {
				var Pin = _Pins [ PinRange ];
				Pin.options.map.setView ( Pin.getLatLng ( ), 17);
				
				return Pin;
			}
942783
public void addComponent(JComponent component, boolean bLinkComponentToConverter)
    {
        this.add(Box.createHorizontalStrut(3));
        
        if (this.getComponentCount() < brgComponentsLinkedToConverter.length)
            brgComponentsLinkedToConverter[this.getComponentCount()] = bLinkComponentToConverter;

        this.add(component);
}
604903
public final void push(Mem src)
  {
    assert(src.size() == 2 || src.size() == (is64() ? 8 : 4));
    emitX86(INST_PUSH, src);
  }
287341
def push_mark(pos = @point)
      @mark = new_mark
      @mark.location = pos
      @mark_ring.push(@mark)
      if self != Buffer.minibuffer
        global_mark_ring = Buffer.global_mark_ring
        if global_mark_ring.empty? || global_mark_ring.current.buffer != self
          push_global_mark(pos)
        end
      end
    end
650422
def set_pin_mode(pin, mode)
      pins[pin].mode = mode
      write(PIN_MODE, pin, mode)
    end
1151096
def push(self, obj):
        """"""
        rv = getattr(self._local, "stack", None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(obj)
        return rv
978812
function _insertPoint(eventData, insertInfo) {
  const toolData = getToolState(eventData.element, this.name);

  if (toolData === undefined) {
    return;
  }

  // Get the toolData from insertInfo
  const data = toolData.data[insertInfo.toolIndex];

  const insertIndex = _getInsertionIndex(insertInfo);

  if (insertIndex === Infinity) {
    return;
  }

  const handleData = new FreehandHandleData(eventData.currentPoints.image);

  const points = data.handles.points;

  // Add the new handle
  points.splice(insertIndex, 0, handleData);

  // Add the line from the previous handle to the inserted handle (note the tool is now one increment longer)
  points[insertIndex - 1].lines.pop();
  points[insertIndex - 1].lines.push(eventData.currentPoints.image);

  addLine(points, insertIndex);

  data.active = true;
  data.highlight = true;

  // Force onImageRendered to fire
  data.invalidated = true;
  external.cornerstone.updateImage(eventData.element);
}
976707
private final void push() {
    if (ptr >= stack.length) {
      // doubling here is probably overkill, but anything that needs to double more than
      // once (32 levels deep) is very atypical anyway.
      byte[] newstack = new byte[stack.length<<1];
      System.arraycopy(stack,0,newstack,0,stack.length);
      stack = newstack;
    }
    stack[ptr++] = state;
  }
1133035
function collectComponent(component) {
    var name = component.constructor.name;
    (components[name] || (components[name] = [])).push(component);
  }