Default implementation
773009
def derive_fields(self):
        
        fields = []
        if self.fields:
            fields.append(self.fields)

        return fields
402511
public function initDefaults() {
        /**
         * @var Tree $this
         */
        $module = Yii::$app->controller->module;
        $iconTypeAttribute = null;
        extract($module->dataStructure);
        $this->setDefault($iconTypeAttribute, TreeView::ICON_CSS);
        foreach (static::$boolAttribs as $attr) {
            $val = in_array($attr, static::$falseAttribs) ? false : true;
            $this->setDefault($attr, $val);
        }
    }
910926
function default_init(user, password) {
  this.defaults.username = user;
  this.defaults.password = password;

  this.defaults.headers = {
    Accept: 'application/json'
  };
  this.defaults.headers['Content-Type'] = 'application/json';
}
1299195
public function buildDefaults()
    {
        $dataClasses = ClassInfo::subclassesFor(DataObject::class);
        array_shift($dataClasses);

        if (!Director::is_cli()) {
            echo "<ul>";
        }

        foreach ($dataClasses as $dataClass) {
            singleton($dataClass)->requireDefaultRecords();
            if (Director::is_cli()) {
                echo "Defaults loaded for $dataClass\n";
            } else {
                echo "<li>Defaults loaded for $dataClass</li>\n";
            }
        }

        if (!Director::is_cli()) {
            echo "</ul>";
        }
    }
279332
def inject_default_call(self, high):
        '''
        
        '''
        for chunk in high:
            state = high[chunk]
            if not isinstance(state, collections.Mapping):
                continue
            for state_ref in state:
                needs_default = True
                if not isinstance(state[state_ref], list):
                    continue
                for argset in state[state_ref]:
                    if isinstance(argset, six.string_types):
                        needs_default = False
                        break
                if needs_default:
                    state[state_ref].insert(-1, '__call__')
400364
private function default() {

        $this->callback->filter(function (HttpCallBack $test) {
           
            return !strcmp($test->getPath(), $this->actual.'/**');

        })->each(function (HttpCallBack $test) {
 
            $test->call($this->rutesManager->getParameter());

        });
        
    }
845714
def defaults(current: dict, *args: AnyMapping) -> dict:
    
    """
    for data in args:
        for key, value in data.items():
            current.setdefault(key, value)
    return current
701420
protected function initDefaults()
    {
        if ($this->properties['header'] === null) {
            $this->setHeader($this->name);
        }
        if ($this->properties['type'] === null) {
            $this->setType(ColumnType::createType(ColumnType::TYPE_STRING));
        }
    }
1356066
public function enableDefaultAutoInitValue()
    {
        switch ($this->type) {
            case 'char':
            case 'boolean':
            case 'bool':
            case 'int':
            case 'uint':
            case 'long':
            case 'ulong':
            case 'double':
            case 'zephir_ce_guard':
                $this->defaultInitValue = 0;
                break;

            case 'variable':
            case 'string':
            case 'array':
                $this->defaultInitValue = null;
                $this->setDynamicTypes('null');
                $this->setMustInitNull(true);
                $this->setLocalOnly(false);
                break;

            default:
                throw new CompilerException('Cannot create an automatic safe default value for variable type: '.$this->type);
        }
    }
806385
def _set_program_defaults(cls, programs):
        """"""
        for program in programs:
            val = getattr(cls, program.__name__) \
                and extern.does_external_program_run(program.__name__,
                                                     Settings.verbose)
            setattr(cls, program.__name__, val)
180723
public void loadDefault() {
    try {
      load( new BufferedReader(new StringReader(
        DefaultTeXHyphenData.hyphenData) ) );
    } catch(IOException e) {
      // shouldn't happen
      throw new RuntimeException(e);
    }
  }
303078
def default(self, value):
        """"""
        self._default = value
        self._thumb  = self._link_to_img()
123325
def method_missing(name, *args, &blk)
      if name.to_s =~ /^default_(.*)=$/
        @default_options[$1.to_sym] = args.first
      elsif name.to_s =~ /=$/
        @dirty_options[$`.to_sym] = args.first
      elsif @default_options.key?(name)
        dirty_or_db_setting_or_default(name)
      else
        super
      end
    end
1270297
def init_default_cb():
    """"""
    global default_cb
    nlcb = os.environ.get('NLCB', '').lower()
    if not nlcb:
        return

    if nlcb == 'default':
        default_cb = NL_CB_DEFAULT
    elif nlcb == 'verbose':
        default_cb = NL_CB_VERBOSE
    elif nlcb == 'debug':
        default_cb = NL_CB_DEBUG
    else:
        _LOGGER.warning('Unknown value for NLCB, valid values: {default | verbose | debug}')
36105
protected function initDefaultApp()
    {
        $this->app = new App([
            'skin'                    => $this->skin,
            'catch_exceptions'        => false,
            'always_run'              => false,
            'catch_runaway_callbacks' => false,
        ]);
        $this->app->init();
    }
25628
def default_hook(config):
    """"""
    if (any(arg.startswith('bdist') for arg in sys.argv) and
            os.path.isdir(PY2K_DIR) != IS_PY2K and os.path.isdir(LIB_DIR)):
        shutil.rmtree(LIB_DIR)

    if IS_PY2K and any(arg.startswith('install') or
                       arg.startswith('build') or
                       arg.startswith('bdist') for arg in sys.argv):
        generate_py2k(config)
        packages_root = get_cfg_value(config, 'files', 'packages_root')
        packages_root = os.path.join(PY2K_DIR, packages_root)
        set_cfg_value(config, 'files', 'packages_root', packages_root)
1305145
function mkDefault(type) {
            if (typeof type === 'string')
                type = ProtoBuf.TYPES[type];
            if (typeof type.defaultValue === 'undefined')
                throw Error("default value for type "+type.name+" is not supported");
            if (type == ProtoBuf.TYPES["bytes"])
                return new ByteBuffer(0);
            return type.defaultValue;
        }