Set TTL since creation.
<p>
Note: Calling this method on a builder with an existing TTL since creation will override the previous value or function.

@param create TTL since creation
@return a new builder with the TTL since creation
974550
public ExpiryPolicyBuilder<K, V> create(Duration create) {
    Objects.requireNonNull(create, "Create duration cannot be null");
    if (create.isNegative()) {
      throw new IllegalArgumentException("Create duration must be positive");
    }
    return create((a, b) -> create);
  }
461519
private synchronized void setCreator(ObjectValue newCreator)
	{
		// Do not set the creator if created by the system class. The System contains
		// fields with references to Thread instances which are not Serializable and
		// will fail a deep copy with a NotSerializableExpection for Thread
		if (newCreator != null
				&& newCreator.type.getClassdef() instanceof ASystemClassDefinition)
		{
			return;
		}
		// establish transitive reference
		newCreator.addChild(this);
	}
1033999
public void setCreate(long now, SimpleOrderedMap<Object> status)
      throws IOException {
    if (action.equals(ComponentCollection.ACTION_CREATE)) {
      this.now = now;
      this.status = status;
    } else {
      throw new IOException("not allowed with action '" + action + "'");
    }
  }
1274021
public void set(String key, String value, int ttl) throws EtcdClientException {
        set(key, value, ttl, null);
    }
173770
@Nonnull
	public static LFltIntPredicate fltIntPredicateFrom(Consumer<LFltIntPredicateBuilder> buildingFunction) {
		LFltIntPredicateBuilder builder = new LFltIntPredicateBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
440965
@Override
	public CommerceOrderPayment create(long commerceOrderPaymentId) {
		CommerceOrderPayment commerceOrderPayment = new CommerceOrderPaymentImpl();

		commerceOrderPayment.setNew(true);
		commerceOrderPayment.setPrimaryKey(commerceOrderPaymentId);

		commerceOrderPayment.setCompanyId(companyProvider.getCompanyId());

		return commerceOrderPayment;
	}
523819
@Nonnull
	public static LByteToCharFunction byteToCharFunctionFrom(Consumer<LByteToCharFunctionBuilder> buildingFunction) {
		LByteToCharFunctionBuilder builder = new LByteToCharFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1282258
public T setMainClass(String mainClass) {
    checkNotNull(mainClass, "mainClass");
    builder.mainClass = mainClass;
    return self();
  }
163802
public static GsonBuilder registerInstant(GsonBuilder builder)
  {
    if (builder == null) { throw new NullPointerException("builder cannot be null"); }

    builder.registerTypeAdapter(INSTANT_TYPE, new InstantConverter());

    return builder;
  }
611606
def build(self, builder):
        
        params = {}

        # Add in the transaction type
        if self.transaction_type is not None:
            params["TransactionType"] = self.transaction_type

        if self.seqnum is None:
            # SeqNum is not optional (and defaulted)
            raise ValueError("SeqNum is not set.")  # pragma: no cover
        params["SeqNum"] = str(self.seqnum)

        if self.annotation_id is not None:
            # If an Annotation is contained with an Annotations element,
            # the ID attribute is required.
            params["ID"] = self.annotation_id

        builder.start("Annotation", params)

        if self.flags in (None, []):
            raise ValueError('Flag is not set.')

        # populate the flags
        for flag in self.flags:
            flag.build(builder)

        # add the Comment, if it exists
        if self.comment is not None:
            self.comment.build(builder)

        builder.end("Annotation")
732690
public String create(Consumer<JWTCreator.Builder> jwtBuilderConsumer) {
        Date issueTime = new Date();
        Date expirationTime = new Date(issueTime.getTime() + defaultExpirationMs);
        JWTCreator.Builder builder = JWT.create()
                // opinionated creation, we enforce using an expiration
                .withIssuer(issuer)
                .withIssuedAt(issueTime)
                .withExpiresAt(expirationTime);
        // apply any additional token customisation
        jwtBuilderConsumer.accept(builder);
        return sign(builder);
    }
1281926
@CheckReturnValue
  public static <ReqT, RespT> Builder<ReqT, RespT> newBuilder(
      Marshaller<ReqT> requestMarshaller, Marshaller<RespT> responseMarshaller) {
    return new Builder<ReqT, RespT>()
        .setRequestMarshaller(requestMarshaller)
        .setResponseMarshaller(responseMarshaller);
  }
617241
public <T extends InteractionAwareFixture> T create(Class<T> clazz) {
        return create(clazz, null, null);
    }
1047481
public Datatype.Builder setBuilderSerializable(boolean builderSerializable) {
    this.builderSerializable = builderSerializable;
    _unsetProperties.remove(Property.BUILDER_SERIALIZABLE);
    return (Datatype.Builder) this;
  }
154403
public <P>JsonModelBuilder<T> add(JsonPropertyBuilderCreator<T> creator1,
			JsonPropertyBuilderCreator<T> creator2) {
		addSub(creator1.<P> get());
		addSub(creator2.<P> get());
		return this;
	}
1118189
public T set(final T newValue) {
        if(continuous!=null)
         continuous.offer(newValue);

        setDiscreteIfDiff(newValue);
        return newValue;
    }
362595
private void assignMinimumTTL(List<? extends DnsAnswer> dnsAnswers, LookupResult.Builder builder) {

        if (config.hasOverrideTTL()) {
            builder.cacheTTL(config.getCacheTTLOverrideMillis());
        } else {
            // Deduce minimum TTL on all TXT records. A TTL will always be returned by DNS server.
            builder.cacheTTL(dnsAnswers.stream()
                                       .map(DnsAnswer::dnsTTL)
                                       .min(Comparator.comparing(Long::valueOf)).get() * 1000);
        }
    }