Java GroupCache类代码示例

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
AccountCreator(
    SchemaFactory<ReviewDb> schema,
    Sequences sequences,
    AccountsUpdate.Server accountsUpdate,
    VersionedAuthorizedKeys.Accessor authorizedKeys,
    GroupCache groupCache,
    @ServerInitiated Provider<GroupsUpdate> groupsUpdateProvider,
    SshKeyCache sshKeyCache,
    ExternalIdsUpdate.Server externalIdsUpdate,
    @SshEnabled boolean sshEnabled) {
  accounts = new HashMap<>();
  reviewDbProvider = schema;
  this.sequences = sequences;
  this.accountsUpdate = accountsUpdate;
  this.authorizedKeys = authorizedKeys;
  this.groupCache = groupCache;
  this.groupsUpdateProvider = groupsUpdateProvider;
  this.sshKeyCache = sshKeyCache;
  this.externalIdsUpdate = externalIdsUpdate;
  this.sshEnabled = sshEnabled;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
protected ListGroups(
    final GroupCache groupCache,
    final GroupControl.Factory groupControlFactory,
    final GroupControl.GenericFactory genericGroupControlFactory,
    final Provider<IdentifiedUser> identifiedUser,
    final IdentifiedUser.GenericFactory userFactory,
    final GetGroups accountGetGroups,
    final GroupsCollection groupsCollection,
    GroupJson json,
    GroupBackend groupBackend,
    Groups groups,
    Provider<ReviewDb> db) {
  this.groupCache = groupCache;
  this.groupControlFactory = groupControlFactory;
  this.genericGroupControlFactory = genericGroupControlFactory;
  this.identifiedUser = identifiedUser;
  this.userFactory = userFactory;
  this.accountGetGroups = accountGetGroups;
  this.json = json;
  this.groupBackend = groupBackend;
  this.groups = groups;
  this.groupsCollection = groupsCollection;
  this.db = db;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
LuceneGroupIndex(
    @GerritServerConfig Config cfg,
    SitePaths sitePaths,
    Provider<GroupCache> groupCache,
    @Assisted Schema<InternalGroup> schema)
    throws IOException {
  super(
      schema,
      sitePaths,
      dir(schema, cfg, sitePaths),
      GROUPS,
      null,
      new GerritIndexWriterConfig(cfg, GROUPS),
      new SearcherFactory());
  this.groupCache = groupCache;

  indexWriterConfig = new GerritIndexWriterConfig(cfg, GROUPS);
  queryBuilder = new QueryBuilder<>(schema, indexWriterConfig.getAnalyzer());
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
public AccountsImpl(
    AccountResolver resolver,
    AccountCache byId,
    ReviewDb db,
    GroupCache groupCache,
    GroupMembers.Factory groupMembersFactory,
    OneOffRequestContext oneOffRequestContext,
    IdentifiedUser.GenericFactory userFactory) {
  this.resolver = resolver;
  this.byId = byId;
  this.db = db;
  this.groupCache = groupCache;
  this.groupMembers = groupMembersFactory;
  this.adminUser = userFactory.create(new Account.Id(1000000));
  this.oneOffRequestContext = oneOffRequestContext;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Override
protected void configure() {
  // The AccountIndex implementations (LuceneAccountIndex and
  // ElasticAccountIndex) need AccountCache only for reading from the index.
  // On init we only want to write to the index, hence we don't need the
  // account cache.
  bind(AccountCache.class).toProvider(Providers.of(null));

  // AccountIndexDefinition wants to have AllAccountsIndexer but it is only
  // used by the Reindex program and the OnlineReindexer which are both not
  // used during init, hence we don't need AllAccountsIndexer.
  bind(AllAccountsIndexer.class).toProvider(Providers.of(null));

  bind(AccountIndexCollection.class);

  // The GroupIndex implementations (LuceneGroupIndex and ElasticGroupIndex)
  // need GroupCache only for reading from the index. On init we only want to
  // write to the index, hence we don't need the group cache.
  bind(GroupCache.class).toProvider(Providers.of(null));

  // GroupIndexDefinition wants to have AllGroupsIndexer but it is only used
  // by the Reindex program and the OnlineReindexer which are both not used
  // during init, hence we don't need AllGroupsIndexer.
  bind(AllGroupsIndexer.class).toProvider(Providers.of(null));

  bind(GroupIndexCollection.class);

  bind(new TypeLiteral<Map<String, Integer>>() {})
      .annotatedWith(Names.named(SingleVersionModule.SINGLE_VERSIONS))
      .toInstance(ImmutableMap.<String, Integer>of());
  bind(LifecycleListener.class)
      .annotatedWith(Names.named(INDEX_MANAGER))
      .to(SingleVersionListener.class);
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
protected ListMembersCommandImpl(
    GroupCache groupCache,
    GroupControl.Factory groupControlFactory,
    AccountLoader.Factory accountLoaderFactory) {
  super(groupCache, groupControlFactory, accountLoaderFactory);
  this.groupCache = groupCache;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
Arguments(
    GroupIndexCollection groupIndexCollection,
    GroupCache groupCache,
    GroupBackend groupBackend,
    AccountResolver accountResolver) {
  this.groupIndex = groupIndexCollection.getSearchIndex();
  this.groupCache = groupCache;
  this.groupBackend = groupBackend;
  this.accountResolver = accountResolver;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
public GetAuditLog(
    Provider<ReviewDb> db,
    AccountLoader.Factory accountLoaderFactory,
    GroupCache groupCache,
    GroupJson groupJson,
    GroupBackend groupBackend,
    Groups groups) {
  this.db = db;
  this.accountLoaderFactory = accountLoaderFactory;
  this.groupCache = groupCache;
  this.groupJson = groupJson;
  this.groupBackend = groupBackend;
  this.groups = groups;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
protected ListMembers(
    GroupCache groupCache,
    GroupControl.Factory groupControlFactory,
    AccountLoader.Factory accountLoaderFactory) {
  this.groupCache = groupCache;
  this.groupControlFactory = groupControlFactory;
  this.accountLoader = accountLoaderFactory.create(true);
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
CreateGroup(
    Provider<IdentifiedUser> self,
    @GerritPersonIdent PersonIdent serverIdent,
    ReviewDb db,
    @UserInitiated Provider<GroupsUpdate> groupsUpdateProvider,
    GroupCache groupCache,
    GroupsCollection groups,
    GroupJson json,
    DynamicSet<GroupCreationValidationListener> groupCreationValidationListeners,
    AddMembers addMembers,
    SystemGroupBackend systemGroupBackend,
    @GerritServerConfig Config cfg,
    @Assisted String name,
    Sequences sequences) {
  this.self = self;
  this.serverIdent = serverIdent;
  this.db = db;
  this.groupsUpdateProvider = groupsUpdateProvider;
  this.groupCache = groupCache;
  this.groups = groups;
  this.json = json;
  this.groupCreationValidationListeners = groupCreationValidationListeners;
  this.addMembers = addMembers;
  this.systemGroupBackend = systemGroupBackend;
  this.defaultVisibleToAll = cfg.getBoolean("groups", "newGroupsVisibleToAll", false);
  this.name = name;
  this.sequences = sequences;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
DbGroupMemberAuditListener(
    SchemaFactory<ReviewDb> schema,
    AccountCache accountCache,
    GroupCache groupCache,
    UniversalGroupBackend groupBackend) {
  this.schema = schema;
  this.accountCache = accountCache;
  this.groupCache = groupCache;
  this.groupBackend = groupBackend;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@AssistedInject
GroupIndexerImpl(
    GroupCache groupCache,
    DynamicSet<GroupIndexedListener> indexedListener,
    @Assisted GroupIndexCollection indexes) {
  this.groupCache = groupCache;
  this.indexedListener = indexedListener;
  this.indexes = indexes;
  this.index = null;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
AllGroupsIndexer(
    SchemaFactory<ReviewDb> schemaFactory,
    @IndexExecutor(BATCH) ListeningExecutorService executor,
    GroupCache groupCache,
    Groups groups) {
  this.schemaFactory = schemaFactory;
  this.executor = executor;
  this.groupCache = groupCache;
  this.groups = groups;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
public AccountGroupIdHandler(
    final GroupCache groupCache,
    @Assisted final CmdLineParser parser,
    @Assisted final OptionDef option,
    @Assisted final Setter<AccountGroup.Id> setter) {
  super(parser, option, setter);
  this.groupCache = groupCache;
}
 

import com.google.gerrit.server.account.GroupCache; //导入依赖的package包/类
@Inject
ElasticGroupIndex(
    @GerritServerConfig Config cfg,
    SitePaths sitePaths,
    Provider<GroupCache> groupCache,
    JestClientBuilder clientBuilder,
    @Assisted Schema<InternalGroup> schema) {
  super(cfg, sitePaths, schema, clientBuilder, GROUPS_PREFIX);
  this.groupCache = groupCache;
  this.mapping = new GroupMapping(schema);
}