Create an updated {@link Bindable} instance with a value supplier.
@param suppliedValue the supplier for the value
@return an updated {@link Bindable}
326464
public Bindable<T> withSuppliedValue(Supplier<T> suppliedValue) {
		return new Bindable<>(this.type, this.boxedType, suppliedValue, NO_ANNOTATIONS);
	}
1044381
def update(self, _values=None, **values):
        
        if _values is not None:
            values.update(_values)

        values = OrderedDict(sorted(values.items()))

        bindings = list(values.values()) + self.get_bindings()

        sql = self._grammar.compile_update(self, values)

        return self._connection.update(sql, self._clean_bindings(bindings))
213750
public Try<T> orElse(Supplier<Try<T>> defaultValue) {
    try {
      return isSuccess() ? this : defaultValue.get();
    } catch (RuntimeException e) {
      return new Failure<>(e);
    }
  }
517638
@Override
  public QueryBuilder<V> withBindVariableValue(String key, V value) {
    valueMap.put(key, value);
    return this;
  }
245053
@Override
	public void updateDouble(final String columnLabel, final double x) throws SQLException {
		wrapped.updateDouble(columnLabel, x);
	}
622623
public static <T> Supplier<T> memoized(Supplier<T> actual) {
        return new Supplier<T>() {
            Supplier<T> delegate = this::initialize;
            boolean initialized;

            public T get() {
                return delegate.get();
            }

            private synchronized T initialize() {
                if (!initialized) {
                    T value = actual.get();
                    delegate = () -> value;
                    initialized = true;
                }
                return delegate.get();
            }
        };
    }
572961
@Override
    public boolean updateValuesForField(String currentValue) {
        Utils.require(m_dbObj.getObjectID().equals(currentValue), "Object ID cannot be changed");
        return false;
    }
921376
private static <T> void updateAppLinkDataTable(Map<String, Set<T>> table,
                                                   boolean add,
                                                   String key,
                                                   T value,
                                                   String tracePrefix) // F743-26072
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();

        Set<T> values = table.get(key);
        if (add)
        {
            if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
                Tr.debug(tc, tracePrefix + ": adding " + key + " = " + value);

            if (values == null)
            {
                values = new LinkedHashSet<T>();
                table.put(key, values);
            }

            values.add(value);
        }
        else
        {
            if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
                Tr.debug(tc, tracePrefix + ": removing " + key + " = " + value);

            if (values != null) // d657052
            {
                values.remove(value);
                if (values.size() == 0) // d657052
                {
                    if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
                        Tr.debug(tc, tracePrefix + ": removing " + key);
                    table.remove(key);
                }
            }
            else
            {
                if (isTraceOn && tc.isDebugEnabled() && tracePrefix != null)
                    Tr.debug(tc, tracePrefix + ": key not found: " + key);
            }
        }
    }
1339321
public Versioned<V> update(V newValue, long newVersion) {
    Versioned<V> previousValue = value;
    value = new Versioned<>(newValue, newVersion);
    return previousValue;
  }
342092
private Value createValue(Object obj, ValueFactory factory) throws ValueFormatException
   {
      if (obj instanceof String)
      {
         return factory.createValue((String)obj);
      }
      else if (obj instanceof Calendar)
      {
         return factory.createValue((Calendar)obj);
      }
      else if (obj instanceof Date)
      {
         Calendar cal = Calendar.getInstance();
         cal.setTime((Date)obj);
         return factory.createValue(cal);
      }
      else
      {
         throw new ValueFormatException("Unsupported value type " + obj.getClass());
      }
   }
9361
public void bindUpdate(PreparedStatement stmt, ClassDescriptor cld, Object obj) throws java.sql.SQLException
    {
        if (cld.getUpdateProcedure() != null)
        {
            this.bindProcedure(stmt, cld, obj, cld.getUpdateProcedure());
        }
        else
        {
            int index = 1;
            ValueContainer[] values, valuesSnapshot;
            // first take a snapshot of current locking values
            valuesSnapshot = cld.getCurrentLockingValues(obj);
            cld.updateLockingValues(obj); // BRJ
            values = getNonKeyValues(m_broker, cld, obj);

            // parameters for SET-clause
            for (int i = 0; i < values.length; i++)
            {
                setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());
                index++;
            }
            // parameters for WHERE-clause pk
            values = getKeyValues(m_broker, cld, obj);
            for (int i = 0; i < values.length; i++)
            {
                setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());
                index++;
            }
            // parameters for WHERE-clause locking
            // take old locking values
            values = valuesSnapshot;
            for (int i = 0; i < values.length; i++)
            {
                setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());
                index++;
            }
        }
    }
912509
public void bind() throws Throwable
   {
      if (name == null)
         throw new IllegalArgumentException("Name is null");

      if (obj == null)
         throw new IllegalArgumentException("Obj is null");

      if (trace)
         log.trace("Binding " + obj.getClass().getName() + " under " + name);

      Properties properties = new Properties();
      properties.setProperty(Context.PROVIDER_URL, jndiProtocol + "://" + jndiHost + ":" + jndiPort);
      Context context = new InitialContext(properties);

      try
      {
         String className = obj.getClass().getName();
         Reference ref = new Reference(className,
                                       new StringRefAddr("class", className),
                                       JndiBinder.class.getName(),
                                       null);
         ref.add(new StringRefAddr("name", name));

         objs.put(name, obj);

         Util.bind(context, name, ref);

         if (log.isDebugEnabled())
            log.debug("Bound " + obj.getClass().getName() + " under " + name);
      }
      finally
      {
         if (context != null)
         {
            try
            {
               context.close();
            }
            catch (NamingException ne)
            {
               // Ignore
            }
         }
      }
   }
1327297
@Override
    protected ParameterBinder createBinder(Object[] values) {
        return new SpelExpressionStringQueryParameterBinder((DefaultParameters) getQueryMethod().getParameters(), values, query,
                evaluationContextProvider, parser);
    }
309499
protected PropertyValueBindingBuilder bindProperty( final String name )
    {
        checkNotNull( name, "Property name cannot be null." );

        return new PropertyValueBindingBuilder()
        {

            public void toValue( final String value )
            {
                checkNotNull( value, "Null value not admitted for property '%s's", name );

                bindConstant().annotatedWith( named( name ) ).to( value );
            }

        };
    }
754412
public Consumer<UpdateCellOp> asUpdateCellConsumer() {
        return new Consumer<UpdateCellOp>() {
            @Override
            public void accept(UpdateCellOp op) throws Exception {
                update(op.getArg1());
            }
        };
    }
1340214
public ObjectBindingAssert<T> hasSameValue(ObservableObjectValue<T> expectedValue) {
        new ObservableValueAssertions<>(actual).hasSameValue(expectedValue);
        return this;
    }
676115
public static <T> Bindable<T> of(ResolvableType type) {
		Assert.notNull(type, "Type must not be null");
		ResolvableType boxedType = box(type);
		return new Bindable<>(type, boxedType, null, NO_ANNOTATIONS);
	}