Convert this {@code Tuple} instance into a Map with one key,value pair. Where
{@code key} is {@code _1} and {@code value} is {@code _2};

@return the Map as described
546132
@SuppressWarnings("unused")
        public Map<A, B> toMap() {
            Map<A, B> m = new HashMap<A, B>();
            m.put(_1, _2);
            return m;
        }
360730
@SuppressWarnings("ConstantConditions")
  ImmutableSetMultimap<K,V> toImmutableSetMultimap() {
    final ImmutableSetMultimap.Builder<K, V>  ret = ImmutableSetMultimap.builder();

    for (final MultimapEntry<K, V> entry : entries) {
      ret.putAll(entry.key, entry.values);
    }

    return ret.build();
  }
596060
public final <T2> Tuple2<T1, T2> concat(Tuple1<T2> tuple) {
        return new Tuple2<>(v1, tuple.v1);
    }
1123471
public static Point2d convert(Tuple2D<?> tuple) {
		if (tuple instanceof Point2d) {
			return (Point2d) tuple;
		}
		return new Point2d(tuple.getX(), tuple.getY());
	}
430496
static <K, V> Map<K, V> keyValuesToMap(Iterator<KeyValue<K, V>> keyValues) {
        Map<K, V> map = new HashMap<>();
        keyValues.forEachRemaining(pair -> map.put(pair.getKey(), pair.getValue()));
        return map;
    }
547705
public final Tuple2<Tuple1<T1>, Tuple5<T2, T3, T4, T5, T6>> split1() {
        return new Tuple2<>(limit1(), skip1());
    }
904632
public final Tuple2<Tuple2<T1, T2>, Tuple1<T3>> split2() {
        return new Tuple2<>(limit2(), skip2());
    }
499043
public Set<Map.Entry<A,B>> entrySet() {
	return new AbstractSet<Map.Entry<A,B>>() {
	    public int size() {
		return map.size();
	    }
	    public Iterator<Map.Entry<A,B>> iterator() {
		return new Iterator<Map.Entry<A,B>>() {
		    private final Iterator<Map.Entry<A,B>> it = map.entrySet().iterator();
		    private Map.Entry<A,B> last = null;
		    public boolean hasNext() {
			return it.hasNext(); 
		    }
		    public Map.Entry<A,B> next() { 
		        last = it.next();
			return last;
		    }
		    public void remove() {
			it.remove();
			revMap.remove(last.getValue());
		    }
		};
	    }
	    public boolean remove(Object o) {
		if(!(o instanceof Map.Entry/*<A,B>*/)) return false;
		@SuppressWarnings("unchecked")
		Map.Entry<A,B> entry = (Map.Entry<A,B>) o;
		B currValue = BijMap.this.get(entry.getKey());
		if((currValue == null) || !currValue.equals(entry.getValue())) return false;
		BijMap.this.remove(entry.getKey());
		return true;
	    }
	    public void clear() {
		BijMap.this.clear();
	    }
	};
    }
27783
public static <K, V> Reducer<PersistentMap<K, V>,Tuple2<K,V>> toPersistentMap() {
        return Reducer.of(HashMap.empty(), (final PersistentMap<K, V> a) -> b -> a.putAll(b), (in) -> {
            Tuple2<K, V> w = in;
            return HashMap.of((K) w._1(), (V) w._2());

        }
1214311
public <T0, T1> SingleOutputStreamOperator<Tuple2<T0, T1>> projectTuple2() {
		TypeInformation<?>[] fTypes = extractFieldTypes(fieldIndexes, dataStream.getType());
		TupleTypeInfo<Tuple2<T0, T1>> tType = new TupleTypeInfo<Tuple2<T0, T1>>(fTypes);

		return dataStream.transform("Projection", tType, new StreamProject<IN, Tuple2<T0, T1>>(fieldIndexes, tType.createSerializer(dataStream.getExecutionConfig())));
	}
281137
public final <U2> Tuple2<T1, U2> map2(Function<? super T2, ? extends U2> function) {
        return Tuple.tuple(v1, function.apply(v2));
    }
827355
public <T> Tuple2<String, T> nextKeyValue(Class<T> clazz) throws IOException {
      if (currentValue.getKey() != NAME) {
         throw new IOException("Expecting NAME, but found " + jsonTokenToStructuredElement(null));
      }
      String name = currentValue.getValue().asString();
      consume();
      return Tuple2.of(name, nextValue(clazz));
   }
712031
public static <K, V> PairedMapValues<V> zipValues(final Map<K, V> left, final Map<K, V> right) {
    checkNotNull(left);
    checkNotNull(right);
    final ImmutableList.Builder<ZipPair<V, V>> pairedValues =
        ImmutableList.builder();
    final ImmutableList.Builder<V> leftOnly = ImmutableList.builder();
    final ImmutableList.Builder<V> rightOnly = ImmutableList.builder();

    for (final Map.Entry<K, V> leftEntry : left.entrySet()) {
      final K key = leftEntry.getKey();
      if (right.containsKey(key)) {
        pairedValues.add(ZipPair.from(leftEntry.getValue(), right.get(key)));
      } else {
        leftOnly.add(leftEntry.getValue());
      }
    }

    for (final Map.Entry<K, V> rightEntry : right.entrySet()) {
      if (!left.containsKey(rightEntry.getKey())) {
        rightOnly.add(rightEntry.getValue());
      }
    }

    return new PairedMapValues<V>(pairedValues.build(), leftOnly.build(),
        rightOnly.build());
  }
1364881
public final <T1, T2> Tuple2<T1, T2> concat(Tuple2<T1, T2> tuple) {
        return new Tuple2<>(tuple.v1, tuple.v2);
    }
1143909
public ValueMap getValueMap(Object key) {
    Object value = get(key);
    if (value instanceof ValueMap) {
      return (ValueMap) value;
    } else if (value instanceof Map) {
      //noinspection unchecked
      return new ValueMap((Map<String, Object>) value);
    } else {
      return null;
    }
  }
1279921
@SuppressWarnings("unchecked")
  public static <K, V> MultiValueMap<K, V> unmodifiableMultiValueMap(
      final MultiValueMap<? extends K, ? extends V> map) {
    Assert.notNull(map, "'map' must not be null");
    final Map<K, List<V>> result = new LinkedHashMap<>(map.size());
    map.forEach((key, value) -> {
      final List<? extends V> values = Collections.unmodifiableList(value);
      result.put(key, (List<V>) values);
    });
    final Map<K, List<V>> unmodifiableMap = Collections.unmodifiableMap(result);
    return CollectionUtils.toMultiValueMap(unmodifiableMap);
  }
62017
private MultiValueMap<String, String> union(MultiValueMap<String, String> map1, MultiValueMap<String, String> map2) {
		MultiValueMap<String, String> union = new LinkedMultiValueMap<String, String>(map1);
		Set<Entry<String, List<String>>> map2Entries = map2.entrySet();
		for (Iterator<Entry<String, List<String>>> entryIt = map2Entries.iterator(); entryIt.hasNext();) {
			Entry<String, List<String>> entry = entryIt.next();
			String key = entry.getKey();
			List<String> values = entry.getValue();
			for (String value : values) {
				union.add(key, value);
			}
		}
		return union;
	}