Java Code Examples for com.google.common.base.Suppliers#memoize()

/**
 * Computes whether the given rule is overridden by another rule with some
 * related shorthand property of equal or higher importance.
 *
 * @param propertyNode the property node of the rule to check
 * @param selector the printed representation of the selector of the rule
 * @param rules rulesets occurring after the ruleset to check (represented as
 *     a map from selector/property pairs to rulesets for easy searching)
 * @param ruleset the ruleset to check (assumed to contain one rule)
 * @return whether the given ruleset has an overriding ruleset which uses a
 *     related shorthand property
 */
private boolean hasOverridingShorthand(
    CssPropertyNode propertyNode,
    String selector,
    Table<String, String, CssRulesetNode> rules,
    final CssRulesetNode ruleset) {

  Supplier<Boolean> rulesetIsImportant = Suppliers.memoize(
      new Supplier<Boolean>() {
        @Override
        public Boolean get() {
          return isImportantRule(ruleset);
        }
      });

  for (String shorthand : propertyNode.getProperty().getShorthands()) {
    CssRulesetNode shorthandRuleset = rules.get(selector, shorthand);
    if ((shorthandRuleset != null)
        && (!rulesetIsImportant.get() || isImportantRule(shorthandRuleset))) {
      return true;
    }
  }

  return false;
}
 

private AstyanaxStorage newAstyanaxStorage(long uuid, int shardsLog2, boolean readsAllowed, final String placement,
                                           final String table) {
    // Delay resolving the placement until it's used so we can manipulate table metadata for placements that
    // don't replicate to the current data center.
    return new AstyanaxStorage(uuid, shardsLog2, readsAllowed, placement, Suppliers.memoize(new Supplier<Placement>() {
        @Override
        public Placement get() {
            try {
                return _placementCache.get(placement);
            } catch (UnknownPlacementException e) {
                // Add table information to the exception
                e.setTable(table);
                throw e;
            }
        }
    }));
}
 

/**
 * Return the {@link IResourceTaskProvider} supplier, initializing it if required.
 *
 * <p>The supplier is memoized, so it will return the same instantiated
 * objects upon repeated calls.
 */
public static Supplier<List<IResourceTaskProvider>> getInstance() {
  return Suppliers.memoize(new Supplier<List<IResourceTaskProvider>>() {
    public List<IResourceTaskProvider> get() {
      return SingletonHolder.instance.getInstances();
    }
  });
}
 

/**
 * Constructor used by PackedGrammar's sortRules()
 * @param lhs todo
 * @param sourceRhs todo
 * @param targetRhs todo
 * @param features todo
 * @param arity todo
 * @param owner todo
 */
public Rule(int lhs, int[] sourceRhs, int[] targetRhs, FeatureVector features, int arity, OwnerId owner) {
  this.lhs = lhs;
  this.source = sourceRhs;
  this.arity = arity;
  this.owner = owner;
  this.target = targetRhs;
  this.featuresSupplier = Suppliers.memoize(() -> features);
  this.sparseFeatureStringSupplier = initializeSparseFeaturesStringSupplier();
  this.alignmentSupplier = initializeAlignmentSupplier();
}
 

private DepositStorage(
    final Eth1EventsChannel eth1EventsChannel,
    final Database database,
    final boolean eth1DepositsFromStorageEnabled) {
  this.eth1EventsChannel = eth1EventsChannel;
  this.database = database;
  this.replayResult = Suppliers.memoize(() -> SafeFuture.of(this::replayDeposits));
  this.eth1DepositsFromStorageEnabled = eth1DepositsFromStorageEnabled;
}
 

/**
 * Constructs a CommunityList with the given name for {@link #_name}, and lines for {@link
 * #_lines}
 *
 * @param name The name of the structure
 * @param lines The lines in the list
 */
public CommunityList(
    @Nonnull String name, @Nonnull List<CommunityListLine> lines, boolean invertMatch) {
  _name = name;
  _lines = lines;
  _invertMatch = invertMatch;
  _communityCache = Suppliers.memoize(new CommunityCacheSupplier());
}
 

/** Creates a ProfilerLatticeStatisticProvider. */
private ProfilerLatticeStatisticProvider(Lattice lattice) {
  Objects.requireNonNull(lattice);
  this.profile = Suppliers.memoize(() -> {
    final ProfilerImpl profiler =
        ProfilerImpl.builder()
            .withPassSize(200)
            .withMinimumSurprise(0.3D)
            .build();
    final List<Profiler.Column> columns = new ArrayList<>();
    for (Lattice.Column column : lattice.columns) {
      columns.add(new Profiler.Column(column.ordinal, column.alias));
    }
    final String sql =
        lattice.sql(ImmutableBitSet.range(lattice.columns.size()),
            false, ImmutableList.of());
    final Table table =
        new MaterializationService.DefaultTableFactory()
            .createTable(lattice.rootSchema, sql, ImmutableList.of());
    final ImmutableList<ImmutableBitSet> initialGroups =
        ImmutableList.of();
    final Enumerable<List<Comparable>> rows =
        ((ScannableTable) table).scan(null)
            .select(values -> {
              for (int i = 0; i < values.length; i++) {
                if (values[i] == null) {
                  values[i] = NullSentinel.INSTANCE;
                }
              }
              //noinspection unchecked
              return (List<Comparable>) (List) Arrays.asList(values);
            });
    return profiler.profile(rows, columns, initialGroups);
  })::get;
}
 

public BigQueryCredentialsSupplier(Optional<String> credentialsKey, Optional<String> credentialsFile)
{
    requireNonNull(credentialsKey, "credentialsKey is null");
    requireNonNull(credentialsFile, "credentialsFile is null");
    // lazy creation, cache once it's created
    this.credentialsCreator = Suppliers.memoize(() -> {
        Optional<Credentials> credentialsFromKey = credentialsKey.map(BigQueryCredentialsSupplier::createCredentialsFromKey);
        Optional<Credentials> credentialsFromFile = credentialsFile.map(BigQueryCredentialsSupplier::createCredentialsFromFile);
        return Stream.of(credentialsFromKey, credentialsFromFile)
                .flatMap(Streams::stream)
                .findFirst();
    });
}
 

private Supplier<byte[]> initializeAlignmentSupplier(){
  return Suppliers.memoize(() ->{
    byte[] raw_alignment = getAlignmentArray(source[address + 2]);
    byte[] points = new byte[raw_alignment.length + 2];
    points[0] = points[1] = 0;
    for (int i = 0; i < raw_alignment.length; i++)
      points[i + 2] = (byte) (raw_alignment[i] + 1);
    return points;
  });
}
 

private static Supplier<LookupDataSource> createBPartnerLocationLookup()
{
	return Suppliers.memoize(() -> LookupDataSourceFactory.instance
			.getLookupDataSource(SqlLookupDescriptor.builder()
					.setCtxTableName(null)
					.setCtxColumnName(I_M_PickingSlot.COLUMNNAME_C_BPartner_Location_ID)
					.setDisplayType(DisplayType.Search)
					.setWidgetType(DocumentFieldWidgetType.Lookup)
					.buildForDefaultScope()));
}
 

private static Supplier<ImmutableSet<JavaLibrary>> createTransitiveClasspathDepsSupplier(
    SourcePathRuleFinder ruleFinder, AndroidGraphEnhancementResult enhancementResult) {
  return Suppliers.memoize(
      () ->
          JavaLibraryClasspathProvider.getClasspathDeps(
              ruleFinder
                  .filterBuildRuleInputs(enhancementResult.getClasspathEntriesToDex().stream())
                  .collect(ImmutableSet.toImmutableSet())));
}
 

private void createAndRegister(final StorageService service) {
  final List<SegmentIdentifier> segments = service.getAllSegmentIdentifiers();

  final Supplier<RocksDBFactoryConfiguration> configuration =
      Suppliers.memoize(options::toDomainObject);
  factory =
      new RocksDBKeyValueStorageFactory(
          configuration, segments, RocksDBMetricsFactory.PUBLIC_ROCKS_DB_METRICS);
  privacyFactory = new RocksDBKeyValuePrivacyStorageFactory(factory);

  service.registerKeyValueStorage(factory);
  service.registerKeyValueStorage(privacyFactory);
}
 

Bound(DoubleArray xValues, DoubleArray yValues) {
  super(xValues, yValues);
  this.xValues = xValues.toArrayUnsafe();
  this.yValues = yValues.toArrayUnsafe();
  PiecewisePolynomialInterpolator underlying = new NaturalSplineInterpolator();
  this.poly = underlying.interpolate(xValues.toArray(), yValues.toArray());
  this.polySens = Suppliers.memoize(() -> underlying.interpolateWithSensitivity(xValues.toArray(), yValues.toArray()));
}
 

FieldAccessTarget(FieldAccessTargetBuilder builder) {
    super(builder.getOwner(), builder.getName(), builder.getFullName());
    this.type = builder.getType();
    this.field = Suppliers.memoize(builder.getField());
}
 

Supplier<ExtensionPointInterface> createLazyLoader( PluginInterface extensionPointPlugin ) {
  return Suppliers.memoize( new ExtensionPointLoader( extensionPointPlugin ) );
}
 

public MemoizedSupplier(Supplier<T> originalSupplier) {
    this.memorizeSupplier = Suppliers.memoize(originalSupplier::get);
    this.valueReference = new AtomicReference<>();
}
 

public CollaborationWikiStore(final LegacyKVStoreProvider storeProvider) {
  Preconditions.checkNotNull(storeProvider, "kvStore provider required");
  wikiStore = Suppliers.memoize(() -> storeProvider.getStore(CollaborationWikiStore.CollaborationWikiStoreStoreCreator.class));
}
 

JavaField(DomainBuilders.JavaFieldBuilder builder) {
    super(builder);
    type = builder.getType();
    fieldSupplier = Suppliers.memoize(new ReflectFieldSupplier());
}
 

protected PlatformConfig(Supplier<ModuleConfigRepository> repositorySupplier, Path configDir) {
    this.repositorySupplier = Suppliers.memoize(Objects.requireNonNull(repositorySupplier));
    this.configDir = FileUtil.createDirectory(configDir);
}
 

JavaMethod(DomainBuilders.JavaMethodBuilder builder) {
    super(builder);
    throwsClause = builder.getThrowsClause(this);
    methodSupplier = Suppliers.memoize(new ReflectMethodSupplier());
    annotationDefaultValue = builder.getAnnotationDefaultValue();
}