// next and stop.
//
// Next returns the next pair in the sequence
// and a boolean indicating whether the pair is valid.
// When the sequence is over, next returns a pair of zero values and false.
// It is valid to call next after reaching the end of the sequence
// or after calling stop. These calls will continue
// to return a pair of zero values and false.
//

     * of mutually exclusive options to the {@link TaskOptions#mutuallyExclusiveOptions taskOptions} argument.
     */
    private static Map<String, OptionDescriptor> generateOppositeOptions(Object target, Map<String, OptionDescriptor> options, TaskOptions taskOptions) {
        Map<String, OptionDescriptor> oppositeOptions = new HashMap<>();

}

//////////////////////////////// Pairs ////////////////////////////////
//
// API Priority and Fairness tends to use RatioedGaugeVec members in pairs,
// one for requests waiting in a queue and one for requests being executed.
// The following definitions are a convenience layer that adds support for that
// particular pattern of usage.

// RatioedGaugePair is a corresponding pair of gauges, one for the

// are problematic.  This analysis returns the set of pairs of resource
// operations that cannot be put in the same cluster because XLA cannot respect
// the dependencies between them in the TensorFlow program.
//
// The restrictions are not transitive: it is fine to put A and C in the same
// cluster even if the returned set contains (A,B) and (B,C).
//
// In other words, if these pairs are seen as edges in an undirected graph of

}

// NewValidationIgnorer initializes the ignorer for the validatior, pairs are in namespace/namePattern format.
func NewValidationIgnorer(pairs ...string) *ValidationIgnorer {
	vi := &ValidationIgnorer{
		patternsByNamespace: make(map[string]sets.String),
	}
	for _, pair := range pairs {
		parts := strings.SplitN(pair, "/", 2)
		if len(parts) != 2 {
			continue
		}
		vi.Add(parts[0], parts[1])
	}

	ignoreResources string
	// renameResources identifies renamed resources before comparison.
	// The format of each renaming pair is A->B, all renaming pairs are comma separated.
	// e.g. Service:*:istio-pilot->Service:*:istio-control - rename istio-pilot service into istio-control
	renameResources string
}

     * soon be deprecated.
     *
     * @throws IllegalArgumentException if duplicate key pairs were added
     */
    public ImmutableTable<R, C, V> build() {
      return buildOrThrow();
    }

    /**
     * Returns a newly-created immutable table, or throws an exception if duplicate key pairs were
     * added.
     *

     * soon be deprecated.
     *
     * @throws IllegalArgumentException if duplicate key pairs were added
     */
    public ImmutableTable<R, C, V> build() {
      return buildOrThrow();
    }

    /**
     * Returns a newly-created immutable table, or throws an exception if duplicate key pairs were
     * added.
     *

 * because of the possibility of splitting a surrogate pair. The only case in which it is safe to
 * escape strings and concatenate the results is if you can rule out this possibility, either by
 * splitting an existing long string into short strings adaptively around {@linkplain
 * Character#isHighSurrogate surrogate} {@linkplain Character#isLowSurrogate pairs}, or by starting

            projectSchema.extension("generic").type,
            equalTo(accessible(genericType))
        )
    }

    private
    fun schemaWithExtensions(vararg pairs: Pair<String, SchemaType>) = projectSchemaWith(
        extensions = pairs.map { ProjectSchemaEntry(SchemaType.of<Project>(), it.first, it.second) }
    )

    private
    fun <T> ProjectSchema<T>.extension(name: String) =