Add requested highlights to the payload
166832
private function getHighlight()
    {
        if (Utils::findKey($this->options, 'highlight', false))
        {
            foreach ($this->fields as $field)
            {
                $this->payload['highlight']['fields'][$field] = new StdClass();
            }

            if ($tag = Utils::findKey($this->options['highlight'], 'tag', false))
            {
                $this->payload['highlight']['pre_tags'] = [$tag];
                $this->payload['highlight']['post_tags'] = [preg_replace('/\A</', '</', $tag)];
            }
        }
    }
248781
function highlight(node, clear) {
        if (!_remoteHighlight) {
            _remoteHighlight = new Highlight("#cfc");
        }
        if (clear) {
            _remoteHighlight.clear();
        }
        _remoteHighlight.add(node, true);
    }
1358840
def _process_content_body(self, channel, payload):
        """"""
        partial = self.partial_messages[channel]
        partial.add_payload(payload)
        if partial.complete:
            #
            # Stick the message in the queue and go back to
            # waiting for method frames
            #
            self._quick_put((channel, partial.method_sig,
                             partial.args, partial.msg))
            self.partial_messages.pop(channel, None)
            self.expected_types[channel] = 1
446527
function() {
    this.appendDummyInput()
        .appendField('hue:')
        .appendField(new Blockly.FieldAngle('0', this.validator), 'HUE');
    this.setOutput(true, 'Colour');
    this.setTooltip('Paint the block with this colour.');
    this.setHelpUrl('https://www.youtube.com/watch?v=s2_xaEvcVI0#t=55');
  }
1272927
function highlightTokens(defs: Object, text: string) {
  return text.replace(jsTokens, function(...args) {
    const type = getTokenType(args);
    const colorize = defs[type];
    if (colorize) {
      return args[0]
        .split(NEWLINE)
        .map(str => colorize(str))
        .join("\n");
    } else {
      return args[0];
    }
  });
}
635472
function appendAWSWhitelist(source) {
  if (!source || source instanceof String || !(typeof source === 'string' || (source instanceof Object)))
    throw new Error('Please specify a path to the local whitelist file, or supply a whitelist source object.');

  capturer.append(source);
}
638436
def highlight!(group, attributes={})
      highlight(group, attributes.dup.tap { |hash| hash[:force] = true })
    end
689952
def _add_payload_files(zip_file, payload_info_list):
    """"""
    payload_byte_count = 0
    payload_file_count = 0
    for payload_info_dict in payload_info_list:
        zip_file.write_iter(payload_info_dict['path'], payload_info_dict['iter'])
        payload_byte_count += payload_info_dict['iter'].size
        payload_file_count += 1
    return payload_byte_count, payload_file_count
891686
def emit_contextually(self, action, payload):
        
        self.dump(action, payload)
        return g.rio_client_contextual.append((action, payload, ))
516470
def append(self, p_string, p_color):
        
        self.colors[len(self.data)] = p_color
        self.data += p_string
1192268
def RenderPayload(self, result, value):
    """"""
    if "args_rdf_name" in result:
      result["payload_type"] = result["args_rdf_name"]
      del result["args_rdf_name"]

    if "args" in result:
      result["payload"] = self._PassThrough(value.payload)
      del result["args"]

    return result
46704
public function add_highlight_content($response) {
        if (!isset($response->highlighting)) {
            // There is no highlighting to add.
            return;
        }

        $highlightedobject = $response->highlighting;
        foreach ($response->response->docs as $doc) {
            $x = $doc->id;
            $highlighteddoc = $highlightedobject->$x;
            $this->merge_highlight_field_values($doc, $highlighteddoc);
        }
    }
317432
def scene_add(sequence_number, scene_id, animation_id, name, color, velocity, config):
        """"""
        (red, green, blue) = (int(color[0]*255), int(color[1]*255), int(color[2]*255))
        return MessageWriter().string("scene.add").uint64(sequence_number).uint32(scene_id).uint32(animation_id).string(name) \
                              .uint8_3(red, green, blue).uint32(int(velocity * 1000)).string(config).get()
435069
def _highlight(string, color):
	''''''
	if CONFIG['color']:
		if color < 8:
			return '\033[{color}m{string}\033[0m'.format(string = string, color = color+30)
		else:
			return '\033[{color}m{string}\033[0m'.format(string = string, color = color+82)
	else:
		return string
464432
protected function addRequestBody()
    {
        if (! empty($this->payload['parameters'])) {
            if (in_array($this->method, ['DELETE', 'PATCH', 'POST', 'PUT'])) {
                $this->addCurlOption(CURLOPT_POSTFIELDS, $this->formattedRequestBody());
            } elseif (is_array($this->payload['parameters'])) {
                // append parameters in the url
                $this->payload['url'] = sprintf('%s?%s', $this->payload['url'], $this->formattedRequestBody());
            }
        }
    }
1136205
function addInterceptedXHR(req, post) {
        var xhrObj = {};
        var lightXHR = {};
        lightXHR["url"] = req.url;
        lightXHR["method"] = req.method;
        xhrObj["xhr"] = lightXHR;
        xhrObj["post"] = post;

        if (interceptXHRMap[req.url] != undefined) {
            interceptXHRMap[req.url].push(xhrObj);
        } else {
            interceptXHRMap[req._parsedUrl.pathname].push(xhrObj);
        }
    }
668282
def highlights_worker(work_unit):
    '''
    '''
    if 'config' not in work_unit.spec:
        raise coordinate.exceptions.ProgrammerError(
            'could not run `create_highlights` without global config')

    web_conf = Config()
    unitconf = work_unit.spec['config']
    with yakonfig.defaulted_config([coordinate, kvlayer, dblogger, web_conf],
                                   config=unitconf):
        file_id = make_file_id(work_unit.key)
        web_conf.kvlclient.setup_namespace(highlights_kvlayer_tables)
        payload_strs = list(web_conf.kvlclient.get('files', file_id))
        if payload_strs and payload_strs[0][1]:
            payload_str = payload_strs[0][1]
            try:
                data = json.loads(payload_str)
                # now create the response payload
                maybe_store_highlights(file_id, data, web_conf.tfidf, web_conf.kvlclient)
            except Exception, exc:
                logger.critical('failed to decode data out of %r', 
                                payload_str, exc_info=True)
                payload = {
                    'state': ERROR,
                    'error': {
                        'code': 7,
                        'message': 'failed to generate stored results:\n%s' % \
                        traceback.format_exc(exc)}
                    }
                payload_str = json.dumps(payload)
                kvlclient.put('highlights', (file_id, payload_str))