org.bukkit.entity.ComplexEntityPart#com.google.common.collect.ImmutableSet.Builder源码实例Demo

public Set<String> getIncomingChannels(Plugin plugin) {
    if (plugin == null) {
        throw new IllegalArgumentException("Plugin cannot be null");
    }

    synchronized (incomingLock) {
        Set<PluginMessageListenerRegistration> registrations = incomingByPlugin.get(plugin);

        if (registrations != null) {
            Builder<String> builder = ImmutableSet.builder();

            for (PluginMessageListenerRegistration registration : registrations) {
                builder.add(registration.getChannel());
            }

            return builder.build();
        } else {
            return ImmutableSet.of();
        }
    }
}
 

public Set<PluginMessageListenerRegistration> getIncomingChannelRegistrations(Plugin plugin, String channel) {
    if (plugin == null) {
        throw new IllegalArgumentException("Plugin cannot be null");
    }
    validateChannel(channel);

    synchronized (incomingLock) {
        Set<PluginMessageListenerRegistration> registrations = incomingByPlugin.get(plugin);

        if (registrations != null) {
            Builder<PluginMessageListenerRegistration> builder = ImmutableSet.builder();

            for (PluginMessageListenerRegistration registration : registrations) {
                if (registration.getChannel().equals(channel)) {
                    builder.add(registration);
                }
            }

            return builder.build();
        } else {
            return ImmutableSet.of();
        }
    }
}
 

@Override
public void fromBytes(ByteBuf b){
    trainID = b.readInt();

    int ids = b.readInt();
    PacketBuffer pb = new PacketBuffer(b);
    Builder<UUID> cartIDs = new ImmutableSet.Builder<>();
    for(int i = 0; i < ids; i++) {
        cartIDs.add(pb.readUniqueId());
    }
    this.cartIDs = cartIDs.build();

    int posCount = b.readInt();
    Builder<MCPos> positions = new ImmutableSet.Builder<>();
    for(int i = 0; i < posCount; i++) {
        positions.add(new MCPos(b));
    }
    this.positions = positions.build();
}
 

@Test
void legacyDiscoverySpec() throws Throwable {
    final List<Endpoint> sampleEndpoints = ZooKeeperTestUtil.sampleEndpoints(3);
    setLegacySpecNodeChildren(sampleEndpoints);
    final ZooKeeperEndpointGroup endpointGroup = endpointGroup(ZooKeeperDiscoverySpec.legacy());
    await().untilAsserted(() -> assertThat(endpointGroup.endpoints()).hasSameElementsAs(sampleEndpoints));

    // Add two more nodes.
    final List<Endpoint> extraEndpoints = ZooKeeperTestUtil.sampleEndpoints(2);
    setLegacySpecNodeChildren(extraEndpoints);

    // Construct the final expected node list.
    final Builder<Endpoint> builder = ImmutableSet.builder();
    builder.addAll(sampleEndpoints).addAll(extraEndpoints);
    try (CloseableZooKeeper zk = zkInstance.connection()) {
        zk.sync(Z_NODE, (rc, path, ctx) -> {}, null);
    }

    final Set<Endpoint> expected = builder.build();
    await().untilAsserted(() -> assertThat(endpointGroup.endpoints()).hasSameElementsAs(expected));
    disconnectZk(endpointGroup);
}
 

@Test
void curatorDiscovery() throws Throwable {
    final List<Endpoint> sampleEndpoints = ZooKeeperTestUtil.sampleEndpoints(3);
    setCuratorXNodeChildren(sampleEndpoints, 0);
    final ZooKeeperDiscoverySpec spec = ZooKeeperDiscoverySpec.builderForCurator(CURATOR_X_SERVICE_NAME)
                                                              .build();
    final ZooKeeperEndpointGroup endpointGroup = endpointGroup(spec);
    await().untilAsserted(() -> assertThat(endpointGroup.endpoints()).hasSameElementsAs(sampleEndpoints));

    // Add two more nodes.
    final List<Endpoint> extraEndpoints = ZooKeeperTestUtil.sampleEndpoints(2);
    setCuratorXNodeChildren(extraEndpoints, 3);

    // Construct the final expected node list.
    final Builder<Endpoint> builder = ImmutableSet.builder();
    builder.addAll(sampleEndpoints).addAll(extraEndpoints);
    try (CloseableZooKeeper zk = zkInstance.connection()) {
        zk.sync(Z_NODE, (rc, path, ctx) -> {}, null);
    }

    final Set<Endpoint> expected = builder.build();
    await().untilAsserted(() -> assertThat(endpointGroup.endpoints()).hasSameElementsAs(expected));
    disconnectZk(endpointGroup);
}
 

private void consumeOptionsAndKeys(ImapRequestLineReader requestReader, GetAnnotationRequest.Builder builder) throws DecodingException {
    while (requestReader.nextNonSpaceChar() == '(') {
        requestReader.consumeChar('(');
        switch (requestReader.nextChar()) {
            case 'M':
                consumeMaxsizeOpt(requestReader, builder);
                break;

            case 'D':
                consumeDepthOpt(requestReader, builder);
                break;

            default:
                consumeKeys(requestReader, builder);
                break;
        }
    }
}
 

/**
 * Return all supported options
 */
public static Set<String> getAllOptions() {
    Builder<String> options = ImmutableSet.<String>builder();
    options.add(
        SupportedOptions.TOKENS,
        SupportedOptions.OUT_REFMAP_FILE,
        SupportedOptions.DISABLE_TARGET_VALIDATOR,
        SupportedOptions.DISABLE_TARGET_EXPORT,
        SupportedOptions.DISABLE_OVERWRITE_CHECKER,
        SupportedOptions.OVERWRITE_ERROR_LEVEL,
        SupportedOptions.DEFAULT_OBFUSCATION_ENV,
        SupportedOptions.DEPENDENCY_TARGETS_FILE,
        SupportedOptions.MAPPING_TYPES,
        SupportedOptions.PLUGIN_VERSION
    );
    options.addAll(
        ObfuscationServices.getInstance().getSupportedOptions()
    );
    return options.build();
}
 

/**
 * Attempt to resolve a RIB route down to an interface route.
 *
 * @param rib {@link GenericRib} for which to do the resolution.
 * @param route {@link AbstractRoute} with a next hop IP to be resolved.
 * @return A map (interface name -> last hop IP -> last taken route) for
 * @throws BatfishException if resolution depth is exceeded (high likelihood of a routing loop) OR
 *     an invalid route in the RIB has been encountered.
 */
@VisibleForTesting
Set<FibEntry> resolveRoute(
    GenericRib<? extends AbstractRouteDecorator> rib, AbstractRoute route) {
  ResolutionTreeNode resolutionRoot = ResolutionTreeNode.root(route);
  buildResolutionTree(
      rib,
      route,
      Route.UNSET_ROUTE_NEXT_HOP_IP,
      new HashSet<>(),
      0,
      Prefix.MAX_PREFIX_LENGTH,
      null,
      resolutionRoot);
  Builder<FibEntry> collector = ImmutableSet.builder();
  collectEntries(resolutionRoot, new Stack<>(), collector);
  return collector.build();
}
 

private void collectEntries(
    ResolutionTreeNode node,
    Stack<AbstractRoute> stack,
    ImmutableCollection.Builder<FibEntry> entriesBuilder) {
  if (node.getChildren().isEmpty() && node.getFinalNextHopIp() != null) {
    String nextHopInterface = node.getRoute().getNextHopInterface();
    String nextVrf = getNextVrf(node.getRoute());
    FibAction fibAction =
        nextVrf != null
            ? new FibNextVrf(nextVrf)
            : nextHopInterface.equals(Interface.NULL_INTERFACE_NAME)
                ? FibNullRoute.INSTANCE
                : new FibForward(node.getFinalNextHopIp(), nextHopInterface);
    entriesBuilder.add(new FibEntry(fibAction, ImmutableList.copyOf(stack)));
    return;
  }
  stack.push(node.getRoute());
  for (ResolutionTreeNode child : node.getChildren()) {
    collectEntries(child, stack, entriesBuilder);
  }
  stack.pop();
}
 

private void convertLoopback() {
  Optional.ofNullable(_interfaces.get(LOOPBACK_INTERFACE_NAME))
      .ifPresent(iface -> populateLoInInterfacesToLoopback(iface, _loopback));

  org.batfish.datamodel.Interface newIface = createVIInterfaceForLo();

  if (!_loopback.getAddresses().isEmpty()) {
    newIface.setAddress(_loopback.getAddresses().get(0));
  }
  Builder<ConcreteInterfaceAddress> allAddresses = ImmutableSet.builder();
  allAddresses.addAll(_loopback.getAddresses());
  if (_loopback.getClagVxlanAnycastIp() != null) {
    // Just assume CLAG is correctly configured and comes up
    allAddresses.add(
        ConcreteInterfaceAddress.create(
            _loopback.getClagVxlanAnycastIp(), Prefix.MAX_PREFIX_LENGTH));
  }
  newIface.setAllAddresses(allAddresses.build());
  _c.getAllInterfaces().put(LOOPBACK_INTERFACE_NAME, newIface);
}
 

private org.batfish.datamodel.Interface toInterface(Vlan vlan) {
  org.batfish.datamodel.Interface newIface =
      org.batfish.datamodel.Interface.builder()
          .setName(vlan.getName())
          .setOwner(_c)
          .setType(InterfaceType.VLAN)
          .build();
  newIface.setActive(true);
  newIface.setVlan(vlan.getVlanId());

  // Interface addreses
  if (!vlan.getAddresses().isEmpty()) {
    newIface.setAddress(vlan.getAddresses().get(0));
  }
  ImmutableSet.Builder<InterfaceAddress> allAddresses = ImmutableSet.builder();
  allAddresses.addAll(vlan.getAddresses());
  vlan.getAddressVirtuals().values().forEach(allAddresses::addAll);
  newIface.setAllAddresses(allAddresses.build());
  newIface.setDescription(vlan.getAlias());

  return newIface;
}
 

/**
 * Gets properties of EVPN Layer 3 VNIs.
 *
 * @param nodes the set of nodes to consider
 * @param nc all network configurations
 * @param columns a map from column name to {@link ColumnMetadata}
 * @return A multiset of {@link Row}s where each row corresponds to a node and columns correspond
 *     to property values.
 */
@Nonnull
public static Set<Row> getRows(
    Set<String> nodes, NetworkConfigurations nc, Map<String, ColumnMetadata> columns) {
  Builder<Row> rows = ImmutableSet.builder();

  for (String nodeName : nodes) {
    nc.get(nodeName).map(Configuration::getVrfs).orElse(ImmutableMap.of()).values().stream()
        .map(Vrf::getBgpProcess)
        .filter(Objects::nonNull)
        .flatMap(BgpProcess::allPeerConfigsStream)
        .map(BgpPeerConfig::getEvpnAddressFamily)
        .filter(Objects::nonNull)
        .flatMap(af -> af.getL3VNIs().stream())
        .distinct() // Get rid of duplication across BGP peers (due to the VI model hierarchy)
        .map(c -> generateRow(c, nodeName, columns))
        .forEach(rows::add);
  }
  return rows.build();
}
 

private static void addVlanVnis(
    Configuration c,
    IntegerSpace vlans,
    Map<Integer, ImmutableSet.Builder<NodeInterfacePair>> switchedVlanInterfaces,
    ImmutableMap.Builder<Integer, Integer> vlanVnisBuilder) {
  c.getVrfs()
      .values()
      .forEach(
          vrf ->
              vrf.getLayer2Vnis()
                  .values()
                  .forEach(
                      vniSettings ->
                          tryAddVlanVni(
                              vniSettings, vlans, vlanVnisBuilder, switchedVlanInterfaces)));
}
 

@VisibleForTesting
static void computeNodeVlanProperties(
    SpecifierContext ctxt,
    Configuration c,
    InterfaceSpecifier interfacesSpecifier,
    boolean excludeShutInterfaces,
    IntegerSpace vlans,
    Map<Integer, ImmutableSet.Builder<NodeInterfacePair>> switchedVlanInterfaces,
    ImmutableMap.Builder<Integer, Integer> vlanVnisBuilder) {
  addVlanVnis(c, vlans, switchedVlanInterfaces, vlanVnisBuilder);
  Set<NodeInterfacePair> specifiedInterfaces =
      interfacesSpecifier.resolve(ImmutableSet.of(c.getHostname()), ctxt);
  for (Interface iface : c.getAllInterfaces().values()) {
    tryAddInterfaceToVlans(
        specifiedInterfaces, excludeShutInterfaces, vlans, switchedVlanInterfaces, iface);
  }
}
 

/**
 * Gets properties of switched vlans.
 *
 * @param ctxt context in which to apply {@code interfacesSpecifier}
 * @param configurations configuration to use in extractions
 * @param nodes the set of nodes to consider
 * @param interfaceSpecifier Specifies which interfaces to consider
 * @param columns a map from column name to {@link ColumnMetadata}
 * @return A multiset of {@link Row}s where each row corresponds to a node/vlan pair and columns
 *     correspond to property values.
 */
public static Multiset<Row> getProperties(
    SpecifierContext ctxt,
    Map<String, Configuration> configurations,
    Set<String> nodes,
    InterfaceSpecifier interfaceSpecifier,
    boolean excludeShutInterfaces,
    IntegerSpace vlans,
    Map<String, ColumnMetadata> columns) {
  Multiset<Row> rows = HashMultiset.create();
  for (String node : nodes) {
    Map<Integer, ImmutableSet.Builder<NodeInterfacePair>> switchedVlanInterfaces =
        new HashMap<>();
    ImmutableMap.Builder<Integer, Integer> vlanVnisBuilder = ImmutableMap.builder();
    computeNodeVlanProperties(
        ctxt,
        configurations.get(node),
        interfaceSpecifier,
        excludeShutInterfaces,
        vlans,
        switchedVlanInterfaces,
        vlanVnisBuilder);
    populateNodeRows(node, switchedVlanInterfaces, vlanVnisBuilder, columns, rows);
  }
  return rows;
}
 

@Override
public Set<QName> adaptArgumentValue(final StmtContext<Set<QName>, KeyStatement, KeyEffectiveStatement> ctx,
        final QNameModule targetModule) {
    final Builder<QName> builder = ImmutableSet.builder();
    boolean replaced = false;
    for (final QName qname : ctx.coerceStatementArgument()) {
        if (!targetModule.equals(qname.getModule())) {
            final QName newQname = qname.bindTo(targetModule).intern();
            builder.add(newQname);
            replaced = true;
        } else {
            builder.add(qname);
        }
    }

    // This makes sure we reuse the collection when a grouping is
    // instantiated in the same module
    return replaced ? builder.build() : ctx.getStatementArgument();
}
 

ImmutableNegotiationResult(final ImmutableVariant variant, ImmutableQuality quality, final ImmutableVariant errorVariant, ImmutableAlternatives alternatives) {
	checkArgument(
		(variant==null && quality==null) ||
		(variant!=null && quality!=null),
		"Variant and quality must be simultaneously defined or not (%s <--> %s)",variant,quality);
	checkNotNull(errorVariant,"Error variant cannot be null");
	checkNotNull(alternatives,"Alternatives cannot be null");
	this.variant=variant;
	this.quality=quality;
	this.errorVariant=errorVariant;
	this.alternatives=alternatives;
	Builder<MediaType> mtBuilder=ImmutableSet.<MediaType>builder();
	Builder<CharacterEncoding> ceBuilder=ImmutableSet.<CharacterEncoding>builder();
	Builder<Language> lBuilder=ImmutableSet.<Language>builder();
	for(Alternative alternative:alternatives) {
		addEntityIfPresent(mtBuilder,alternative.type());
		addEntityIfPresent(ceBuilder,alternative.charset());
		addEntityIfPresent(lBuilder,alternative.language());
	}
	this.mediaTypes=mtBuilder.build();
	this.characterEncodings=ceBuilder.build();
	this.languages=lBuilder.build();
}
 

ReflectiveDaoAdapter(Class<T> klass, ImmutableList<FieldAdapter> fieldAdapters, ImmutableList<EmbeddedFieldInitializer> fieldInitializers) {
  mClassFactory = ClassFactory.get(klass);
  mFieldAdapters = fieldAdapters;
  mFieldInitializers = fieldInitializers;

  ImmutableList.Builder<String> projectionBuilder = ImmutableList.builder();
  ImmutableList.Builder<String> writableColumnsBuilder = ImmutableList.builder();

  for (FieldAdapter fieldAdapter : fieldAdapters) {
    projectionBuilder.add(fieldAdapter.getColumnNames());
    writableColumnsBuilder.add(fieldAdapter.getWritableColumnNames());
  }
  mProjection = array(projectionBuilder.build());
  mWritableColumns = array(writableColumnsBuilder.build());
  mWritableDuplicates = findDuplicates(mWritableColumns);
}
 

/**
 * It returns a list of trace files that corresponds to builds while respecting the maximum size
 * of the final zip file.
 *
 * @param entries the highlighted builds
 * @return a set of paths that points to the corresponding traces.
 */
private ImmutableSet<Path> getTracePathsOfBuilds(ImmutableSet<BuildLogEntry> entries) {
  ImmutableSet.Builder<Path> tracePaths = new ImmutableSet.Builder<>();
  long reportSizeBytes = 0;
  for (BuildLogEntry entry : entries) {
    reportSizeBytes += entry.getSize();
    if (entry.getTraceFile().isPresent()) {
      try {
        Path traceFile = filesystem.getPathForRelativeExistingPath(entry.getTraceFile().get());
        long traceFileSizeBytes = Files.size(traceFile);
        if (doctorConfig.getReportMaxSizeBytes().isPresent()) {
          if (reportSizeBytes + traceFileSizeBytes < doctorConfig.getReportMaxSizeBytes().get()) {
            tracePaths.add(entry.getTraceFile().get());
            reportSizeBytes += traceFileSizeBytes;
          }
        } else {
          tracePaths.add(entry.getTraceFile().get());
          reportSizeBytes += traceFileSizeBytes;
        }
      } catch (IOException e) {
        LOG.info("Trace path %s wasn't valid, skipping it.", entry.getTraceFile().get());
      }
    }
  }
  return tracePaths.build();
}
 

private Set<String> getPermutationsConditions(ResourceContext context,
    List<String> permutationAxes) {
  Builder<String> setBuilder = ImmutableSet.builder();
  PropertyOracle oracle = context.getGeneratorContext().getPropertyOracle();

  for (String permutationAxis : permutationAxes) {
    String propValue = null;
    try {
      SelectionProperty selProp = oracle.getSelectionProperty(null,
          permutationAxis);
      propValue = selProp.getCurrentValue();
    } catch (BadPropertyValueException e) {
      try {
        ConfigurationProperty confProp = oracle.getConfigurationProperty(permutationAxis);
        propValue = confProp.getValues().get(0);
      } catch (BadPropertyValueException e1) {
        e1.printStackTrace();
      }
    }

    if (propValue != null) {
      setBuilder.add(permutationAxis + ":" + propValue);
    }
  }
  return setBuilder.build();
}
 

public Set<ComplexEntityPart> getParts() {
    Builder<ComplexEntityPart> builder = ImmutableSet.builder();

    for (MultiPartEntityPart part : getHandle().dragonPartArray) {
        builder.add((ComplexEntityPart) part.getBukkitEntity());
    }

    return builder.build();
}
 

/**
 * Returns a message on {@code snapshotSymbolProblems} that do not exist in {@code
 * baselineProblems}.
 */
@VisibleForTesting
static String messageForNewErrors(
    ImmutableSetMultimap<SymbolProblem, ClassFile> snapshotSymbolProblems,
    Set<SymbolProblem> baselineProblems,
    ClassPathResult classPathResult) {
  Set<SymbolProblem> newProblems =
      Sets.difference(snapshotSymbolProblems.keySet(), baselineProblems);
  StringBuilder message =
      new StringBuilder("Newly introduced problem" + (newProblems.size() > 1 ? "s" : "") + ":\n");
  Builder<ClassPathEntry> problematicJars = ImmutableSet.builder();
  for (SymbolProblem problem : newProblems) {
    message.append(problem + "\n");

    // This is null for ClassNotFound error.
    ClassFile containingClass = problem.getContainingClass();
    if (containingClass != null) {
      problematicJars.add(containingClass.getClassPathEntry());
    }

    for (ClassFile classFile : snapshotSymbolProblems.get(problem)) {
      message.append(
          String.format(
              "  referenced from %s (%s)\n",
              classFile.getBinaryName(), classFile.getClassPathEntry()));
      problematicJars.add(classFile.getClassPathEntry());
    }
  }

  message.append("\n");
  message.append(classPathResult.formatDependencyPaths(problematicJars.build()));

  return message.toString();
}
 

/**
 * Returns a copy of {@code bom} replacing its managed dependencies that have locally-installed
 * snapshot versions.
 */
@VisibleForTesting
static Bom copyWithSnapshot(
    RepositorySystem repositorySystem,
    RepositorySystemSession session,
    Bom bom,
    Map<String, String> localArtifacts)
    throws ModelBuildingException, ArtifactResolutionException {
  ImmutableList.Builder<Artifact> managedDependencies = ImmutableList.builder();

  Model model =
      buildModelWithSnapshotBom(repositorySystem, session, bom.getCoordinates(), localArtifacts);

  ArtifactTypeRegistry registry = session.getArtifactTypeRegistry();
  ImmutableList<Artifact> newManagedDependencies =
      model.getDependencyManagement().getDependencies().stream()
          .map(dependency -> RepositoryUtils.toDependency(dependency, registry))
          .map(Dependency::getArtifact)
          .collect(toImmutableList());
  for (Artifact managedDependency : newManagedDependencies) {
    if (Bom.shouldSkipBomMember(managedDependency)) {
      continue;
    }
    String version =
        localArtifacts.getOrDefault(
            managedDependency.getGroupId() + ":" + managedDependency.getArtifactId(),
            managedDependency.getVersion());
    managedDependencies.add(managedDependency.setVersion(version));
  }
  // "-SNAPSHOT" suffix for coordinate to distinguish easily.
  return new Bom(bom.getCoordinates() + "-SNAPSHOT", managedDependencies.build());
}
 

@Override
protected void processElement(AbstractElement element, AbstractRule rule, Builder<String> result) {
	if (element instanceof RuleCall) {
		AbstractRule calledRule = ((RuleCall) element).getRule();
		if (calledRule instanceof TerminalRule) {
			super.processElement(element, rule, result);
		} else {
			processElement(calledRule.getAlternatives(), rule, result);
		}
	} else {
		super.processElement(element, rule, result);
	}
}
 

static Set<String> toStringSet(ResultSet resultSet) throws SQLException {
  Builder<String> builder = ImmutableSet.builder();
  final List<Ord<String>> columns = columnLabels(resultSet);
  while (resultSet.next()) {
    StringBuilder buf = new StringBuilder();
    for (Ord<String> column : columns) {
      buf.append(column.i == 1 ? "" : "; ").append(column.e).append("=").append(resultSet.getObject(column.i));
    }
    builder.add(buf.toString());
    buf.setLength(0);
  }
  return builder.build();
}
 

public Set<ComplexEntityPart> getParts() {
    Builder<ComplexEntityPart> builder = ImmutableSet.builder();

    for (EntityDragonPart part : getHandle().dragonPartArray) {
        builder.add((ComplexEntityPart) part.getBukkitEntity());
    }

    return builder.build();
}
 

public SymbolProto(final Class clazz, final boolean hasSequence, final boolean hasArgs, final int kind,
		final boolean doesNotHaveScope, final FacetProto[] possibleFacets, final String omissible,
		final String[] contextKeywords, final int[] parentKinds, final boolean isRemoteContext,
		final boolean isUniqueInContext, final boolean nameUniqueInContext, final ISymbolConstructor constr,
		final IValidator validator, final SymbolSerializer serializer, final String name, final String plugin) {
	super(name, clazz, plugin);
	factory = DescriptionFactory.getFactory(kind);
	this.validator = validator;
	this.serializer = serializer;
	constructor = constr;
	this.isRemoteContext = isRemoteContext;
	this.hasSequence = hasSequence;
	this.isPrimitive = IKeyword.PRIMITIVE.equals(name);
	this.hasArgs = hasArgs;
	this.omissibleFacet = omissible;
	this.isUniqueInContext = isUniqueInContext;
	this.kind = kind;
	this.isVar = ISymbolKind.Variable.KINDS.contains(kind);
	this.hasScope = !doesNotHaveScope;
	if (possibleFacets != null) {
		final Builder<String> builder = ImmutableSet.builder();
		this.possibleFacets = GamaMapFactory.createUnordered();
		for (final FacetProto f : possibleFacets) {
			this.possibleFacets.put(f.name, f);
			f.setOwner(getTitle());
			if (!f.optional) {
				builder.add(f.name);
			}
		}
		mandatoryFacets = builder.build();
	} else {
		this.possibleFacets = null;
		mandatoryFacets = null;
	}
	this.contextKeywords = ImmutableSet.copyOf(contextKeywords);
	Arrays.fill(this.contextKinds, false);
	for (final int i : parentKinds) {
		contextKinds[i] = true;
	}
}
 

private ImapMessage buildAnnotationRequest(ImapRequestLineReader requestReader, Tag tag) throws DecodingException {
    GetAnnotationRequest.Builder builder = GetAnnotationRequest.builder().tag(tag);
    builder.mailboxName(requestReader.mailbox());

    consumeOptionsAndKeys(requestReader, builder);

    if (ENDOFLINE_PATTERN.matches(requestReader.nextNonSpaceChar())) {
        consumeKey(requestReader, builder);
    }

    return builder.build();
}
 

private void consumeDepthOpt(ImapRequestLineReader requestReader, GetAnnotationRequest.Builder builder) throws DecodingException {
    if (!requestReader.atom().equalsIgnoreCase(DEPTH)) {
        throw new DecodingException(HumanReadableText.ILLEGAL_ARGUMENTS, "Wrong on, it should be DEPTH");
    }

    builder.depth(Depth.fromString(requestReader.atom()));
    requestReader.consumeChar(')');
}
 

private void consumeMaxsizeOpt(ImapRequestLineReader requestReader, GetAnnotationRequest.Builder builder) throws DecodingException {
    if (!requestReader.atom().equalsIgnoreCase(MAXSIZE)) {
        throw new DecodingException(HumanReadableText.ILLEGAL_ARGUMENTS, "Wrong on, it should be MAXSIZE");
    }

    builder.maxsize(Optional.of((int)requestReader.number(STOP_ON_PAREN)));
    requestReader.consumeChar(')');
}