/*-------------------------------------------------[ Properties ]---------------------------------------------------
765394
@Override
    public void setProperty(String name, Object value) throws SAXNotRecognizedException, SAXNotSupportedException{
        if(!_setProperty(name, value))
            throw new SAXNotRecognizedException(name);
    }
993203
public function index($properties)
    {
        $properties = (array) $properties;

        foreach ($properties as $property)
        {
            $this->addCommand('index', ['property' => $property]);
        }
    }
1322743
function(parameters) {
            var that = this;
            _.each(parameters, function(params, property) {
                that.__setPropertyParam(property, params);
            });
            return that;
        }
1095732
public function clear($properties = null): void
    {
        $this->properties = [];
        if ($properties === null) {
            $properties = [];
        }
        foreach ($properties as $key => $value) {
            $this->set($key, $value);
        }
    }
1098221
@Override
    public void setProperties(Map<Object, Object> properties) {

        Iterator<Object> keys = properties.keySet().iterator();
        while (keys.hasNext()) {
            Object key = keys.next();
            lazyProperties().put(key, properties.get(key));
        }
    }
1004627
function(object, properties) {
        if (!object.__isInterfaceImplemented('properties')) {
            object.__implementInterface('properties', this.interface);
        }

        object.__initProperties();

        var processor = this.get();

        _.each(properties, function(data, property) {
             processor.process(object, data, property);
        });
    }
1105673
protected function setProperties()
    {
        // Fetch request query string values passed by an API client.
        list($limit, $offset) = $this->paramBag->get('limit');
        list($sortKey, $sortDirection) = $this->paramBag->get('sort');

        // If nothing is passed by API client,
        // falling back to class property's value.
        $this->limit = $limit ?: $this->limit;
        $this->offset = $offset ?: $this->offset;
        $this->sortKey = $sortKey ?: $this->sortKey;
        $this->sortDirection = $sortDirection ?: $this->sortDirection;
    }
1228442
@Override
    public void setProperties(Property[] newProperties) {
        // unregister the listeners from previous properties
        for (Property prop : properties) {
            prop.removePropertyChangeListener(this);
        }

        // replace the current properties
        properties.clear();
        properties.addAll(Arrays.asList(newProperties));

        // add listeners
        for (Property prop : properties) {
            prop.addPropertyChangeListener(this);
        }

        buildModel();
    }
407702
private void logProperties(@NotNull final String header, @NotNull final Properties properties) {
        if (LOGGER.isDebugEnabled()) {
            final StringWriter sw = new StringWriter();
            try (final PrintWriter pw = new PrintWriter(sw)) {
                pw.format("%s:%n%n", header);
                final Enumeration<?> e = properties.propertyNames();
                while (e.hasMoreElements()) {
                    final String key = (String) e.nextElement();
                    if (key.contains("password")) {
                        pw.format("%s='*****'%n", key);
                    } else {
                        final String value = properties.getProperty(key);
                        if (value != null) {
                            pw.format("%s='%s'%n", key, value);
                        }
                    }
                }
                pw.flush();
                LOGGER.debug(sw.toString());
            }

        }
    }
984485
@Override
    public void setPropertyValue(PropertyInfo propInfo, Object value) {
        setPropertyValue(propInfo.getId(), value);
    }
1162965
function Property(path, node, scope, getObjectRef, file) {
  if (!node.method && node.kind === "init") return;
  if (!t.isFunction(node.value)) return;

  var replaceSupers = new _helpersReplaceSupers2["default"]({
    getObjectRef: getObjectRef,
    methodNode: node,
    methodPath: path,
    isStatic: true,
    scope: scope,
    file: file
  });

  replaceSupers.replace();
}
1346262
public function assign($property, $value)
	{
		if (null === $this->object)
		{
			$this->object = new Object;
		}

		$this->object->assign($property, $value);

		return $this;
	}
1177854
public function getProperties(): array
    {
        return get_parent_class(__CLASS__) !== false
            ? array_unique(array_merge($this->properties, parent::getProperties()))
            : $this->properties;
    }
12020
@Override
    public boolean setProperties(Dictionary<String, String> properties) {
        this.properties = properties;
        if (this.properties != null)
        {
            if (properties.get("debug") != null)
                debug = Integer.parseInt(properties.get("debug"));

            if (properties.get("input") != null)
                input = Integer.parseInt(properties.get("input"));

            if (properties.get("output") != null)
                output = Integer.parseInt(properties.get("output"));

            listings = Boolean.parseBoolean(properties.get("listings"));

            if (properties.get("readonly") != null)
                readOnly = Boolean.parseBoolean(properties.get("readonly"));

            if (properties.get("sendfileSize") != null)
                sendfileSize = 
                    Integer.parseInt(properties.get("sendfileSize")) * 1024;

            fileEncoding = properties.get("fileEncoding");

            globalXsltFile = properties.get("globalXsltFile");
            contextXsltFile = properties.get("contextXsltFile");
            localXsltFile = properties.get("localXsltFile");
            readmeFile = properties.get("readmeFile");

            if (properties.get("useAcceptRanges") != null)
                useAcceptRanges = Boolean.parseBoolean(properties.get("useAcceptRanges"));

            // Sanity check on the specified buffer sizes
            if (input < 256)
                input = 256;
            if (output < 256)
                output = 256;

            if (debug > 0) {
                log("DefaultServlet.init:  input buffer size=" + input +
                    ", output buffer size=" + output);
            }

            return this.setDocBase(this.properties.get(BASE_PATH));
        }
        else
        {
            return this.setDocBase(null);
        }
    }
743537
@Override
    public void addProperty(Property property) {
        properties.add(property);
        property.addPropertyChangeListener(this);
        buildModel();
    }
1284933
private void syncProperties(boolean fromReal) {
        PluginDefinition def = getDefinition();
        
        for (PropertyInfo propInfo : def.getProperties()) {
            if (fromReal) {
                syncProperty(propInfo, real, this);
            } else {
                syncProperty(propInfo, this, real);
            }
        }
    }
813077
function(property, param, value) {
            var params = {};

            if (!_.isUndefined(value)) {
                params[param] = value;
            }
            else if (_.isObject(param)) {
                _.extend(params, param);
            }

            if (!(property in this.__properties)) {
                this.__properties[property] = {};
            }

            _.extend(this.__properties[property], params);

            return this;
        }