<p class="changed_added_2_2">The default behavior of this method
is to call {@link Flash#putNow(String, Object)} on the wrapped
{@link Flash} object.</p>

@since 2.2
9410
@Override
    public void putNow(String key, Object value) {
        getWrapped().putNow(key, value);
    }
594809
@Override
    public final void put(Object o) {
        boolean discarded = false;

        if (inactive) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "setting active: " + this);

            // If the pool was marked inactive by the pool manager alarm, then
            // switch it back to active.  Hopefully this happens before too
            // many other threads notice and cause contention with the
            // following sync block.
            inactive = false;

            // If this pool has been inactive long enough to be marked
            // unmanaged, then add it back as managed again.
            synchronized (this) {
                if (!ivManaged) {
                    poolMgr.add(this);
                    ivManaged = true;
                }
            }
        }

        discarded = !buffer.pushWithLimit(o, poolSize.maxSize);

        if (discarded) {
            if (discardStrategy != null) {
                discardStrategy.discard(o);
            }
        }

        if (beanPerf != null) { // Update PMI data
            beanPerf.objectReturn(buffer.size(), discarded);
        }
    }
183035
@Override
	public Object put(String key, Object value) {
		if (key == null)
			return null;
		else if (key.indexOf('.') > 0)
			RecursiveObjectWriter.setProperty(this, key, value);
		else
			super.put(key, value);
		return value;
	}
924451
@Override
    public void add(int arg0, Object arg1) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "add", new Object[] { Integer.valueOf(arg0), arg1 });

        synchronized (getMessageLockArtefact()) {
            super.add(arg0, arg1);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.exit(this, tc, "add");
    }
685958
private final void setPersNew() {
		status = ObjectState.PERSISTENT_NEW;
		stateFlags = PS_PERSISTENT | PS_TRANSACTIONAL | PS_DIRTY | PS_NEW;
		context.getSession().internalGetCache().notifyDirty(this);
	}
660750
private void put(Object obj, XmlParser.Node node) throws NoSuchMethodException,
            ClassNotFoundException, InvocationTargetException, IllegalAccessException
    {
        if (!(obj instanceof Map))
                throw new IllegalArgumentException("Object for put is not a Map: " + obj);
        Map map = (Map) obj;

        String name = node.getAttribute("name");
        Object value = value(obj, node);
        map.put(name, value);
        if (log.isDebugEnabled()) log.debug(obj + ".put(" + name + "+" + value + ")");
    }
952386
public void setUnChanged() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setUnChanged");
    changed = false;
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setUnChanged");
  }
180867
public void put(String id,String string,Object value)
    {
	if (DEBUG && id!=null) System.out.println(id+":"+string+" => "+value);
	put(id, new MyWrapper(string), value);
    }
1200445
function(value, sendUpdatedEvt) {
      this.hiddenEl.value = value || "";
      this.el.value  =  value || "";
      // "inherited" from inputex.Field :
      //    (can't inherit of inputex.StringField because would set this.el.value...)
      //
   // set corresponding style
   this.setClassFromState();

   if(sendUpdatedEvt !== false) {
      // fire update event
         this.fireUpdatedEvt();
      }
   }
607930
private void updateAdd()
    {
        if (willAdd)
        {
            for (final Featurable featurable : toAdd)
            {
                featurables.add(featurable);
                for (final HandlerListener listener : listeners)
                {
                    listener.notifyHandlableAdded(featurable);
                }
                if (featurable.hasFeature(Transformable.class))
                {
                    final Transformable transformable = featurable.getFeature(Transformable.class);
                    transformable.teleport(transformable.getX(), transformable.getY());
                }
            }
            toAdd.clear();
            willAdd = false;
        }
    }
812004
@Override
    public void setValue(String value, boolean fireEvents) {
	boolean added = setSelectedValue(this, value, addMissingValue);
	if (added && fireEvents) {
	    ValueChangeEvent.fire(this, getValue());
	}
    }
945844
public function flash( $key, $value )
	{
		$this->put( $key, $value );

		$this->push( 'flash.new', $key );

		$this->removeFromOldFlashData( [$key] );
	}
319830
@Override
	public ValueWrapper putIfAbsent(Object key, Object value) {
		Assert.notNull(key, "key parameter is mandatory");
		Assert.isAssignable(String.class, key.getClass());

		ValueWrapper valueWrapper = get(key);
		if (valueWrapper == null) {
			try {
				this.memcachedClientIF.add((String) key, this.expiration, value).get();
			}
			catch (InterruptedException e) {
				Thread.currentThread().interrupt();
			}
			catch (ExecutionException e) {
				throw new IllegalArgumentException("Error writing key" + key, e);
			}
			return null;
		}
		else {
			return valueWrapper;
		}
	}
937679
void addPendingChange(String key, String value) {
        this.addPendingChange(key, JsonValue.valueOf(value));
    }
492390
private static <T> void  setIfNew(Property<T> prop, T newValue)
  {
    if(!Objects.equals(prop.getValue(), newValue))
    {
      prop.setValue(newValue);
    }
  }
863317
@SuppressLint("CommitPrefEdits")
  @Override public void set(String value) {
    Editor editor = getPreferences().edit().putString(getKey(), value);
    PREF_SAVER.save(editor);
  }
383994
public final void setNewVertexValue(VV newValue) {
		if (setNewVertexValueCalled) {
			throw new IllegalStateException("setNewVertexValue should only be called at most once per updateVertex");
		}
		setNewVertexValueCalled = true;

		outVertex.f1 = newValue;

		out.collect(Either.Left(outVertex));
	}