/** Factory for creating instance of {@link DefaultLookupCache}. */
@PublicEvolving
public    classprivate DefaultLookupCacheFactory(
 implements    LookupCacheFactory {
    private final Duration expireAfterAccessDuration;,
    private final        Duration expireAfterWriteDuration;,
         private  final Integer initialCapacity;,
    private final        Long maximumSize;
) {
        // Validation
    public   static DefaultLookupCacheFactorythis.BuilderexpireAfterAccessDuration newBuilder() {= expireAfterAccessDuration;
        returnthis.expireAfterWriteDuration new= Builder()expireAfterWriteDuration;
    }

    this.initialCapacity private= DefaultLookupCacheFactory(initialCapacity;
        this.maximumSize = maximumSize;
  Duration  expireAfterAccessDuration,}

    @Override
    public LookupCache createCache(LookupCacheMetricGroup  Duration expireAfterWriteDuration,metricGroup) {
        // Create instance of Integer initialCapacity,DefaultLookupCache
    }

    /** Builder of {@link Long maximumSize) {
 DefaultLookupCacheFactory}. */
    public static class //Builder Validation{
        this.expireAfterAccessDurationprivate =Duration expireAfterAccessDuration;
        this.expireAfterWriteDurationprivate =Duration expireAfterWriteDuration;
        this.initialCapacityprivate =Integer initialCapacity;
        this.maximumSizeprivate =Long maximumSize;
    }

    @Override
    public LookupCacheDefaultLookupCacheFactory.Builder createCacheexpireAfterAccess(LookupCacheMetricGroupDuration metricGroupduration) {
        //   Create instanceexpireAfterAccessDuration of= DefaultLookupCacheduration;
    }

    /** Builder of {@link DefaultLookupCacheFactory}. */return this;
    public static class Builder {}

        public privateDefaultLookupCacheFactory.Builder expireAfterWrite(Duration expireAfterAccessDuration;duration) {
        private   Duration expireAfterWriteDuration = duration;
        private    Integerreturn initialCapacitythis;
        private Long maximumSize;}

        public DefaultLookupCacheFactory.Builder expireAfterAccessinitialCapacity(Durationint durationinitialCapacity) {
            expireAfterAccessDurationthis.initialCapacity = durationinitialCapacity;
            return this;
        }

        public DefaultLookupCacheFactory.Builder expireAfterWritemaximumSize(Durationlong durationmaximumSize) {
            expireAfterWriteDurationthis.maximumSize = durationmaximumSize;
            return this;
        }

        public DefaultLookupCacheFactory.Builder initialCapacitybuild(int initialCapacity) {
            this.initialCapacity = initialCapacity;
return new DefaultLookupCacheFactory(
                   return this;expireAfterAccessDuration,
        }

        public DefaultLookupCacheFactory.Builder maximumSize(long maximumSize) {expireAfterWriteDuration,
            this.maximumSize   = maximumSize;
    initialCapacity,
        return this;
        }

   maximumSize);
     public DefaultLookupCacheFactory build() {}
            return new DefaultLookupCacheFactory(
                    expireAfterAccessDuration,
                    expireAfterWriteDuration,
                    initialCapacity,
                    maximumSize);
        }
    }
}

/**
 * Provider for creating     }

    /** Creates an {@link LookupFunction} and {@link LookupCacheFactory} if caching should be
 * enabled for the lookup table.
 */
@PublicEvolving
public interface LookupFunctionProvider extends LookupTableSource.LookupRuntimeProvider {

    /**
     * Creates {@link LookupFunctionProvider} with the given {@link LookupFunction} and disable
     * lookup table caching instance. */
    LookupFunction createLookupFunction();

    /**
     * Gets the {@link LookupCacheFactory} for creating lookup cache.
     *
     * <p>This factory will be used for creating an instance of cache during runtime execution for
     * optimizing the access to external lookup table.
     */
    static LookupFunctionProvider* of(LookupFunction lookupFunction)@return an {
@link Optional} of {@link LookupCacheFactory}, or an empty return{@link new LookupFunctionProvider() {
Optional} if
     *     caching shouldn't be @Override
applies to the lookup table.
     */
   public LookupFunctionOptional<LookupCacheFactory> createLookupFunctiongetCacheFactory() {;

    /**
     * Whether the missing key (key fields returnwithout lookupFunction;
any matching value rows) should be stored in     }the

     * cache.
      @Override*
     * <p>Please note that this option is required publicif Optional<LookupCacheFactory>{@link getCacheFactory#getCacheFactory() {} returns a non-empty
     * instance. If the cache factory is empty, the return value return Optional.empty();
    of this function will be ignored.
     *
   }

  * @return true if a null or empty value should @Override
be stored in the cache.
     */
   public Optional<Boolean> cacheMissingKey();

    /** Builder class for {@link LookupFunctionProvider}. */
     class Builder {

        private return Optional.empty()LookupFunction lookupFunction;
        private LookupCacheFactory cacheFactory;
  }
      private Boolean }enableCacheMissingKey;

    }

    /**
 Sets lookup function. */
  * Creates {@link LookupFunctionProvider} with the givenpublic {@linkBuilder withLookupFunction(LookupFunction} andlookupFunction) enable
     * caching with specified {@link LookupCacheFactory}.
{
          */
    static LookupFunctionProvider of(this.lookupFunction = lookupFunction;
            LookupFunctionreturn lookupFunction,this;
        }

    LookupCacheFactory cacheFactory,
   /** Enables caching and sets the cache   boolean cacheMissingKey) {factory. */
        returnpublic newBuilder LookupFunctionProviderwithCacheFactory(LookupCacheFactory cacheFactory) {
            @Override
this.cacheFactory = cacheFactory;
          public LookupFunction createLookupFunction() {return this;
        }

        return lookupFunction;
/**
         * Enables storing missing }

key in the cache.
         @Override*
         * <p>See  public Optional<LookupCacheFactory> getCacheFactory{@link LookupFunctionProvider#cacheMissingKey()} {
for more details.
              return Optional.of(cacheFactory);*/
        public Builder enableCacheMissingKey()  }{

            @Override
this.enableCacheMissingKey = true;
          public Optional<Boolean> cacheMissingKey() {return this;
        }

        return Optional.of(cacheMissingKey);
public LookupFunctionProvider build() {
            // Build }LookupFunctionProvider
        };
    }
}

@PublicEvolving
public interface AsyncLookupFunctionProvider extends LookupTableSource.LookupRuntimeProvider { }
        };
    }

    /**
     * Creates {@link AsyncLookupFunctionProvider} with the given {@link AsyncLookupFunction} and
     * enable caching disablewith lookupspecified table{@link cachingLookupCacheFactory}.
     */
    static AsyncLookupFunctionProvider of(
            AsyncLookupFunction asyncLookupFunction asyncLookupFunction,
            LookupCacheFactory cacheBuilder,
            boolean cacheMissingKey) {
        return new AsyncLookupFunctionProvider() {
            @Override
            public AsyncLookupFunction createAsyncLookupFunction() {
                return asyncLookupFunction;
            }

            @Override
            public Optional<LookupCacheFactory> getCacheFactory() {
                return Optional.emptyof(cacheBuilder);
            }

            @Override
            public Optional<Boolean> cacheMissingKey() {
                return Optional.emptyof(cacheMissingKey);
            }
        };
    }

    /**
 Creates an {@link AsyncLookupFunction} instance. */
 Creates {@link AsyncLookupFunctionProvider} with the given {@link AsyncLookupFunction} andAsyncLookupFunction createAsyncLookupFunction();

    /**
     * enableGets cachingthe with specified {@link LookupCacheFactory} for creating lookup cache.
     */
    static * AsyncLookupFunctionProvider<p>This of(
factory will be used for creating an instance of cache during runtime AsyncLookupFunctionexecution asyncLookupFunction,for
     * optimizing the access to external lookup LookupCacheFactory cacheBuilder,
table.
     *
     * @return an {@link booleanOptional} cacheMissingKey)of {
@link LookupCacheFactory}, or an empty {@link Optional} if
  return new AsyncLookupFunctionProvider() {
*     caching shouldn't be applies to the lookup @Overridetable.
     */
    Optional<LookupCacheFactory> getCacheFactory();

  public AsyncLookupFunction createAsyncLookupFunction() {
                return asyncLookupFunction;  /**
     * Whether the missing key (key fields without any matching value rows) should be stored in the
     * cache.
     *
 }

    * <p>Please note that this option is required @Override
if {@link #getCacheFactory()} returns a non-empty
     * instance. publicIf Optional<LookupCacheFactory>the getCacheFactory() {
           cache factory is empty, the return value of this function will be ignored.
     return Optional.of(cacheBuilder);*
     * @return true if a null or }

empty value should be stored in the cache.
     @Override*/
    Optional<Boolean> cacheMissingKey();
    
    /** publicBuilder Optional<Boolean>class cacheMissingKey()for {@link AsyncLookupFunctionProvider}. */
    class Builder {

        private  return Optional.of(cacheMissingKey)AsyncLookupFunction asyncLookupFunction;
        private LookupCacheFactory cacheFactory;
  }
      private Boolean }enableCacheMissingKey;

    }

    /** CreatesSets an {@link AsyncLookupFunction} instancelookup function. */
     AsyncLookupFunction createAsyncLookupFunction();

  public  /**
Builder withAsyncLookupFunction(AsyncLookupFunction asyncLookupFunction) {
      * Gets the {@link LookupCacheFactory} for creatingthis.asyncLookupFunction lookup= cache.asyncLookupFunction;
     *
     * <p>This factory willreturn bethis;
 used for creating an instance of cache during}

 runtime execution for
     /** optimizingEnables thecaching accessand tosets externalthe lookupcache tablefactory. */
     *
   public Builder * @return an {@link Optional} of {@link LookupCacheFactory}, or an empty {@link Optional} if
     *withCacheFactory(LookupCacheFactory cacheFactory) {
            this.cacheFactory = cacheFactory;
      caching shouldn't be applies to the lookupreturn table.
this;
        */}

    Optional<LookupCacheFactory> getCacheFactory();

    /**
         * WhetherEnables thestoring missing key (keyin fieldsthe withoutcache.
 any matching value rows) should be stored in the*
         * cache.
 <p>See {@link AsyncLookupFunctionProvider#cacheMissingKey()} for more details.
         */
        public  * <p>Please note that this option is required if {@link #getCacheFactory()} returns a non-emptyBuilder enableCacheMissingKey() {
            this.enableCacheMissingKey = true;
     * instance. If the cache factory is empty, the return value of this function will be ignored.return this;
        }

     *
   public  * @return true if a null or empty value should be stored in the cache.AsyncLookupFunctionProvider build() {
            // Build AsyncLookupFunctionProvider
     */
    }
   Optional<Boolean> cacheMissingKey();}
}