Register a ddk task.
776934
def register_ddk_task(self, *args, **kwargs):
        """"""
        kwargs["task_class"] = DdkTask
        return self.register_task(*args, **kwargs)
646739
def register(self):
        
        os.environ[self.resourceEnvNamePrefix + self.pathHash] = self.pickle()
1136738
def register_nscf_task(self, *args, **kwargs):
        """"""
        kwargs["task_class"] = NscfTask
        return self.register_task(*args, **kwargs)
1250879
def register(self, params, target):
        """"""
        self._space.register(params, target)
        self.dispatch(Events.OPTMIZATION_STEP)
606033
public function register_task($task)
    {
        if ($this->api->register_task($task, $this->ID)) {
            $this->mytask = $task;
        }
    }
1022040
static void register() {
        Transliterator.registerFactory(_ID, new Transliterator.Factory() {
            @Override
            public Transliterator getInstance(String ID) {
                return new UnicodeNameTransliterator(null);
            }
        });
    }
1291748
def register(coordinator):
    """"""
    timer_queue = Queue.Queue()
    coordinator.register(TimerItem, timer_queue)
    coordinator.worker_threads.append(
        TimerThread(timer_queue, coordinator.input_queue))
378370
def addTask(self, task):
        
        with self.regcond:
            self.taskset.append(task)
            task.add_callback('resolved', self.child_done, self.numtasks)
            self.numtasks += 1
            self.count += 1

        task.initialize(self)
        task.start()
1342883
def register(self):
        """"""
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        loop.run_until_complete(self._register())
1156892
def register(**kwargs):
    
    def decorator(func):
        _CALL_REGISTRY[kwargs.get(API_SYM, func.__name__)] = func
        return func

    return decorator
747910
def _do_register(cls, code, name, hash_name=None, hash_new=None):
        """"""
        cls._func_from_name[name.replace('-', '_')] = code
        cls._func_from_name[name.replace('_', '-')] = code
        if hash_name:
            cls._func_from_hash[hash_name] = code
        cls._func_hash[code] = cls._hash(hash_name, hash_new)
381408
def register_jobs(self, job_dict):
        """"""
        njobs = len(job_dict)
        sys.stdout.write("Registering %i total jobs: " % njobs)
        for i, job_details in enumerate(job_dict.values()):
            if i % 10 == 0:
                sys.stdout.write('.')
                sys.stdout.flush()
            self.register_job(job_details)
        sys.stdout.write('!\n')
246872
def register(cls, panel):
        """"""
        panel_class = Horizon.register_panel(cls, panel)
        # Support template loading from panel template directories.
        panel_mod = import_module(panel.__module__)
        panel_dir = os.path.dirname(panel_mod.__file__)
        template_dir = os.path.join(panel_dir, "templates")
        if os.path.exists(template_dir):
            key = os.path.join(cls.slug, panel.slug)
            loaders.panel_template_dirs[key] = template_dir
        return panel_class
422378
def register(self, klass, callback, name="default"):
        
        if klass not in self._definitions:
            self._definitions[klass] = {}

        self._definitions[klass][name] = callback
652750
def _register_task(self, output_type, rule, union_rules):
    """"""
    func = Function(self._to_key(rule.func))
    self._native.lib.tasks_task_begin(self._tasks, func, self._to_type(output_type), rule.cacheable)
    for selector in rule.input_selectors:
      self._native.lib.tasks_add_select(self._tasks, self._to_type(selector))

    def add_get_edge(product, subject):
      self._native.lib.tasks_add_get(self._tasks, self._to_type(product), self._to_type(subject))

    for the_get in rule.input_gets:
      union_members = union_rules.get(the_get.subject_declared_type, None)
      if union_members:
        # If the registered subject type is a union, add Get edges to all registered union members.
        for union_member in union_members:
          add_get_edge(the_get.product, union_member)
      else:
        # Otherwise, the Get subject is a "concrete" type, so add a single Get edge.
        add_get_edge(the_get.product, the_get.subject_declared_type)

    self._native.lib.tasks_task_end(self._tasks)
1121194
def register(self, key, **kwargs):
        """"""
        dimensions = dict((k, str(v)) for k, v in kwargs.items())
        composite_key = self._composite_name(key, dimensions)
        self._metadata[composite_key] = {
            'metric': key,
            'dimensions': dimensions
        }
        return composite_key
1115511
def register(cache):
	'''  '''

	global caches
	name = cache().name
	if not caches.has_key(name):
		caches[name] = cache