result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> isAttribute(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

  }

  @CollectionFeature.Require(SERIALIZABLE)
  public void testInverseSerialization() {
    BiMapPair<K, V> pair = new BiMapPair<>(getMap());
    BiMapPair<K, V> copy = SerializableTester.reserialize(pair);
    assertEquals(pair.forward, copy.forward);
    assertEquals(pair.backward, copy.backward);
    assertSame(copy.backward, copy.forward.inverse());
    assertSame(copy.forward, copy.backward.inverse());
  }

// license that can be found in the LICENSE file.

package p4

type Pair[T1 interface{ M() }, T2 ~int] struct {
	f1 T1
	f2 T2
}

func NewPair[T1 interface{ M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] {
	return Pair[T1, T2]{f1: v1, f2: v2}
}

func (p Pair[X1, _]) First() X1 {
	return p.f1
}

func (p Pair[_, X2]) Second() X2 {
	return p.f2
}

// Deprecated: Use something else.

        assertEquals(1, pairs.size(), "Should have decoded one pair");

        AvPair pair = pairs.get(0);
        assertEquals(AvPair.MsvAvFlags, pair.getType(), "Pair type should be MsvAvFlags");
        assertTrue(pair instanceof AvFlags, "Should be decoded as AvFlags");
        assertEquals(0x12345678, ((AvFlags) pair).getFlags(), "Flags value should match");
    }

    /**

    // you can adjust your actions by overriding
    // default methods defined at the interface
    // _/_/_/_/_/_/_/_/_/_/

    protected Map<String, List<Pair<String, String>>> responseHeaderMap = new HashMap<>();

    protected List<Pair<String, String>> defaultResponseHeaders;

    public FessActionAdjustmentProvider(final FessConfig fessConfig) {
        parseResponseHeaderConfig(fessConfig.getResponseHeaders());
    }

         * @param field the field name to split
         * @return a Pair containing the field name and extension key
         */
        protected Pair<String, String> splitField(final String defaultField, final String field) {
            final int indexOf = field.indexOf(':');
            if (indexOf < 0) {
                return new Pair<>(field, null);
            }

            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> !"name".equals(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }
                    } else if (e.getValue() instanceof List) {
                        final List<String> values = (List<String>) e.getValue();
                        for (final String v : values) {
                            result.getSearchFieldLogList().add(new Pair<>(e.getKey(), v));
                        }

pkg p4, func Clone //deprecated
pkg p4, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0
pkg p4, func NewPair[$0 interface{ M }, $1 interface{ ~int }]($0, $1) Pair[$0, $1]
pkg p4, method (Pair[$0, $1]) First() $0
pkg p4, method (Pair[$0, $1]) Second() $1

import java.util.Objects;
import org.jspecify.annotations.Nullable;

/**
 * An immutable pair representing the two endpoints of an edge in a graph. The {@link EndpointPair}
 * of a directed edge is an ordered pair of nodes ({@link #source()} and {@link #target()}). The
 * {@link EndpointPair} of an undirected edge is an unordered pair of nodes ({@link #nodeU()} and
 * {@link #nodeV()}).
 *