Assign all RainCloudyFaucetZone managed by faucet.
436395
def _assign_zones(self):
        """"""
        for zone_id in range(1, 5):
            zone = \
                RainCloudyFaucetZone(
                    parent=self._parent,
                    controller=self._controller,
                    faucet=self,
                    zone_id=zone_id)

            if zone not in self.zones:
                self.zones.append(zone)
1193891
def assignLeafRegisters(inodes, registerMaker):
    
    leafRegisters = {}
    for node in inodes:
        key = node.key()
        if key in leafRegisters:
            node.reg = leafRegisters[key]
        else:
            node.reg = leafRegisters[key] = registerMaker(node)
198917
def faucet(self):
        """"""
        if hasattr(self, 'faucets'):
            if len(self.faucets) > 1:
                # in the future, we should support more faucets
                raise TypeError("Only one faucet per account.")
            return self.faucets[0]
        raise AttributeError("There is no faucet assigned.")
935361
def auto_watering(self):
        """"""
        value = "zone{}".format(self.id)
        return find_program_status(self._parent.html['home'], value)
1106324
function registerTasks (gulp) {
  exec(gulp)
  install(gulp)
  list(gulp)
  update(gulp)
}
862447
private function registerAllThemes()
    {
        $directories = $this->app['files']->directories(base_path('themes'));

        foreach ($directories as $directory) {
            $this->app['stylist']->registerPath($directory);
        }
    }
624594
public function addAll() {
        if(func_num_args() > 0) {
            for($i = 0; $i < func_num_args(); $i++) {
                if(func_get_arg($i) instanceof \bootbuilder\Controls\Control){
                    array_push($this->controls, func_get_arg($i));
                }
            }
        }
    }
274513
def setup_renderer(renderer)
      renderer.default_assigns = liquid_assigns if respond_to?(:liquid_assigns, true)
      renderer.default_registers = liquid_registers if respond_to?(:liquid_registers, true)
      renderer.default_filters = liquid_filters if respond_to?(:liquid_filters, true)
    end
950711
protected function registerContainer()
    {
        static::setInstance($this);

        $this->instance('app', $this);
        $this->alias('app', static::class);
        $this->alias('app', 'Illuminate\Container\Container');
        $this->alias('app', 'Illuminate\Contracts\Container\Container');
    }
38993
private function registerBaseFacades()
    {
        Facade::clearResolvedInstances();

        Facade::setFacadeApplication($this);

        AliasLoader::getInstance($this->make('config')->get('app.aliases'))->register();
    }
416818
public function setAll()
    {
        $this->removeSelectModifier(self::DISTINCT);
        $this->addSelectModifier(self::ALL);

        return $this;
    }
868503
public final void tryFlushAll() {
      if (flushing.compareAndSet(false, true)) {
         if (reset) {
            for (Stat stat : Stat.values()) {
               topKeyWrapper.get(stat).reset(this, capacity);
            }
            reset = false;
         } else {
            for (Stat stat : Stat.values()) {
               topKeyWrapper.get(stat).flush();
            }
         }
         flushing.set(false);
      }
   }
327244
function(cb) {
    this._loadCollections();
    
    // Start Waterline
    var self = this;
    this._waterline.initialize(self.config, function(err, waterline) {
      if(err) throw err;
      
      hb.addModel('Account', waterline.collections['accounts-'+hb.env]);
      hb.addModel('Keyword', waterline.collections['keywords-'+hb.env]);
      
      cb();
    });
  }
319764
protected function registerFacades()
    {
        $facades = array_merge(
            [
            'RedisKit' => RedisFacade::class,
            'MemcacheKit' => MemcacheFacade::class,
            'FilecacheKit' => FilecacheFacade::class,
            'RequestKit' => RequestFacade::class,
            'ResponseKit' => ResponseFacade::class,
            ], Lb::app()->getFacadesConfig()
        );

        array_walk(
            $facades, function ($facade, $alias) {
                class_alias($facade, $alias);
            }
        );
    }
762916
static void execute(Tenant tenant, Runnable runnable) {
        startTenantFlow();
        try {
            getThreadLocalInstance().setTenant(tenant);
            runnable.run();
        } finally {
            endTenantFlow();
        }
    }
1159621
public static function flush()
    {
        // Ensure that this instance is constructed on flush, thus forcing
        // bootstrapping of necessary .htaccess / web.config files
        $instance = singleton(AssetStore::class);
        if ($instance instanceof FlysystemAssetStore) {
            $public = $instance->getPublicFilesystem();
            if ($public instanceof Filesystem) {
                $publicAdapter = $public->getAdapter();
                if ($publicAdapter instanceof AssetAdapter) {
                    $publicAdapter->flush();
                }
            }
            $protected = $instance->getProtectedFilesystem();
            if ($protected instanceof Filesystem) {
                $protectedAdapter = $protected->getAdapter();
                if ($protectedAdapter instanceof AssetAdapter) {
                    $protectedAdapter->flush();
                }
            }
        }
    }
1363485
def assign_funcs(modname, service, module=None,
                get_conn_funcname='_get_conn', cache_id_funcname='_cache_id',
                exactly_one_funcname='_exactly_one'):
    '''
    
    '''
    mod = sys.modules[modname]
    setattr(mod, get_conn_funcname, get_connection_func(service, module=module))
    setattr(mod, cache_id_funcname, cache_id_func(service))

    # TODO: Remove this and import salt.utils.data.exactly_one into boto_* modules instead
    # Leaving this way for now so boto modules can be back ported
    if exactly_one_funcname is not None:
        setattr(mod, exactly_one_funcname, exactly_one)