const std::string& str() const { return *value_; }

  /** Absl hash function. */
  template <typename H>
  friend H AbslHashValue(H h, const String& s) {
    return H::combine(std::move(h), *s.value_);
  }

 private:
  //! The interned string value. This is never null.
  const std::string* value_;
};

// This is defined in the `iostream.cc` file in this directory. It is not

		err     error
	}{
		{
			desc: "overlay-yaml",
			base: `foo: bar
yo: lo
`,
			overlay: `yo: go`,
			expect: `foo: bar
yo: go
`,
			err: nil,
		},
		{
			desc:    "combine-yaml",
			base:    `foo: bar`,
			overlay: `baz: razmatazz`,
			expect: `baz: razmatazz
foo: bar
`,
			err: nil,
		},
		{
			desc:    "blank",
			base:    `R#)*J#FN`,

     * @return the list of indy modes
     */
    def indyModes() {
        return [true, false]
    }

    final def testCasesWithIndyModes() {
        // Combine each test case with enableIndy=true and/or enableIndy=false
        return [testCases(), indyModes()].combinations().collect { it.flatten() }
    }

  <version>1.0</version>
  <packaging>pom</packaging>

  <name>Maven Integration Test :: MNG-2591</name>
  <description>
    Test aggregation of list configuration items for build plugins when using
    'combine.children=append' attribute.
  </description>

  <modules>
    <module>subproject</module>
  </modules>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>

      super.orderEntriesByValue(valueComparator);
      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> other) {
      super.combine(other);
      return this;
    }

    @Override
    public ImmutableBiMap<K, V> build() {
      return buildOrThrow();
    }

    @Override

    private ExternalResourceName(@Nullable String encodedRoot, String path) {
        this(encodedRoot, path, "");
    }

    public ExternalResourceName(URI parent, String path) {
        this(encodeRoot(parent), combine(parent, path), "");
    }

    private ExternalResourceName(@Nullable String encodedRoot, String path, String encodedQuery) {
        this.encodedRoot = encodedRoot;
        this.path = path;

@RequiresInstalledToolChain(ToolChainRequirement.SWIFTC)
class SwiftDependenciesIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {
    def app = new SwiftAppWithLibraries()

    def "can combine swift builds in a composite"() {
        given:
        createDirs("app", "hello", "log")
        settingsFile << """
            include 'app'
            includeBuild 'hello'
            includeBuild 'log'

  val survey = CipherSuiteSurvey(clients = clients, ianaSuites = ianaSuitesNew, orderBy = orderBy)

  survey.printGoogleSheet()
}

fun rest(clients: List<Client>): List<SuiteId> {
  // combine all ciphers to get these near the top
  return clients.flatMap { it.enabled }

//
inline internal::ParamGenerator<bool> Bool() {
  return Values(false, true);
}

# if GTEST_HAS_COMBINE
// Combine() allows the user to combine two or more sequences to produce
// values of a Cartesian product of those sequences' elements.
//
// Synopsis:
// Combine(gen1, gen2, ..., genN)
//   - returns a generator producing sequences with elements coming from

            }
        }

        return dr;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.dfs.DfsReferralDataInternal#combine(jcifs.DfsReferralData)
     */
    @Override
    public DfsReferralDataInternal combine ( DfsReferralData n ) {
        DfsReferralDataImpl dr = new DfsReferralDataImpl();
        dr.server = n.getServer();
        dr.share = n.getShare();