Convenience factory method to create a Bridge object from two Call objects
@param call1 the call id
@param call2 the call id
@return the Bridge
@throws IOException unexpected error.
549208
public static Bridge create(final Call call1, final Call call2)
    	    throws Exception {
        assert (call1 != null);
    	final String callId1 = call1.getId();
    	final String callId2 = call2.getId();
    	return Bridge.create(callId1, callId2);
    }
931101
def _pycall_path_simple(
    x1: int, y1: int, x2: int, y2: int, handle: Any
) -> float:
    """"""
    return ffi.from_handle(handle)(x1, y1, x2, y2)
440348
public static <T1, T2> TypeFactory<Tuple2<T1, T2>> typeFactory( TypeFactory<T1> type1,
                                                                    TypeFactory<T2> type2 ) {
        return new Tuple2TypeFactory<>(type1, type2);
    }
837371
@SuppressWarnings("rawtypes")
    private static Object createIntermediate(JsonNode node, StringBuffer pathSofar, String index,
            String nextIndex) {
        if (node instanceof POJONode) {
            return createIntermediate(extractValue((POJONode) node), pathSofar, index, nextIndex);
        }
        if (node instanceof ContainerNode) {
            ContainerNode temp = (ContainerNode) node;
            JsonNode value = PATTERN_INDEX.matcher(nextIndex).matches() ? temp.arrayNode()
                    : temp.objectNode();
            return createIntermediate(temp, pathSofar, index, value);
        }
        return null;
    }
1113522
protected List<Reference> mergeReferences(
			List<? extends Reference> references1,
			List<? extends Reference> references2) {
		List<Reference> result = new ArrayList<>();
		for (Reference reference : references1) {
			addBestReferenceToList(reference, result);
		}
		for (Reference reference : references2) {
			addBestReferenceToList(reference, result);
		}
		return result;
	}
1337205
public static Object[] call(Method method, Object[][] params,
                              InetSocketAddress[] addrs, Configuration conf)
    throws IOException {
    return call(method, params, addrs, null, conf);
  }
1371228
@SuppressWarnings("unchecked")
  private Object union(Linker linker, Object a, Object b) {
    if (a instanceof List) {
      return union((List<?>) a, (List<?>) b);
    } else if (a instanceof Map) {
      return union(linker, (Map<ProtoMember, Object>) a, (Map<ProtoMember, Object>) b);
    } else {
      linker.addError("conflicting options: %s, %s", a, b);
      return a; // Just return any placeholder.
    }
  }
569162
public VirtualConnection createConnection() throws ChannelException, ChainException {
        OutboundVirtualConnectionImpl vc = new OutboundVirtualConnectionImpl();
        if (getChain().getState() != RuntimeState.STARTED) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Starting outbound chain, " + getName());
            }
            this.cf.startChainInternal(getChain().getChainData());
            // Reset the reference to the new outboundChain.
            this.outboundChain = this.cf.getRunningChain(getName());
            // Handle issues where the refCount may have gone negative due
            // to too many VCF.destroy calls from the same VCF.
            if (getRefCount() <= 0) {
                this.refCount = 1;
            }
        }
        ConnectionLink[] links = new ConnectionLink[chans.length];
        links[0] = chans[0].getConnectionLink(vc);
        for (int i = 1; i < chans.length; i++) {
            try {
                links[i] = chans[i].getConnectionLink(vc);
            } catch (Exception e) {
                FFDCFilter.processException(e, getClass().getName() + ".createConnection", "125", new Object[] { this, chans[i] });
                // Channel implementation had an error.
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Error getting conn link from " + chans[i].getName() + ", " + e.getMessage());
                }
                throw new ChannelException(e.getMessage());
            }
            links[i - 1].setDeviceLink(links[i]);
            links[i].setApplicationCallback(links[i - 1]);
        }
        // do the single cast here instead of many times later
        vc.setConnectionLink((OutboundConnectionLink) links[0]);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Putting name of chain into vc statemap: " + getName());
        }
        // Set the name of the chain into the statemap of the vc.
        // (Currently used on Z in XMEM channel)
        vc.getStateMap().put("ChainName", getName());

        return vc;
    }
1194109
public E union(E e1, E e2) {
	Node<E> node1 = _get_or_create_root_set(e1);
	Node<E> node2 = _get_or_create_root_set(e2);
	return _link(node1, node2).element;
    }
898741
public static <ReqT, RespT> Iterator<RespT> blockingServerStreamingCall(
      ClientCall<ReqT, RespT> call, ReqT req) {
    BlockingResponseStream<RespT> result = new BlockingResponseStream<>(call);
    asyncUnaryRequestCall(call, req, result.listener(), true);
    return result;
  }
145570
public void commit() throws IOException, AppPlatformException {
        final Map<String, Object> params = new HashMap<String, Object>();

        params.put("bridgeAudio", isBridgeAudio());
        final String[] callIds = getCallIds();
        params.put("callIds", callIds == null ? Collections.emptyList() : Arrays.asList(callIds));

        client.post(getUri(), params);
    }
478055
public static <First extends Serializable, Second extends Serializable>
      SerializablePair<First, Second> fromSerializables(
          final First first, final Second second) {
    return new ImmutableSerializablePair<First, Second>(first, second);
  }
329990
public FloatPoint Add(FloatPoint point1, FloatPoint point2) {
        FloatPoint result = new FloatPoint(point1);
        result.Add(point2);
        return result;
    }
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;
	}
1030529
public static <T> Collection<T> union(Collection<T> coll1, Collection<T> coll2) {
		final ArrayList<T> list = new ArrayList<>();
		if (isEmpty(coll1)) {
			list.addAll(coll2);
		} else if (isEmpty(coll2)) {
			list.addAll(coll1);
		} else {
			final Map<T, Integer> map1 = countMap(coll1);
			final Map<T, Integer> map2 = countMap(coll2);
			final Set<T> elts = newHashSet(coll2);
			elts.addAll(coll1);
			int m;
			for (T t : elts) {
				m = Math.max(Convert.toInt(map1.get(t), 0), Convert.toInt(map2.get(t), 0));
				for (int i = 0; i < m; i++) {
					list.add(t);
				}
			}
		}
		return list;
	}
890744
public void join(SelectableChannel ch1, SelectableChannel ch2) throws IOException
    {
        join(ch1, ch2, (ByteChannel)ch1, (ByteChannel)ch2);
    }
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())));
	}