A small pin that represents the result of the build process
171620
def pin(value):
    ''''''
    if value is False:
        return draw_pin('Build Failed', 'red')
    elif value is True:
        return draw_pin('Build Passed')
    elif value is NOT_FOUND:
        return draw_pin('Build N / A', 'lightGray', 'black')
    return draw_pin('In progress ...', 'lightGray', 'black')
508463
@PostConstruct
	protected void postConstruct() {
		if (pixelPerUnitBased) {
			//	Calculate numerator and denominator
			if (pixelPerUnit > PIXEL_PER_METER) {
				this.numerator = pixelPerUnit / conversionFactor;
				this.denominator = 1;
			} else {
				this.numerator = 1;
				this.denominator = PIXEL_PER_METER / pixelPerUnit;
			}
			setPixelPerUnitBased(false);
		} else {
			// Calculate PPU
			this.pixelPerUnit = numerator / denominator * conversionFactor;
			setPixelPerUnitBased(true);
		}
	}
972339
def post_build(self, pkt, pay):
        
        # Compute the length of TLSPlaintext fragment
        hdr, frag = pkt[:5], pkt[5:]
        if not isinstance(self.tls_session.rcs.cipher, Cipher_NULL):
            frag = self._tls_auth_encrypt(frag)

        if self.len is not None:
            # The user gave us a 'len', let's respect this ultimately
            hdr = hdr[:3] + struct.pack("!H", self.len)
        else:
            # Update header with the length of TLSCiphertext.inner
            hdr = hdr[:3] + struct.pack("!H", len(frag))

        # Now we commit the pending write state if it has been triggered. We
        # update nothing if the pwcs was not set. This probably means that
        # we're working out-of-context (and we need to keep the default wcs).
        if self.tls_session.triggered_pwcs_commit:
            if self.tls_session.pwcs is not None:
                self.tls_session.wcs = self.tls_session.pwcs
                self.tls_session.pwcs = None
            self.tls_session.triggered_pwcs_commit = False

        return hdr + frag + pay
921821
def pin_command(self):
        """"""
        parts = [
            'pip-compile',
            '--no-header',
            '--verbose',
            '--rebuild',
            '--no-index',
            '--output-file', self.outfile,
            self.infile,
        ]
        if OPTIONS['upgrade']:
            parts.insert(3, '--upgrade')
        if self.add_hashes:
            parts.insert(1, '--generate-hashes')
        return parts
1316377
def do_build(self):
        
        tmp = self.explicit
        self.explicit = True
        b = super(KeyShareEntry, self).do_build()
        self.explicit = tmp
        return b
1349665
def do_build(self):
        
        if not self.explicit:
            self = next(iter(self))
        pkt = self.self_build()
        for t in self.post_transforms:
            pkt = t(pkt)
        pay = self.do_build_payload()
        if self.raw_packet_cache is None:
            return self.post_build(pkt, pay)
        else:
            return pkt + pay
950464
public void postConstruct() {
        Assert.isTrue(this.name != null, "name parameter cannot be null");
        Assert.isTrue(this.style != null, "style parameter cannot be null");
        Assert.isTrue(this.size > 1, "size must be greater than 1");

        Font baseFont = null;
        for (String fontName: this.name) {
            try {
                baseFont = new Font(fontName, this.style.styleId, this.size);
                break;
            } catch (Exception e) {
                // try next font in list
            }
        }

        if (baseFont == null) {
            String[] legalFonts =
                    GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
            throw new IllegalArgumentException(
                    Arrays.toString(this.name) + " does not contain a font that can be created by this Java "
                            + "Virtual Machine, legal options are: \n" + Arrays.toString(legalFonts));
        }
    }
406516
def markForRebuild( self, state = True ):
        
        self._rebuildRequired = state
        if ( state ):
            self.show()
            self.update()
777703
function ( ) {
			if ( document.getElementById ) {
				var MaindivElement = document.getElementById ( 'PinControl-MainDiv' );
				var OldPinsElement = document.getElementById ( 'PinControl-Pins' );
				if ( MaindivElement && OldPinsElement )
				{
					var NewPinsElement = _asHtmlElement ( 
						{ 
							mainElement : 'div',
							mainClass : "PinControl-Pins" , 
							pinElement : 'div',
							pinClass : "PinControl-Pin" , 
							categoryElement : 'div',
							categoryClass : "PinControl-Category" , 
							CategoryImgClass : "PinControl-Category-Img",
							textElement : 'div',
							textClass : "PinControl-Text" , 
							addressElement : 'div',
							addressClass : "PinControl-Address" , 
							phoneElement : 'div',
							phoneClass : "PinControl-Phone" , 
							urlElement : 'div',
							urlClass : "PinControl-Url" , 
							urlLength : 50 ,
							distanceElement : 'div' ,
							distanceClass : "PinControl-Distance",
							nextDistanceElement : 'div',
							nextDistanceClass : 'Pin-Print-NextDistance'
						}
					);
					NewPinsElement.id = 'PinControl-Pins';
					var OldStyle = OldPinsElement.style;
					var OldComputedStyle = window.getComputedStyle ( OldPinsElement, null );
					var OldMaxHeight;
					try
					{
						OldMaxHeight = OldComputedStyle.maxHeight;
					}
					catch ( e )
					{
						OldMaxHeight = '400px';
					}

					NewPinsElement.dataset.minimized = OldPinsElement.dataset.minimized;
					if ( 'yes' === NewPinsElement.dataset.minimized  ) {
						NewPinsElement.setAttribute ( "style", "visibility : hidden; width: 0; min-width: 0; height: 0; margin: 0.5em;" );
					}
					else {
						NewPinsElement.setAttribute ( "style", "visibility : visible; width: auto; min-width: 20em; height: auto; margin: 0.5em; max-height: "+ OldMaxHeight );
					}

					var ScrollTop = OldPinsElement.scrollTop;
					MaindivElement.replaceChild ( NewPinsElement, OldPinsElement );
					document.getElementById ( 'PinControl-Pins' ).scrollTop = ScrollTop;
				}
			}
		}
622771
function build(mode, system, cdef, out, cb) {
    logger.info('building');
    out.stdout('building');
    cb();
  }
897451
def pins(id = nil, options = {}, &_block)
      id, options = nil, id if id.is_a?(Hash)
      if id
        pin = Origen.pin_bank.find(id, options)
        unless pin
          puts <<-END
You have tried to reference pin :#{id} within #{self.class} but it does not exist, this could be
because the pin has not been defined yet or it is an alias that is not available in the current context.

If you meant to define the pin then use the add_pin method instead.

          END
          fail 'Pin not found'
        end
        pin
      else
        if options[:power_pin]
          Origen.pin_bank.power_pins
        elsif options[:ground_pin]
          Origen.pin_bank.ground_pins
        elsif options[:virtual_pin]
          Origen.pin_bank.virtual_pins
        elsif options[:other_pin]
          Origen.pin_bank.other_pins
        else
          Origen.pin_bank.pins
        end
      end
    end
723731
def pin(self, hostname, x509):
        

        key = self._x509_key(x509)
        self._storage.setdefault(hostname, set()).add(key)
1332758
function ( ) {
			
			if ( '' === _DistanceInput.value ) {
				return ;
			}

			Map.closePopup(); 

			// ... A new pin is created...
			var getPin;
			if ( typeof module !== 'undefined' && module.exports ) {
				getPin = require ('./L.Marker.Pin' );
			}
			else {
				getPin = L.marker.pin;
			}

			var Pins;
			if ( typeof module !== 'undefined' && module.exports ) {
				Pins = require ('./L.Marker.Pin.Pins' );
			}
			else {
				Pins = L.marker.pin.pins ( );
			}

			var draggableIcon = ! Pins.readOnly;

			var Pin = getPin (
				latlng,
				{
					icon : _Categories.getAt ( _CategorySelect.selectedIndex ).CategoryIcon,
					draggable : draggableIcon,
					className : 'Pin',
					title : _Categories.getAt ( _CategorySelect.selectedIndex ).CategoryName,
					phone : _PhoneInput.value,
					url : _UrlInput.value,
					distance : parseFloat ( _DistanceInput.value ),
					//text : _TextInput.value,
					text : _TextArea.value,
					address : _addressInput.value,
					pinCategory : _Categories.getAt ( _CategorySelect.selectedIndex ),
					map : Map,
				}
			);

			if ( options.exist ) {
				// The dialog was open for edition. The old pin is 
				// removed from the map and from the pin's collection
				var pinPosition = Pins.remove ( options.pinObject );
				Map.removeLayer( options.pinObject );
				Pins.push ( Pin, pinPosition );
			}
			else {
				// ... and added to the pin's collection ...
				Pins.push ( Pin );
			}

			// ... a popup and events are added to the pin ...
			Pin.bindPopup ( Pin.getHtml ( ) ).addTo ( Map );
			
			var ContextMenu;
			if ( typeof module !== 'undefined' && module.exports ) {
				ContextMenu = require ('./L.Marker.Pin.ContextMenu' );
			}
			else {
				ContextMenu = L.marker.pin.contextmenu;
			}
			Pin.on ( 'contextmenu', ContextMenu ); 
			Pin.on ( 'dblclick', ContextMenu);
			Pin.on ( 'dragend', Pins.CallbackFunction ); 
			
			/*
			if ( options.exist ) {
				// The dialog was open for edition. The old pin is 
				// removed from the map and from the pin's collection
				var NewPos = Pins.remove ( options.pinObject );
				Map.removeLayer( options.pinObject );
				Pins.order ( OldPos - 1, NewPos, false );
			}
			*/
		}
763352
function inxbuild() {
    var i, j, p, q, smallpos, smallval, previouscol = 0, startpos = 0;
    for (i = 0; i < netsize; i++) {
      p = network[i];
      smallpos = i;
      smallval = p[1]; // index on g
      // find smallest in i..netsize-1
      for (j = i + 1; j < netsize; j++) {
        q = network[j];
        if (q[1] < smallval) { // index on g
          smallpos = j;
          smallval = q[1]; // index on g
        }
      }
      q = network[smallpos];
      // swap p (i) and q (smallpos) entries
      if (i != smallpos) {
        j = q[0];   q[0] = p[0];   p[0] = j;
        j = q[1];   q[1] = p[1];   p[1] = j;
        j = q[2];   q[2] = p[2];   p[2] = j;
        j = q[3];   q[3] = p[3];   p[3] = j;
      }
      // smallval entry is now in position i

      if (smallval != previouscol) {
        netindex[previouscol] = (startpos + i) >> 1;
        for (j = previouscol + 1; j < smallval; j++)
          netindex[j] = i;
        previouscol = smallval;
        startpos = i;
      }
    }
    netindex[previouscol] = (startpos + maxnetpos) >> 1;
    for (j = previouscol + 1; j < 256; j++)
      netindex[j] = maxnetpos; // really 256
  }
1319965
private void addBuiltIn( ) {
        input1.put("inv", Operation::inv);
        input1.put("pinv", Operation::pinv);
        input1.put("rref", Operation::rref);
        input1.put("eye", Operation::eye);
        input1.put("det", Operation::det);
        input1.put("normF", Operation::normF);
        input1.put("sum", Operation::sum_one);
        input1.put("trace", Operation::trace);
        input1.put("diag", Operation::diag);
        input1.put("min", Operation::min);
        input1.put("max", Operation::max);
        input1.put("abs", Operation::abs);
        input1.put("sin", Operation::sin);
        input1.put("cos", Operation::cos);
        input1.put("atan", Operation::atan);
        input1.put("exp", Operation::exp);
        input1.put("log", Operation::log);
        input1.put("sqrt", Operation::sqrt);
        input1.put("rng", Operation::rng);

        inputN.put("normP", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.normP(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("max", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("One or two inputs expected");
            return Operation.max_two(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("min", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("One or two inputs expected");
            return Operation.min_two(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("sum", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("One or two inputs expected");
            return Operation.sum_two(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("zeros", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.zeros(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("ones", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.ones(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("rand", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.rand(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("randn", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.randn(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("kron", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.kron(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("dot", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.dot(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("pow", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.pow(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("atan2", (inputs, manager) -> {
            if (inputs.size() != 2) throw new RuntimeException("Two inputs expected");
            return Operation.atan2(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("solve", (inputs, manager) -> {
            if( inputs.size() != 2 ) throw new RuntimeException("Two inputs expected");
            return Operation.solve(inputs.get(0), inputs.get(1), manager);
        });

        inputN.put("extract", Operation::extract);
        inputN.put("extractScalar", (inputs, manager) -> {
            if( inputs.size() != 2 && inputs.size() != 3 ) throw new RuntimeException("Two or three inputs expected");
            return Operation.extractScalar(inputs, manager);
        });
    }
86571
@Override
    public void setValue(Pin pin, Number value) {
        super.setValue(pin, value.doubleValue());
    }
710766
function pin() {
        return (new \React\Promise\Promise(function (callable $resolve, callable $reject) {
            $this->client->apimanager()->endpoints->channel->pinChannelMessage($this->channel->getId(), $this->id)->done(function () use ($resolve) {
                $resolve($this);
            }, $reject);
        }));
    }