Configure a Search registry entry.
962918
def _config_win32_search(self, search):
        """"""
        # we call str() on search to convert it from unicode to ascii
        search = str(search)
        split_char = self._determine_split_char(search)
        search_list = search.split(split_char)
        for s in search_list:
            if not s in self.search:
                self.search.add(dns.name.from_text(s))
1116214
def run_with_search(model_path, config, num_days):
    """"""
    from indra.tools.machine.machine import run_with_search_helper
    run_with_search_helper(model_path, config, num_days=num_days)
362787
def register(cls, config_type: Type[DecoderConfig], suffix: str):
        
        def wrapper(target_cls):
            cls.__registry[config_type] = (target_cls, suffix)
            return target_cls

        return wrapper
1348700
def configure(**kwargs):
        """"""
        for key in kwargs:
            if key == 'is_logging_enabled':
                Event.is_logging_enabled = kwargs[key]
            elif key == 'collector_queue':
                Event.collector_queue = kwargs[key]
            else:
                Logger.get_logger(__name__).error("Unknown key %s in configure or bad type %s",
                                                  key, type(kwargs[key]))
776200
def set_configs(self, key, d):
        """"""
        if '_config' in self.proxy:
            self.proxy['_config'][key] = d
        else:
            self.proxy['_config'] = {key: d}
126339
@Override
  protected void configure() {

    bind(DiscoveryService.class).to(BaseDiscoveryService.class);

    bind(OperatingSystemDetectionStrategy.class)
        .to(NameSubstringBasedOperatingSystemDetectionStrategy.class);
  }
1108068
def registry_adapter(obj, request):
    
    return {
        'query_uri': obj.query_uri,
        'success': obj.success,
        'has_references': obj.has_references,
        'count': obj.count,
        'applications': [{
                             'title': a.title,
                             'uri': a.uri,
                             'service_url': a.service_url,
                             'success': a.success,
                             'has_references': a.has_references,
                             'count': a.count,
                             'items': [{
                                           'uri': i.uri,
                                           'title': i.title
                                       } for i in a.items] if a.items is not None else None
                         } for a in obj.applications] if obj.applications is not None else None
    }
948148
def register(cls, key, filename):
        """"""

        if key in cls._stock:
            logger.info('Warning, replacing resource ' + str(key))
        cls._stock[key] = {'type': 'custom', 'filename': filename}
        logger.info('%s registered as %s' % (filename, key))
581179
public void setRegistrationConfig(RegistrationConfig registrationConfig) {
        this.registrationConfig = registrationConfig;

        if (registrationConfig.getDefaultConfig()!=null) {
            for (String key : registrationConfig.getDefaultConfig().keySet()) {
                dynamicConfig.put(key, registrationConfig.getDefaultConfig().get(key));
            }
        }
    }
172681
def set_config(self, key, option, value):
        """"""
        if '_config' not in self.proxy:
            newopt = dict(default_cfg)
            newopt[option] = value
            self.proxy['_config'] = {key: newopt}
        else:
            if key in self.proxy['_config']:
                self.proxy['_config'][key][option] = value
            else:
                newopt = dict(default_cfg)
                newopt[option] = value
                self.proxy['_config'][key] = newopt
278258
def _load(root):
    """"""
    types = _load_types(root)
    enums = _load_enums(root)
    commands = _load_commands(root)
    features = _load_features(root)
    extensions = _load_extensions(root)
    return Registry(None, types, enums, commands, features, extensions)
492619
function SearchResultExplorer(registry, commandService) {
        this.registry = registry;
        this._commandService = commandService;
        this.fileClient = new mFileClient.FileClient(this.registry);
        this.defaulRows = 40;
		this._contentTypeService = new mContentTypes.ContentTypeRegistry(this.registry);
        this.declareCommands();
    }
672797
def _construct_register(reg, default_reg):
    """"""
    if reg:
        x = dict((k, reg.get(k, d)) for k, d in default_reg.items())
    else:
        x = dict(default_reg)
    return x
304306
public function registerSearchableMacros()
    {
        $self = $this;

        BaseCollection::macro('searchable', function () use ($self) {
            $self->queueMakeSearchable($this);
        });

        BaseCollection::macro('unsearchable', function () use ($self) {
            $self->queueRemoveFromSearch($this);
        });
    }
226460
def with_reg(access_mask = Win32::Registry::Constants::KEY_ALL_ACCESS, &block)
      @hkey.open(@reg_path, access_mask, &block)
    end
843685
function setSearch(uri) {
  if (typeof uri.search === 'string' || uri.query === undefined) return;

  if (typeof uri.query === 'string') {
    uri.search = '?' + uri.query;
    return;
  }

  var name, filled = false;
  uri.search = '?';

  for (name in uri.query) {
    filled = true;
    uri.search += name + '=' + uri.query[name] + '&';
  }

  uri.search = uri.search.substr(0, uri.search.length - 1);
}
310479
protected function storeSearchRegistry()
    {
        $location = $this->properties['location'];
        if( $this->forceStoreRegistry )
        {
            if( isset( $this->searchRegistry[$location] ) )
            {
                $this->forceStoreRegistry = false;
                parent::storeSearchRegistry();
            }
        }
    }