Optionally initialize this property with a value
@param {*=} initValue Initial value for this property
343319
function Property (initValue) {
		if (arguments.length) {
			this.set(initValue);
		}
		else {
			this.set(this.defaultValue);
		}
		ok.Data.apply(this, arguments);
	}
1133847
function init(opt_config) {
  var config = objects.clone(defaultConfig);
  if (opt_config) {
    objects.merge(config, opt_config);
  }
  initVariations(config);
}
699056
function getIniValue (iniObject, keyParts) {
  const current = iniObject[keyParts[0]]
  if (!current) {
    return null
  } else if (keyParts.length === 1) {
    return current
  } else {
    return getIniValue(current, keyParts.slice(1))
  }
}
1345877
def initialized(self, value):
        

        if value is not None:
            assert type(value) is bool, "'{0}' attribute: '{1}' type is not 'bool'!".format("initialized", value)
            self.component_initialized.emit() if value else self.component_uninitialized.emit()
        self.__initialized = value
557941
public void initialize(double initial[] , int numberOfParameters , double minimumFunctionValue ) {
		super.initialize(initial,numberOfParameters);

		tmp_p.reshape(numberOfParameters,1);

		regionRadius = config.regionInitial;

		fx = cost(x);

		if( verbose != null ) {
			verbose.println("Steps     fx        change      |step|   f-test     g-test    tr-ratio  region ");
			verbose.printf("%-4d  %9.3E  %10.3E  %9.3E  %9.3E  %9.3E  %6.2f   %6.2E\n",
					totalSelectSteps, fx, 0.0,0.0,0.0,0.0, 0.0, regionRadius);
		}

		this.parameterUpdate.initialize(this,numberOfParameters, minimumFunctionValue);

		// a perfect initial guess is a pathological case. easiest to handle it here
		if( fx <= minimumFunctionValue ) {
			if( verbose != null ) {
				verbose.println("Converged minimum value");
			}
			mode = TrustRegionBase_F64.Mode.CONVERGED;
		} else {
			mode = TrustRegionBase_F64.Mode.COMPUTE_DERIVATIVES;
		}
	}
861336
function init( element, value, bindings ) {
    var $el = $( element );
    var model = value();
    var allBindings = unwrap( bindings() );
    var options = ko.toJS( allBindings.froalaOptions );

    // initialize the editor
    $el.froalaEditor( options || {} );

    // provide froala editor instance for flexibility
    if( allBindings.froalaInstance && ko.isWriteableObservable( allBindings.froalaInstance ) ) {
      allBindings.froalaInstance( $el.data( 'froala.editor' ) );
    }

    // update underlying model whenever editor content changed
    var processUpdateEvent = function (e, editor) {
        if (ko.isWriteableObservable(model)) {
            var editorValue = editor.html.get();
            var current = model();
            if (current !== editorValue) {
                model(editorValue);
            }
        }
    }

    $el.on('froalaEditor.contentChanged', processUpdateEvent);
    $el.on('froalaEditor.paste.after', processUpdateEvent);

    // cleanup editor, when dom node is removed
    ko.utils.domNodeDisposal.addDisposeCallback( element, destroy( element ) );

    // do not handle child nodes
    return { controlsDescendantBindings: true };
  }
259540
function preferencesInitialize() {
          return this.initializedPromise = defaultPreferences.then(function (defaults) {
            Object.defineProperty(this, 'defaults', {
              value: Object.freeze(defaults),
              writable: false,
              enumerable: true,
              configurable: false
            });
            this.prefs = cloneObj(defaults);
            return this._readFromStorage(defaults);
          }.bind(this)).then(function (prefObj) {
            this.isInitializedPromiseResolved = true;
            if (prefObj) {
              this.prefs = prefObj;
            }
          }.bind(this));
        }
601530
void init() {
        if (mEvaluator == null) {
            // We already handle int and float automatically, but not their Object
            // equivalents
            mEvaluator = (mValueType == Integer.class) ? sIntEvaluator :
                    (mValueType == Float.class) ? sFloatEvaluator :
                    null;
        }
        if (mEvaluator != null) {
            // KeyframeSet knows how to evaluate the common types - only give it a custom
            // evaluator if one has been set on this class
            mKeyframeSet.setEvaluator(mEvaluator);
        }
    }
350779
function (name, newValue) {
		if (arguments.length > 1) {
			this.setValue(name, newValue);
		}
		else {
			var attrs = name;
			this.setMap(attrs);
		}
	}
658965
function init() {
    var stateFromHash = getStateFromHash();
    var stateChanged = false;

    if (typeof defaults === 'object' && defaults) {
      Object.keys(defaults).forEach(function(key) {
        if (key in stateFromHash) return;

        stateFromHash[key] = defaults[key]
        stateChanged = true;
      });
    }

    if (stateChanged) set(stateFromHash);
  }
1155049
function init(ctx) {
  if (glEnums == null) {
    glEnums = { };
    for (var propertyName in ctx) {
      if (typeof ctx[propertyName] == 'number') {
        glEnums[ctx[propertyName]] = propertyName;
      }
    }
  }
}
762255
public void init(final String name, final short[] values, final int dim_x,
	    final int dim_y) {
		buildAttributeValueObject(name);
		insert(values, dim_x, dim_y);
    }
647799
function(element, options) {
      options || (options = { });

      this.callSuper('initialize', options);
      this._initElement(element);
      this._originalImage = this.getElement();
      this._initConfig(options);

      this.filters = [ ];

      if (options.filters) {
        this.filters = options.filters;
        this.applyFilters();
      }
    }
122645
public void init(ServletConfig config) throws ServletException {        
        try {
            String idlPath = config.getInitParameter("idl");
            if (idlPath == null) {
                throw new ServletException("idl init param is required. Set to path to .json file, or classpath:/mycontract.json");
            }

            if (idlPath.startsWith("classpath:")) {
                idlPath = idlPath.substring(10);
                contract = Contract.load(getClass().getResourceAsStream(idlPath));
            }
            else {
                contract = Contract.load(new File(idlPath));
            }
            
            server = new Server(contract);

            int handlerCount = 0;
            Enumeration params = config.getInitParameterNames();
            while (params.hasMoreElements()) {
                String key = params.nextElement().toString();
                if (key.indexOf("handler.") == 0) {
                    String val = config.getInitParameter(key);
                    int pos = val.indexOf("=");
                    if (pos == -1) {
                        throw new ServletException("Invalid init param: key=" + key + 
                                                   " value=" + val +
                                                   " -- should be: interfaceClass=implClass");
                    }

                    String ifaceCname = val.substring(0, pos);
                    String implCname  = val.substring(pos+1);

                    Class ifaceClazz = Class.forName(ifaceCname);
                    Class implClazz  = Class.forName(implCname);
                    server.addHandler(ifaceClazz, implClazz.newInstance());
                    handlerCount++;
                }
            }

            if (handlerCount == 0) {
                throw new ServletException("At least one handler.x init property is required");
            }
        }
        catch (ServletException e) {
            throw e;
        }
        catch (Exception e) {
            throw new ServletException(e);
        }
    }
575141
function init() {
    if (tokens) {
      return;
    }
    if (fromString) {
      tokens = cbml.parse(contentString);
    }
    else {
      tokens = cbml.parse(fs.readFileSync(filename));
    }
    /*<debug>
    console.log(JSON.stringify(tokens, null, '  '));
    //</debug>*/
  }
1213131
def init(self, value):
        '''  '''
        value = self.value_or_default(value)

        if value is None: return None

        if is_hashed(value):
            return value

        return make_password(value)
143516
function init(pluginInterface) {
    pi = pluginInterface;
    log = pi.log;
    localStorage = pi.localStorage;
}