Set the unknown properties for this type. The values are copied to an immutable map.
Note, these values are NOT serialized into the type.
164040
public void setUnknownProperties(Map<String, Object> unknownProperties) {
        this.unknownProperties = Collections.unmodifiableMap(
            new HashMap<>(unknownProperties));
    }
287839
@SuppressWarnings("unchecked")
    private static void setMappedValue(Object obj, Property property, Object key, Object value, ObjectWrapper options) {
        if (property == null) {
            throw new IllegalArgumentException("Cannot set a new mapped value to a 'null' property.");
        }

        if (Map.class.isAssignableFrom(property.getType())) {
            Map map = (Map) property.get(obj);

            if (map == null) {
                if (options.isAutoInstancing) {
                    map = new LinkedHashMap();
                    property.set(obj, map);
                } else {
                    throw new NullPointerException("Invalid 'null' value found for the mapped '" + property + "' in "
                                                           + obj.getClass().getName() + " object.");
                }
            }

            map.put(key, value);
        } else {
            throw new IllegalArgumentException("Cannot set a new mapped value to " + property
                                                       + ". Only Map type is supported for mapped properties, but " + property.getType().getName()
                                                       + " found.");
        }
    }
805278
public void setMapperProperties(Properties properties) {
        if (this.mapperHelper == null) {
            this.mapperHelper = new MapperHelper();
        }
        this.mapperHelper.setProperties(properties);
    }
1258911
public void setValues() {
    for (Map.Entry<String, ArrayValueMap.ArrayValue> entry : keyMap.entrySet()) {
      @SuppressWarnings("unchecked")
      Map<String, Object> destinationMap = (Map<String, Object>) destination;
      destinationMap.put(entry.getKey(), entry.getValue().toArray());
    }
    for (Map.Entry<Field, ArrayValueMap.ArrayValue> entry : fieldMap.entrySet()) {
      FieldInfo.setFieldValue(entry.getKey(), destination, entry.getValue().toArray());
    }
  }
538475
public void setValue(Object newValue)
    {
    	if (NOT_KNOWN.equals(newValue))
    	{
        	m_proxyField.updateValue();
    		m_proxyField.setNotKnown(true);
    		return;
    	}
    	if (UNKNOWN.equals(newValue))
    	{
    		m_proxyField.reset();
        	m_proxyField.updateValue();
    		return;
    	}
    	m_proxyField.setValue(newValue);
    	m_proxyField.updateValue();
    }
1009898
function set(property, value, defaultValue) {
    if (value === undefined) {
      if (defaultValue === undefined) {
        defaultValue = this.keys[property];
      }
      if (typeof defaultValue === 'function') {
        this[property] = defaultValue.call(this);
      } else {
        this[property] = defaultValue;
      }
    } else {
      this[property] = value;
    }
  }
463477
public void setProperty(String key, String value)
	{
		if (properties == null)
			properties = new Hashtable<String, String>();
		properties.put(key, value);
	}
43388
public void setProperties( Map<String, Object> properties )
    {
        Introspector introspector = new Introspector( target.getClass(), new PropertyComparator() );
        for (Map.Entry<String,Object> property : properties.entrySet())
        {
            Method setter = introspector.getSetter( property.getKey() );
            if (setter != null) invoke( setter, property.getValue() );
        }
    }
1100800
private static void initializePropertyMaps() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "initializePropertyMap");

    // Add all the supported properties to the PropertyMaps:
    // PR, DM, and TL use the PhantomPropertyCoder as they are encoded/decoded
    // separately rather than by using their PropertyCoder.
    // They need to be included in the map so that methods can extract information
    // and set them.
    // Any property with a shortName which maps to null but be added with one of
    // the general coders - currently StringPropertyCoder or IntegerPropertyCoder.
    // NOTE: If SuppressIfDefaultInJNDI is not null, the LongName MUST match that defined in
    // JmsInternalConstants
    // Parameters:
    //        PropertyCoder               ( LongName                            ShortName), IntValue,  ValueType    , DefaultValue             SuppressIfDefaultInJNDI)
    addToMaps(new PhantomPropertyCoder    (JmsInternalConstants.PRIORITY             , PR),  PR_INT,   Integer.class, Integer.valueOf(Message.DEFAULT_PRIORITY) ,null);
    addToMaps(new PhantomPropertyCoder    (JmsInternalConstants.DELIVERY_MODE        , DM),  DM_INT,   String.class , ApiJmsConstants.DELIVERY_MODE_APP         ,null);
    addToMaps(new PhantomPropertyCoder    (JmsInternalConstants.TIME_TO_LIVE         , TL),  TL_INT,   Long.class   , Long.valueOf(Message.DEFAULT_TIME_TO_LIVE),null);
    addToMaps(new ReadAheadCoder          ("readAhead"                               , RA),  RA_INT,   String.class , ApiJmsConstants.READ_AHEAD_AS_CONNECTION  ,null);
    addToMaps(new ShortStringPropertyCoder("topicName"                               , TN),  TN_INT,   String.class , null                                      ,null);
    addToMaps(new ShortStringPropertyCoder("topicSpace"                              , TS),  TS_INT,   String.class , JmsTopicImpl.DEFAULT_TOPIC_SPACE          ,null);
    addToMaps(new ShortStringPropertyCoder("queueName"                               , QN),  QN_INT,   String.class , null                                      ,null);
    addToMaps(new OnOffPropertyCoder      (JmsInternalConstants.SCOPE_TO_LOCAL_QP    , QP),  QP_INT,   String.class , ApiJmsConstants.SCOPE_TO_LOCAL_QP_OFF     ,JmsQueueImpl.class);
    addToMaps(new OnOffPropertyCoder      (JmsInternalConstants.PRODUCER_PREFER_LOCAL, PL),  PL_INT,   String.class , ApiJmsConstants.PRODUCER_PREFER_LOCAL_ON  ,JmsQueueImpl.class);
    addToMaps(new OnOffPropertyCoder      (JmsInternalConstants.PRODUCER_BIND        , PB),  PB_INT,   String.class , ApiJmsConstants.PRODUCER_BIND_OFF         ,JmsQueueImpl.class);
    addToMaps(new OnOffPropertyCoder      (JmsInternalConstants.GATHER_MESSAGES      , GM),  GM_INT,   String.class , ApiJmsConstants.GATHER_MESSAGES_OFF       ,JmsQueueImpl.class);
    addToMaps(new StringPropertyCoder     (JmsInternalConstants.BUS_NAME             , BN),  BN_INT,   String.class , null                                      ,null);
    addToMaps(new IntegerPropertyCoder    (JmsInternalConstants.BLOCKED_DESTINATION  , BD),  BD_INT,   Integer.class, null                                      ,null);
    addToMaps(new StringPropertyCoder     ("destName"                                , DN),  DN_INT,   String.class , null                                      ,null);
    addToMaps(new StringPropertyCoder     ("destDiscrim"                             , DD),  DD_INT,   String.class , null                                      ,null);

    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "propertyMap" + propertyMap);
    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "reverseMap" + reverseMap);
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "initializePropertyMap");
  }
389015
def set(self, name, value):
        

        name = str(name)
        if name not in self._properties:
            raise ArgumentError("Unknown property in DeviceModel", name=name)

        self._properties[name] = value
779913
public void setProperties(Map<String, Value> properties) {
        if (properties != null) {
            this.properties = new HashMap<>(properties);
        } else {
            this.properties = null;
        }
    }
924030
public void setProperties(Object bean, Map map) {
        checkInitalised();
        for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entry) iter.next();
            String key = entry.getKey().toString();

            Object value = entry.getValue();
            setProperty(bean, key, value);
        }
    }
939941
@Override
  public void set(Object data, Class<?>... typeSpecs) {
    this.reset();
    this.mDefaultTypeSpecs = typeSpecs;
    this.add(data, typeSpecs);
  }
221097
def set_property(self, **kwargs):
        
        if not isinstance(self._value, nparray.ndarray):
            raise ValueError("value is not a nparray object")

        for property, value in kwargs.items():
            setattr(self._value, property, value)
376441
@SuppressWarnings({"unchecked", "SuspiciousSystemArraycopy"})
    private static void setIndexedValue(Object obj, Property property, int index, Object value, ObjectWrapper options) {
        if (property == null) {
            throw new IllegalArgumentException("Cannot set a new indexed value to a 'null' property.");
        }

        Object propertyValue = property.get(obj);

        if (propertyValue == null) {
            if (options.isAutoInstancing) {
                Class<?> propertyType = property.getType();

                if (propertyType.isAssignableFrom(List.class)) {
                    propertyValue = new ArrayList();
                    property.set(obj, propertyValue);
                } else if (propertyType.isArray()) {
                    propertyValue = Array.newInstance(property.getActualType(), index + 1);
                    property.set(obj, propertyValue);
                } else {
                    throw new IllegalArgumentException("The indexed " + property + " in object "
                                                               + obj.getClass().getSimpleName() + " has value 'null'. Only List and array types can be " +
                                                               "auto instantiated, but " + propertyType.getSimpleName() + " found.");
                }
            } else {
                throw new NullPointerException("Invalid 'null' value found for the indexed '" + property + "' in "
                                                       + obj.getClass().getName() + " object.");
            }
        }

        if (propertyValue instanceof List) {
            List list = (List) propertyValue;
            int size = list.size();

            if (index >= size && options.isAutoGrowing) {
                for (int i = size; i < index; i++) {
                    try {
                        list.add(null);
                    } catch (NullPointerException ex) {
                        throw new NullPointerException("The indexed " + property + " has size lower than the requested '"
                                                               + index + "' index. An attempt to autogrowing it, filling with 'null' values, was made, " +
                                                               " but the List implementation seems to do not accept 'null' values. " + ex.getMessage());
                    }
                }

                list.add(index, value);
            } else {
                try {
                    list.set(index, value);
                } catch (IndexOutOfBoundsException e) {
                    throw new IndexOutOfBoundsException("Cannot set a new value to the indexed list " + property + " in "
                                                                + obj.getClass().getSimpleName() + " as the requested '" + index + "' index is unbound.");
                }
            }
        } else if (propertyValue.getClass().isArray()) {
            int length = Array.getLength(propertyValue);

            if (index >= length && options.isAutoGrowing) {
                Object biggerArray = Array.newInstance(property.getActualType(), index + 1);
                System.arraycopy(propertyValue, 0, biggerArray, 0, length);
                property.set(obj, biggerArray);
                propertyValue = biggerArray;
            }

            try {
                Array.set(propertyValue, index, value);
            } catch (ArrayIndexOutOfBoundsException e) {
                throw new IndexOutOfBoundsException("Cannot set a new value to the indexed array " + property
                                                            + " in " + obj.getClass().getSimpleName() + " as the requested '" + index + "' index is unbound.");
            }
        } else {
            throw new IllegalArgumentException("Cannot set a new value to a not indexed " + property + ". Only List and array " +
                                                       "types are supported, but " + propertyValue.getClass().getName() + " found.");
        }
    }
940636
public void setConfiguration( Dictionary<?,?> properties ) {

		// Ignore iPojo properties
		final List<String> propertiesToSkip = Arrays.asList(
				"component",
				"felix.fileinstall.filename" );

		// Convert the dictionary into a map
		Map<String,String> map = new LinkedHashMap<> ();
		for( Enumeration<?> en = properties.keys(); en.hasMoreElements(); ) {

			Object key = en.nextElement();
			String keyAsString = String.valueOf( key );
			if( propertiesToSkip.contains( keyAsString ))
				continue;

			// "null" are not acceptable values in dictionaries
			// (OSGi often use Hash tables)
			Object value = properties.get( key );
			map.put( keyAsString, String.valueOf( value ));
		}

		// Invoked by iPojo => the messaging type is the right one in this method
		map.put( MessagingConstants.MESSAGING_TYPE_PROPERTY, FACTORY_RABBITMQ );
		setConfiguration( map );
	}
323796
@Override
	public synchronized void setProperties(Map<Object, Object> properties)
	{
		if(this.properties == null)
			this.properties = new Properties();
		
		
		this.properties.putAll(properties);
	}