Add key/value property pair to this executor factory configuration

@param key
property key
@param value
property value
@return previous value if exists, null otherwise
427664
public ExecutorFactoryConfigurationBuilder addExecutorProperty(String key, String value) {
      TypedProperties properties = attributes.attribute(PROPERTIES).get();
      properties.put(key, value);
      attributes.attribute(PROPERTIES).set(properties);
      return this;
   }
1219521
public synchronized Object insert(String key, Object value) {
        // evict until size < maxSize
        while (isEvictionRequired() && entryLimit > 0 && entryLimit < Integer.MAX_VALUE) {
            evictStaleEntries();
        }

        CacheEntry curEntry = new CacheEntry(value);
        CacheEntry oldEntry1 = (CacheEntry) primaryTable.put(key, curEntry);

        CacheEntry oldEntry2 = (CacheEntry) secondaryTable.remove(key);
        CacheEntry oldEntry3 = (CacheEntry) tertiaryTable.remove(key);

        return (oldEntry1 != null) ? oldEntry1.value : (oldEntry2 != null) ? oldEntry2.value : (oldEntry3 != null) ? oldEntry3.value : null;
    }
365975
public synchronized final V put(K key, V value) {
        if (key == null) {
            throw new NullPointerException("key == null");
        } else if (value == null) {
            throw new NullPointerException("value == null");
        }

        V previous = map.put(key, value);
        trimToSize(maxSize);
        return previous;
    }
1296467
public V put( final K key, final V value ) {
        synchronized ( _map ) {
            final ManagedItem<V> previous = _map.put( key, new ManagedItem<V>( value, System.currentTimeMillis() ) );
            while ( _map.size() > _size ) {
                _map.remove( _map.keySet().iterator().next() );
            }
            return previous != null
                ? previous._value
                : null;
        }
    }
24604
public Object put(String key, JsonArray value) {
		if (value == null) {
			stateMap.put(key, Type.NULL);
		} else {
			stateMap.put(key, Type.ARRAY);
		}

		return super.put(key, value);
	}
1369416
public PropertiesWriter append( final String key, final String value )
    {
        NullArgumentException.validateNotEmpty( key, "Key" );
        String valueToAdd = value;
        if( value == null )
        {
            valueToAdd = "";
        }
        Integer position = m_positions.get( key );
        List<String> values = m_values.get( key );
        if( values == null )
        {
            values = new ArrayList<String>();
            m_values.put( key, values );
        }
        values.add( valueToAdd );
        StringBuilder builder = new StringBuilder().append( key ).append( "=" );
        if( values.size() == 1 )
        {
            builder.append( valueToAdd );
        }
        else
        {
            builder.append( "\\\n" );
            String trail = null;
            for( String storedValue : values )
            {
                if( trail != null )
                {
                    builder.append( trail );
                }
                builder.append( storedValue );
                trail = m_separator + "\\\n";
            }
        }
        if( position == null )
        {
            m_content.add( builder.toString() );
            m_positions.put( key, m_content.size() - 1 );
        }
        else
        {
            m_content.set( position, builder.toString() );
        }
        return this;
    }
509503
public boolean add(final K key, final V value) {
        if (!this.map.containsKey(key)) {
            this.map.put(key, new ArrayList<V>());
        }
        return this.map.get(key).add(value);
    }
772480
public ContextPropertiesCache put(String key, String value) {
    checkArgument(key != null, "Key of context property must not be null");
    checkArgument(value != null, "Value of context property must not be null");
    props.put(key, value);
    return this;
  }
105265
@Override
	public Object put(final Object key, final Object value) {
		lock.writeLock().lock();
		try {
			return properties.put(key, value);
		} finally {
			lock.writeLock().unlock();
		}
	}
276296
synchronized void setProperty(Object key, Object value) throws ChannelFactoryPropertyIgnoredException {
        if (null == key) {
            throw new ChannelFactoryPropertyIgnoredException("Ignored channel factory property key of null");
        }
        if (myProperties == null) {
            this.myProperties = new HashMap<Object, Object>();
        }
        this.myProperties.put(key, value);
        if (cf != null) {
            cf.updateProperties(myProperties);
        }
    }
66101
public synchronized TypedProperties putIfAbsent(String key, String value) {
      if (getProperty(key) == null) {
         put(key, value);
      }
      return this;
   }
426148
public ObjectNameBuilder addProperty(String key, String value) {
    nameStrBuilder.append(sanitizeValue(key))
        .append('=')
        .append(sanitizeValue(value)).append(",");
    return this;
  }
573170
@Override
    public V put(final K key, final V value) {
        map.merge(key, value, defaultMerger);
        return previousValue;
    }
156101
public static void addProperty(String key, String value) {
    TransactionLogger instance = getInstance();
    if (instance != null) {
      instance.properties.put(key, value);
    }
  }
879800
public ValueMap putValue(String key, Object value) {
    delegate.put(key, value);
    return this;
  }
1031013
public void add(K key, V value) {
		List<V> values = this.targetMap.get(key);
		if (values == null) {
			values = new LinkedList<V>();
			this.targetMap.put(key, values);
		}
		values.add(value);
	}
93609
public Kafka property(String key, String value) {
		Preconditions.checkNotNull(key);
		Preconditions.checkNotNull(value);
		if (this.kafkaProperties == null) {
			this.kafkaProperties = new HashMap<>();
		}
		kafkaProperties.put(key, value);
		return this;
	}