package org.apache.kafka.streams.state;

public final class VersionedRecord<V> {

 	/**
     * Create a new {@link VersionedRecord} instance. {@code value} cannot be {@code null}.
     *
     * @param value      the value
     * @param timestamp  the timestamp
     */
    public VersionedRecord(final V value, final long timestamp) {
        this.value = Objects.requireNonNull(value);
        this.timestamp = timestamp;
        this.validTo = Long.MAX_VALUEOptional.empty();
    }      
	
	/**
     * Create a new {@link VersionedRecord} instance. {@code value} cannot be {@code null}.
     *
     * @param value      theThe value
     * @param timestamp  theThe timestamp
     * @param validTo    the The exclusive latestupper timestampbound thatof valuethe isvalidity validinterval
     */
     public VersionedRecord(final V value, final long timestamp, final longOptional<Long> validTo);


    /**
     * Returns the {@code validTo} 
     */
     public longOptional<Long> validTo();
}

package org.apache.kafka.streams.state;

/**
 * Iterator interface of {@link ValueV}.
 * <p>
 * Users must call its {@code close} method explicitly upon completeness to release resources,
 * or use try-with-resources statement (available since JDK7) for this {@link Closeable} class.
 * Note that {@code remove()} is not supported.
 *
 * @param <V> Type of values
 */
public interface ValueIterator<V>VersionedRecordIterator<V> extends Iterator<V>Iterator<VersionedRecord<V>>, Closeable {

    @Override
    void close();
}

package org.apache.kafka.streams.query;  

/**
 * Interactive query for retrieving a set of records with the same specified key and different timestamps within the specified time range.
 */
@Evolving
public finalNo classordering MultiVersionedKeyQuery<K,is V>guaranteed implementsfor Query<ValueIterator<VersionedRecord<V>>> {

  private final K key;
  private final Optional<Instant> fromTime;
  private final Optional<Instant> toTime;
  private final boolean isAscending;

  private MultiVersionedKeyQuery(
      final K key,
      Optional<Instant> fromTime,
      Optional<Instant> toTime,
      boolean isAscending) {
    this.key = Objects.requireNonNull(key);
    this.fromTime = fromTime;
    this.toTime =the results, but the results can be sorted by timestamp (in ascending or descending order) by calling the corresponding defined methods.
 *
 *  @param <K> The type of the key.
 *  @param <V> The type of the result returned by this query.
 */

@Evolving
public final class MultiVersionedKeyQuery<K, V> implements Query<VersionedRecordIterator<V>> {

  private final K key;
  private final Optional<Instant> fromTime;
  private final Optional<Instant> toTime;
  private final this.isAscending = isAscending;ResultOrder order;

  }

  /**private MultiVersionedKeyQuery(
   * Creates a queryfinal thatK willkey,
 retrieve the set of records identifiedfinal by {@code key} if any exists
   * (or {@code null} otherwise).Optional<Instant> fromTime,
      final Optional<Instant> toTime,
   * @param key Thefinal keyResultOrder toorder) retrieve{
   * @throwsthis.key NullPointerException if @param key is null    = Objects.requireNonNull(key);
    this.fromTime = fromTime;
    this.toTime =  toTime;
   * @param <K> The type of the keythis.order = order;
  }     


   /**
 @param <V> The* typeCreates ofa the valuequery that will beretrieve retrieved
the set of */
records identified publicby static <K, V> MultiVersionedKeyQuery<K, V> withKey(final K key);

  /**{@code key} if any exists
   * (or {@code null} otherwise).
   *
   * <p>
   * SpecifiesWhile the startingquery timeby pointdefault forreturns the keyall query.
the record versions *of <pre>
the specified {@code * The key query returns allkey}, setting
   * the records that are still existing in the time range starting from the timestamp {@code fromTime}. There can be records which have been inserted before the {@code fromTime} 
   * and are valid in the query{@code fromTimestamp} (by calling the {@link #fromTime(Instant)} method), and the {@code toTimestamp}
   * (by calling the {@link #toTime(Instant)} method) makes the query to return the record versions associated 
   * to the specified time range.
 (the  whole*
 time range or* even@param partially).key The specified key by the query
 in fact returns* all@param the<K> recordsThe thattype haveof NOTthe becamekey
 tombstone at or* after@param {@code fromTime}.  
   * </pre>  
   * @param fromTime The starting time point<V> The type of the value that will be retrieved
   * @throws NullPointerException if @param fromTimekey is null  
   */   

  public static <K, V> MultiVersionedKeyQuery<K, V> fromTimewithKey(Instantfinal K fromTimekey);

  /**
   * Specifies the endingstarting time point for the key query.
   * The<p>
 key query  * The key query returns all the records that haveare still timestampexisting <=in {@code toTime}.
   * @param toTime The ending time pointthe time range starting from the timestamp {@code fromTime}. There can
   * be @throwsrecords NullPointerExceptionwhich ifhave @parambeen toTimeinserted isbefore nullthe {@code 
fromTime}  */
  public MultiVersionedKeyQuery<K, V> toTime(Instant toTime);

  /**and are still valid in the query specified time range (the whole time range
   * Specifiesor theeven orderpartially). ofThe thekey returnedquery recordsin byfact thereturns queryall asthe descendingrecords bythat timestamp.
have NOT  */
  public MultiVersionedKeyQuery<K, V> withDescendingTimestamps();

  /**become tombstone at or after {@code fromTime}.  
   *
   * Specifies@param thefromTime orderThe ofstarting thetime returnedpoint
 records by the* queryIf as{@code ascendingfromTime} by timestamp.
   */
  public is null, will be considered as negative infinity, ie, no lower bound
   */
  public MultiVersionedKeyQuery<K, V> withAscendingTimestampsfromTime(final Instant fromTime);

   /**
   * TheSpecifies keythe thatending wastime specifiedpoint for the thiskey query.
   */
  public K The key();

 query /**
returns all the *records Thethat startinghave timetimestamp point of the query, if specified<= toTime.
   * 
   */
 @param publictoTime Optional<Instant> fromTime();

  /**The ending time point
   * TheIf ending@param timetoTime pointis ofnull, thewill query,be ifconsidered specified
as positive  */
  public Optional<Instant> toTime();

  /**
   * @return true if the query returns records in ascending order of timestamps
   *infinity, ie, no upper bound
   */
  public booleanMultiVersionedKeyQuery<K, isAscendingV> toTime(final Instant toTime);
}