Set the attribute user default properties.

@param 	prop_list	The user default attribute properties
185524
public void set_default_properties(UserDefaultAttrProp prop_list)
	{
		if (prop_list.label != null)
			user_default_properties.addElement(new AttrProperty("label",prop_list.label));

		if (prop_list.description != null)
			user_default_properties.addElement(new AttrProperty("description",prop_list.description));

		if (prop_list.unit != null)
			user_default_properties.addElement(new AttrProperty("unit",prop_list.unit));

		if (prop_list.standard_unit != null)
			user_default_properties.addElement(new AttrProperty("standard_unit",prop_list.standard_unit));

		if (prop_list.display_unit != null)
			user_default_properties.addElement(new AttrProperty("display_unit",prop_list.display_unit));
		
		if (prop_list.format != null)
			user_default_properties.addElement(new AttrProperty("format",prop_list.format));

		if (prop_list.min_value != null)
			user_default_properties.addElement(new AttrProperty("min_value",prop_list.min_value));

		if (prop_list.max_value != null)
			user_default_properties.addElement(new AttrProperty("max_value",prop_list.max_value));

		if (prop_list.min_alarm != null)
			user_default_properties.addElement(new AttrProperty("min_alarm",prop_list.min_alarm));

		if (prop_list.max_alarm != null)
			user_default_properties.addElement(new AttrProperty("max_alarm",prop_list.max_alarm));
	}
705713
private void addPluginConfigDefaultProperties() {
    for (ConfProp prop : ConfProp.values()) {
      if (conf.get(prop.name) == null)
        conf.set(prop.name, prop.defVal);
    }
  }
908992
def get_setter(cls, prop_name,  # @NoSelf
                   user_setter=None, setter_takes_name=False,
                   user_getter=None, getter_takes_name=False):
        """"""

        has_prop_variable = cls.has_prop_attribute(prop_name)

        # WARNING! These are deprecated
        has_specific_setter = hasattr(cls, SET_PROP_NAME % \
                                      {'prop_name' : prop_name})
        has_general_setter = hasattr(cls, SET_GENERIC_NAME)

        if not (has_prop_variable or
                has_specific_setter or
                has_general_setter or
                user_setter):
            return None

        if has_prop_variable:
            if has_specific_setter or user_setter:
                logger.warning("In class %s.%s ignoring custom logical "
                               "setter for property '%s' as a "
                               "corresponding attribute exists" % \
                               (cls.__module__, cls.__name__, prop_name))

            user_setter = user_getter = None
            setter_takes_name = getter_takes_name = False
        else:
            if user_setter:
                pass
            else:
                if has_specific_setter:
                    def __setter(self, val):
                        _setter = getattr(self, SET_PROP_NAME % \
                                          {'prop_name' : prop_name})
                        _setter(val)
                        return
                    user_setter = __setter
                    #user_setter = getattr(cls, SET_PROP_NAME % \
                    #                     {'prop_name' : prop_name})
                    setter_takes_name = False
                else:
                    assert has_general_setter

                    def __setter(self, name, val):
                        _setter = getattr(self, SET_GENERIC_NAME)
                        _setter(name, val)
                        return
                    user_setter = __setter
                    #user_setter = getattr(cls, SET_GENERIC_NAME)
                    setter_takes_name = True

        # the final setter is a combination of a basic setter, and
        # the getter (see how inner_{getter,setter} are used in
        # _setter below)
        _inner_setter = PropertyMeta.get_setter(cls, prop_name,
                                        user_setter, setter_takes_name,
                                        user_getter, getter_takes_name)

        _inner_getter = type(cls).get_getter(cls, prop_name,
                                             user_getter, getter_takes_name)

        def _setter(self, val):
            curr_frame = len(self._notify_stack)
            if prop_name not in self._notify_stack:
                self._notify_stack.append(prop_name)

            old = _inner_getter(self)
            new = type(self).create_value(prop_name, val, self)

            # to track dependencies
            olds = self.__before_property_value_change__(prop_name) if \
                self._has_observer() else ()
            self._notify_stack.extend(
                            map(operator.itemgetter(1), olds))

            # this is the unique place where the value is set:
            _inner_setter(self, new)

            if type(self).check_value_change(old, new):
                self._reset_property_notification(prop_name, old)

            self.notify_property_value_change(prop_name, old, val)

            # to notify dependencies
            self.__after_property_value_change__(prop_name, olds)

            del self._notify_stack[curr_frame:]
        return _setter
533185
def set_list_attribute(self, other, trigger_klass, property_name):
        """"""
        # Check property exists
        if isinstance(other, trigger_klass):

            if not hasattr(self, property_name):
                raise AttributeError("%s has no property %s" % (self.__class__.__name__, property_name))

            val = getattr(self, property_name, [])
            if other in val:
                raise ValueError("%s already exists in %s" % (other.__class__.__name__, self.__class__.__name__))
            else:
                val.append(other)
                setattr(self, property_name, val)
627687
def custom_properties(self, props):
        
        fprops = javabridge.make_instance("java/io/File", "(Ljava/lang/String;)V", props)
        javabridge.call(self.jobject, "setCustomPropsFile", "(Ljava/io/File;)V", fprops)
881064
public void setProperties(Properties properties) {
		sessionTimeout = Integer.valueOf(properties.getProperty("session_timeout", "" + sessionTimeout));
		System.out.println(new LogEntry("session timeout set to " + sessionTimeout + " (sec)"));
		defaultAdminPassword = properties.getProperty("default_admin_password", defaultAdminPassword);
	}
209676
public void setUserDetailList(java.util.Collection<UserDetail> userDetailList) {
        if (userDetailList == null) {
            this.userDetailList = null;
            return;
        }

        this.userDetailList = new com.amazonaws.internal.SdkInternalList<UserDetail>(userDetailList);
    }
653612
public void setPropertyDefaultType (Class type, String propertyName, Class defaultType) {
		if (type == null) throw new IllegalArgumentException("type cannot be null.");
		if (propertyName == null) throw new IllegalArgumentException("propertyName cannot be null.");
		if (defaultType == null) throw new IllegalArgumentException("defaultType cannot be null.");
		Property property = Beans.getProperty(type, propertyName, beanProperties, privateFields, this);
		if (property == null)
			throw new IllegalArgumentException("The class " + type.getName() + " does not have a property named: " + propertyName);
		propertyToDefaultType.put(property, defaultType);
	}
1130630
public static void loadUserConfigProps() {
        userProps = new Properties();
        try {
            LOG.info("Loading the properties as proj root /src:");
            loadProps(userProps, mRunPropertiesFile);
        } catch (IOException e) {
            LOG.info("context", e);
            try {
                LOG.info("No prop file found, trying load the properties as proj root /src:");
                loadProps(userProps, iRunPropertiesFile);
            } catch (IOException e1) {
                LOG.error("IOException", e1);
            }
        }
    }
1004257
def __setAttributeDefaults(self):
        
        for k,v in self.__class__.attributes.items():
            if v is not None and self.attributes.has_key(k) is False:
                if isinstance(v, types.FunctionType):
                    self.attributes[k] = v(self)
                else:
                    self.attributes[k] = v
1292751
protected void setProperty(JKLocale locale, final String propName, final String value) {
		logger.trace("Add label :", propName, " , with value: ", value);
		Properties prop = getLables(locale);
		prop.setProperty(JKCollectionUtil.fixPropertyKey(propName), fixValue(value));
	}
628297
def set_properties(self, eid, value, idx='*'):
        
        if value.__class__ not in Template.class_cache:
            props = []
            for name in dir(value.__class__):
                prop = getattr(value.__class__, name)
                if type(prop) == property and hasattr(prop, 'fget'):
                    props.append((name, prop))
            Template.class_cache[value.__class__] = props
        for (name, prop) in Template.class_cache[value.__class__]:
            new_eid = ''.join([eid, ':', name])
            self.set_value(new_eid, prop.fget(value), idx)
            self.set_attribute(eid, name, prop.fget(value), idx)
322318
public void setURLProperties(HsqlProperties p) {

        if (p != null) {
            for (Enumeration e = p.propertyNames(); e.hasMoreElements(); ) {
                String   propertyName = (String) e.nextElement();
                Object[] row          = (Object[]) meta.get(propertyName);

                if (row != null
                        && (db_readonly.equals(propertyName)
                            || ((Integer) row[indexType]).intValue()
                               == SET_PROPERTY)) {

                    // can add error checking with defaults
                    setProperty(propertyName, p.getProperty(propertyName));
                }
            }
        }
    }
692077
function(props) {
	// Default properties to an array
	if (typeof props == 'string') {
		props = [props];
	}

	var i,
		propsLen = props.length;

	for (i = 0; i < propsLen; i += 1) {
		this._node.style[props[i]] = '';
	}
	return this;
}
489788
public void setList(List<?> list) {
		this.checkNull(list);
		this.list.add(list);
		this.type.add(List.class);
	}
1197465
@Override
    public void set(String propName, Object value) {
        if (propName.equals(PROP_PRINCIPAL_NAME)) {
            setPrincipalName(((String) value));
        }
        if (propName.equals(PROP_PASSWORD)) {
            setPassword(((byte[]) value));
        }
        if (propName.equals(PROP_REALM)) {
            setRealm(((String) value));
        }
        if (propName.equals(PROP_CERTIFICATE)) {
            getCertificate().add(((byte[]) value));
        }
        super.set(propName, value);
    }
145819
@Override
    public void setListProperty(String propertyName, List<String> values) {
        setProperty(propertyName, values);

    }