////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Start: config property setters 
Check {@link _cView#id} for validity before assignment
@param {_cView} view_config
@param {string} id
514449
function(view_config, id) {

		if (Lava.schema.DEBUG && !Lava.isValidId(id)) Lava.t();
		view_config.id = id;

	}
913737
@Override
	public String initValues(final FieldCase ca) {
		boolean found = false;
		buffer.setLength(0);
		for (Constraint c : constraints) {
			String cV = c.initValues(ca);
			if (cV != null) {
				found = true;
				buffer.append(cV);
			}
		}
		if (found) {
			return buffer.toString();
		}
		return null;
	}
182246
private String processViewPropertySvgReference(final String viewProperty) throws IOException {
        // find start of value
        int indexOfColon = viewProperty.indexOf(':');
        if (indexOfColon > -1) {
            int indexOfValueStart = -1;
            int indexOfSQ = viewProperty.indexOf('\'',
                                                 indexOfColon + 1);
            int indexOfDQ = viewProperty.indexOf('"',
                                                 indexOfColon + 1);
            if (indexOfSQ > -1) {
                indexOfValueStart = indexOfSQ;
            } else {
                indexOfValueStart = indexOfDQ;
            }
            if (indexOfValueStart > -1) {
                String viewValue = viewProperty.substring(indexOfValueStart + 1);

                // find end of value
                int indexOfValueEnd = -1;
                indexOfSQ = viewValue.lastIndexOf('\'');
                indexOfDQ = viewValue.lastIndexOf('"');
                if (indexOfSQ > -1) {
                    indexOfValueEnd = indexOfSQ;
                } else {
                    indexOfValueEnd = indexOfDQ;
                }
                if (indexOfValueEnd > -1) {
                    viewValue = viewValue.substring(0,
                                                    indexOfValueEnd);
                    if (viewValue.endsWith(SVG_FILE_SUFFIX)) {
                        // read svg file
                        String svgContents = getReferencedSvgFileContents(viewValue);
                        if (svgContents != null) {
                            String ignorableViewProperty = viewProperty.replace("\"view\"",
                                                                                "\"_view_file\"");
                            StringBuilder newViewProperty = new StringBuilder(ignorableViewProperty).append(LINE_SEPARATOR);
                            newViewProperty.append(viewProperty.substring(0,
                                                                          indexOfValueStart));
                            newViewProperty.append("\"").append(svgContents).append("\",").append(LINE_SEPARATOR);
                            return newViewProperty.toString();
                        }
                    }
                }
            }
        }

        // property not changed, return original property
        return viewProperty + LINE_SEPARATOR;
    }
396697
function (viewName, viewConfig, customParams, callback) {
      [viewName, viewConfig, customParams, callback] = doArgs(arguments, ['string', 'object', ['object', {}], 'function']);

      viewConfig.json = JSON.stringify(viewConfig);

      const self = this;

      doRequest({
        method: 'POST',
        urlPattern: [VIEW_CONFIG, viewName],
        request: {
          form: viewConfig
          // headers: {'content-type': 'application/x-www-form-urlencoded'},
        },
        noparse: true
      }, customParams, function (error, data) {
        if (error) {
          callback(error, data);
          return;
        }
        self.view_info(viewName, customParams, callback);
      });
    }
524901
function(viewId) {
            var that = this;
            var requirePath = this.convertViewIdToRequirePath(viewId);

            return system.defer(function(dfd) {
                system.acquire(requirePath).then(function(markup) {
                    var element = that.processMarkup(markup);
                    element.setAttribute('data-view', viewId);
                    dfd.resolve(element);
                }).fail(function(err){
                        that.createFallbackView(viewId, requirePath, err).then(function(element){
                            element.setAttribute('data-view', viewId);
                            dfd.resolve(element);
                        });
                    });
            }).promise();
        }
81469
function(view_config, raw_hash) {

		for (var name in raw_hash) {

			if (Lava.schema.DEBUG && this._allowed_hash_options.indexOf(name) == -1) Lava.t("Hash option is not supported: " + name);
			if (name in this._view_config_property_setters) {
				this[this._view_config_property_setters[name]](view_config, raw_hash[name]);
			} else {
				view_config[name] = raw_hash[name];
			}

		}

	}
1141683
@UiThread
  public static <T extends View, V> void set(@NonNull T view,
      @NonNull Property<? super T, V> setter, @Nullable V value) {
    setter.set(view, value);
  }
899469
@Nullable
    public static String setVariantForView(@NonNull View view, @Nullable String variant) {
        String previousVariant = null;
        String previousAttribute = null;
        for (Map.Entry<String, HashMap<Integer, String>> entry : bindings.entrySet()) {
            if (entry.getValue().containsKey(view.getId())) {
                previousVariant = entry.getKey();
                previousAttribute = entry.getValue().get(view.getId());
                bindings.remove(previousVariant);
                break;
            }
        }
        mapAttribute(previousAttribute, view.getId(), variant, view.getClass().getSimpleName());
        return previousVariant;
    }
1348108
function initBindings() {
    ngDevMode && assertEqual(viewData[BINDING_INDEX], -1, 'Binding index should not yet be set ' + viewData[BINDING_INDEX]);
    if (tView.bindingStartIndex === -1) {
        tView.bindingStartIndex = viewData.length;
    }
    viewData[BINDING_INDEX] = tView.bindingStartIndex;
}
523575
function (config) {
        if (typeof config !== 'object') {
            throw new Error('Invalid Route Config');
        }
        if (typeof config.route !== 'string') {
            var name_1 = config.name || '(no name)';
            throw new Error('Invalid Route Config for "' + name_1 + '": You must specify a "route:" pattern.');
        }
        if (!('redirect' in config || config.moduleId || config.navigationStrategy || config.viewPorts)) {
            throw new Error('Invalid Route Config for "' + config.route + '": You must specify a "moduleId:", "redirect:", "navigationStrategy:", or "viewPorts:".');
        }
    }
466498
public void setEntryId(String v) {
    if (ResourceEntry_Type.featOkTst && ((ResourceEntry_Type)jcasType).casFeat_entryId == null)
      jcasType.jcas.throwFeatMissing("entryId", "de.julielab.jules.types.ResourceEntry");
    jcasType.ll_cas.ll_setStringValue(addr, ((ResourceEntry_Type)jcasType).casFeatCode_entryId, v);}
193090
private void isInitialized(boolean condition, String propName) {
        if (condition == true) {
            IllegalStateException e = new IllegalStateException("J2CGlobalConfigProperties: internal error.  Set once property already set.");
            Tr.error(tc, "SET_ONCE_PROP_ALREADY_SET_J2CA0159", (Object) null);
            throw e;
        }
    }
55833
function(view_config, depends_text) {

		var binds = [],
			raw_arguments = Lava.ExpressionParser.parseRaw(depends_text, Lava.ExpressionParser.SEPARATORS.SEMICOLON),
			i = 0,
			count = raw_arguments.length;

		if (Lava.schema.DEBUG && count == 0) Lava.t("malformed 'depends' hash option");

		for (; i < count; i++) {
			if (Lava.schema.DEBUG && (!raw_arguments[i].flags || !raw_arguments[i].flags.isScopeEval)) Lava.t('malformed "depends" hash option: argument ');
			binds.push(raw_arguments[i].binds[0]);
		}

		if (!('scope' in view_config)) {
			view_config['scope'] = {
				"depends": binds
			}
		} else {
			if (Lava.schema.DEBUG && ('depends' in view_config['scope'])) Lava.t();
			view_config['scope']['depends'] = binds;
		}

	}
809586
@Override
    public void init (ExtendedProperties config)
    {
        // the web framework was kind enough to slip this into the runtime when it started up
        _sctx = (ServletContext)rsvc.getApplicationAttribute("ServletContext");
        if (_sctx == null) {
            rsvc.getLog().warn("ServletContextResourceLoader: servlet context was not supplied " +
                               "as application context. A user of the servlet context resource " +
                               "loader must call Velocity.setApplicationAttribute(" +
                               "\"ServletContext\", getServletContext()).");
        }
    }
695195
public void setViewHandler(final int viewId, final ViewHandler<T> viewHandler) {
        if (viewHandler == null) {
            throw new IllegalArgumentException("'viewHandler' cannot be null.");
        }
        mViewHandlers.put(viewId, viewHandler);
    }
1113553
public void setSettings(final String viewId, final String item, final String value) {
        this.configEntry.set(item, value);
    }
1167243
function init(theConfig) {
        exports.config = theConfig;

        Inspector.on("error", _onError);
        Inspector.Inspector.on("detached", _onDetached);

        // Only listen for styleSheetAdded
        // We may get interim added/removed events when pushing incremental updates
        CSSAgent.on("styleSheetAdded.livedev", _styleSheetAdded);

        MainViewManager
            .on("currentFileChange", _onFileChanged);
        DocumentManager
            .on("documentSaved", _onDocumentSaved)
            .on("dirtyFlagChange", _onDirtyFlagChange);
        ProjectManager
            .on("beforeProjectClose beforeAppClose", close);

        // Initialize exports.status
        _setStatus(STATUS_INACTIVE);
    }