Gather the targets and markers used for stalking.
184409
function() {
        var isWindow = this.container.is(window),
            eTop = this.element.offset().top,
            offset,
            offsets = [];

        if (this.element.css('overflow') === 'auto' && !this.element.is('body')) {
            this.element[0].scrollTop = 0; // Set scroll to top so offsets are correct
        }

        this.targets = $(this.options.target);

        this.markers = $(this.options.marker).each(function(index, marker) {
            offset = $(marker).offset();

            if (!isWindow) {
                offset.top -= eTop;
            }

            offsets.push(offset);
        });

        this.offsets = offsets;
    }
524289
public void hookScannerHook(Scanner scan) {
        Iterator<ExtensionHook> iter = extensionHooks.values().iterator();
        while (iter.hasNext()) {
            ExtensionHook hook = iter.next();
            List<ScannerHook> scannerHookList = hook.getScannerHookList();

            for (ScannerHook scannerHook : scannerHookList) {
                try {
                    if (hook != null) {
                        scan.addScannerHook(scannerHook);
                    }
                    
                } catch (Exception e) {
                    logger.error(e.getMessage(), e);
                }
            }
        }
    }
390751
@Scheduled(cron = "${deployer.main.targets.scan.scheduling.cron}")
    public void scanTargets() {
        try {
            targetService.resolveTargets();
        } catch (DeployerException e) {
            logger.error("Scheduled target scan failed", e);
        }
    }
345440
def StartInterrogationHunt(self):
    """"""
    flow_name = compatibility.GetName(flows_discovery.Interrogate)
    flow_args = flows_discovery.InterrogateArgs(lightweight=False)
    description = "Interrogate run by cron to keep host info fresh."

    if data_store.RelationalDBEnabled():
      hunt_id = hunt.CreateAndStartHunt(
          flow_name,
          flow_args,
          self.token.username,
          client_limit=0,
          client_rate=50,
          crash_limit=config.CONFIG["Cron.interrogate_crash_limit"],
          description=description,
          duration=rdfvalue.Duration("1w"),
          output_plugins=self.GetOutputPlugins())
      self.Log("Started hunt %s.", hunt_id)
    else:
      with hunts_implementation.StartHunt(
          hunt_name=hunts_standard.GenericHunt.__name__,
          client_limit=0,
          flow_runner_args=rdf_flow_runner.FlowRunnerArgs(flow_name=flow_name),
          flow_args=flow_args,
          output_plugins=self.GetOutputPlugins(),
          crash_limit=config.CONFIG["Cron.interrogate_crash_limit"],
          client_rate=50,
          expiry_time=rdfvalue.Duration("1w"),
          description=description,
          token=self.token) as hunt_obj:

        hunt_obj.GetRunner().Start()
        self.Log("Started hunt %s.", hunt_obj.urn)
1186389
def markers():
    ''' 
    '''
    print("Available markers: \n\n - " + "\n - ".join(list(MarkerType)))
    print()
    print("Shortcuts: \n\n" + "\n".join(" %r: %s" % item for item in _MARKER_SHORTCUTS.items()))
492099
def listTargets(self):
        '''
            
        '''
        sql = 'select * from {}'.format(self.TABLE_ITEMS)
        cursor = self.db.execute(sql)

        return [(iid, name, path) for iid, name, path in cursor]
498874
private void checkTargets() {

        // checking current target first
        if ((m_currentTarget != null) && m_currentTarget.checkPosition(m_clientX, m_clientY, m_orientation)) {
            // in case of nested targets, check the children of the current target
            if ((m_currentTarget instanceof I_CmsNestedDropTarget)
                && ((I_CmsNestedDropTarget)m_currentTarget).hasDnDChildren()) {
                for (I_CmsDropTarget target : ((I_CmsNestedDropTarget)m_currentTarget).getDnDChildren()) {
                    if ((target != m_currentTarget) && target.checkPosition(m_clientX, m_clientY, m_orientation)) {
                        // notifying controller, if false is returned, placeholder will not be positioned inside target
                        if (m_controller.onTargetEnter(m_draggable, target, this)) {
                            target.insertPlaceholder(m_placeholder, m_clientX, m_clientY, m_orientation);
                            m_currentTarget = target;
                            m_controller.onPositionedPlaceholder(m_draggable, m_currentTarget, this);
                            return;
                        }
                    }
                }
            }
            if (m_currentTarget.getPlaceholderIndex() < 0) {
                m_currentTarget.insertPlaceholder(m_placeholder, m_clientX, m_clientY, m_orientation);
            } else {
                m_currentTarget.repositionPlaceholder(m_clientX, m_clientY, m_orientation);
            }

            m_controller.onPositionedPlaceholder(m_draggable, m_currentTarget, this);
        } else {
            // leaving the current target
            if (m_currentTarget != null) {
                m_controller.onTargetLeave(m_draggable, m_currentTarget, this);
            }
            for (I_CmsDropTarget target : m_targets) {
                if ((target != m_currentTarget) && target.checkPosition(m_clientX, m_clientY, m_orientation)) {
                    // notifying controller, if false is returned, placeholder will not be positioned inside target
                    if (m_controller.onTargetEnter(m_draggable, target, this)) {
                        target.insertPlaceholder(m_placeholder, m_clientX, m_clientY, m_orientation);
                        m_currentTarget = target;
                        m_controller.onPositionedPlaceholder(m_draggable, m_currentTarget, this);
                        return;
                    }
                }
            }
            // mouse position is not over any registered target
            m_currentTarget = null;
        }
    }
458815
def settargets(self):
        """"""
        # Define the set targets call. Include the path to the script, the database path and files, as well
        # as the taxonomic rank to use
        logging.info('Setting up database')
        self.targetcall = 'cd {} && ./set_targets.sh {} {} --{}'.format(self.clarkpath, self.databasepath,
                                                                        self.database, self.rank)
        #
        subprocess.call(self.targetcall, shell=True, stdout=self.devnull, stderr=self.devnull)
647549
public void trace(final Marker marker, final String message) {
        log.trace(marker, sanitize(message));
    }
764580
def setTargets(self, targets):
        
        if not self.verifyArguments(targets) and not self.patterned:
            raise NetworkError('setTargets() requires [[...],[...],...] or [{"layerName": [...]}, ...].', targets)
        self.targets = targets
388114
function (pointer, event, eventTarget) {
            if (this.prevTap
                && event.clientX === this.prevTap.clientX
                && event.clientY === this.prevTap.clientY
                && eventTarget   === this.prevTap.target) {

                this.downTargets[0] = eventTarget;
                this.downTimes[0] = new Date().getTime();
                this.collectEventTargets(pointer, event, eventTarget, 'tap');
            }
        }
1153786
protected void obtainFindBugsMarkers() {
        // Delete old markers
        markers.clear();
        if (editor == null || ruler == null) {
            return;
        }

        // Obtain all markers in the editor
        IResource resource = (IResource) editor.getEditorInput().getAdapter(IFile.class);
        if(resource == null){
            return;
        }
        IMarker[] allMarkers = MarkerUtil.getMarkers(resource, IResource.DEPTH_ZERO);
        if(allMarkers.length == 0) {
            return;
        }
        // Discover relevant markers, i.e. FindBugsMarkers
        AbstractMarkerAnnotationModel model = getModel();
        IDocument document = getDocument();
        for (int i = 0; i < allMarkers.length; i++) {
            if (includesRulerLine(model.getMarkerPosition(allMarkers[i]), document)) {
                if (MarkerUtil.isFindBugsMarker(allMarkers[i])) {
                    markers.add(allMarkers[i]);
                }
            }
        }
    }
20733
private Set<String> getTheMissingFields(Set<String> locatedTargets) {
        Set<String> missing = new HashSet<>();
        for (String target : getNeeded()) {
            if (!locatedTargets.contains(target)) {
                // Handle wildcard targets differently
                if (target.endsWith("*")) {
                    if (target.endsWith(".*")) {
                        if (!locatedTargets.contains(target.substring(0, target.length() - 2))) {
                            missing.add(target);
                        }
                    }
                    // Else: it ends with :* and it is always "present".
                } else {
                    missing.add(target);
                }
            }
        }
        return missing;
    }
596280
def _handle(self, nick, target, message, **kwargs):
        
        for regex, (func, pattern) in self.routes.items():
            match = regex.match(message)
            if match:
                self.client.loop.create_task(
                    func(nick, target, message, match, **kwargs))
1332924
synchronized void collectLeafPages(Collection<PageWrapper> target) {
        this.pageByOffset.values().stream().filter(p -> !p.isIndexPage()).forEach(target::add);
    }
51149
def select(actor, targets)
    targets.find_all {|target| actor.size >= target.size}
  end
1104996
function determineTargetDir(source, target) {
	return stat(source).
		then(results => results.isDirectory() ? target : path.dirname(target));
}