Concatenates the method.
187181
public void concatenate(JavaMethod tail)
  {
    CodeAttribute codeAttr = getCode();
    CodeAttribute tailCodeAttr = tail.getCode();

    byte []code = codeAttr.getCode();
    byte []tailCode = tailCodeAttr.getCode();

    int codeLength = code.length;

    if ((code[codeLength - 1] & 0xff) == CodeVisitor.RETURN)
      codeLength = codeLength - 1;

    byte []newCode = new byte[codeLength + tailCode.length];
    System.arraycopy(code, 0, newCode, 0, codeLength);
    System.arraycopy(tailCode, 0, newCode, codeLength, tailCode.length);

    codeAttr.setCode(newCode);

    if (codeAttr.getMaxStack() < tailCodeAttr.getMaxStack())
      codeAttr.setMaxStack(tailCodeAttr.getMaxStack());

    if (codeAttr.getMaxLocals() < tailCodeAttr.getMaxLocals())
      codeAttr.setMaxLocals(tailCodeAttr.getMaxLocals());

    ArrayList<CodeAttribute.ExceptionItem> exns = tailCodeAttr.getExceptions();
    for (int i = 0; i < exns.size();  i++) {
      CodeAttribute.ExceptionItem exn = exns.get(i);

      CodeAttribute.ExceptionItem newExn = new CodeAttribute.ExceptionItem();

      newExn.setType(exn.getType());
      newExn.setStart(exn.getStart() + codeLength);
      newExn.setEnd(exn.getEnd() + codeLength);
      newExn.setHandler(exn.getHandler() + codeLength);
    }
  }
606692
private static byte[] concat(byte[] a, byte[] b)
    {
        byte[] c = new byte[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);

        return c;
    }
452047
public static <T> Iterator<T> concat(final Iterator<? extends T>... iterators) {
        return new ImmutableIterator<T>() {
            int current = 0;

            @Override
            public boolean hasNext() {
                advance();
                return current < iterators.length;
            }

            @Override
            public T next() {
                advance();
                try {
                    return iterators[current].next();
                } catch (ArrayIndexOutOfBoundsException e) {
                    throw new NoSuchElementException();
                }
            }

            private void advance() {
                while (current < iterators.length && !iterators[current].hasNext()) {
                    current++;
                }
            }
        };
    }
596060
public final <T2> Tuple2<T1, T2> concat(Tuple1<T2> tuple) {
        return new Tuple2<>(v1, tuple.v1);
    }
756165
private static String concat(final String... parts) {

		final StringBuilder buf = new StringBuilder();

		for (final String part : parts) {

			// handle nulls gracefully (ignore)
			if (part != null) {

				buf.append(part);
			}
		}

		return buf.toString();
	}
191344
public static <T> LazyIterable<T> concatenate(Iterable<T>... iterables)
    {
        return CompositeIterable.with(iterables);
    }
191236
function( object, method ) {
		var args = Array.prototype.slice.call(arguments, 2);
		return function() {
			var args2 = [this].concat(args, $.makeArray(arguments));
			return method.apply(object, args2);
		};
	}
469619
function _concat(buffOne, buffTwo) {
  if (!buffOne) return buffTwo;
  if (!buffTwo) return buffOne;

  let newLength = buffOne.length + buffTwo.length;
  return Buffer.concat([buffOne, buffTwo], newLength);
}
591568
private static StringConcatenationClient toStringConcatenation(final String... javaCodeLines) {
		return new StringConcatenationClient() {
			@Override
			protected void appendTo(StringConcatenationClient.TargetStringConcatenation builder) {
				for (final String line : javaCodeLines) {
					builder.append(line);
					builder.newLineIfNotEmpty();
				}
			}
		};
	}
877161
public static String concat(final Object... osToString) {
        final StringBuilder b = new StringBuilder();
        if (osToString != null) {
            for (final Object o : osToString) {
                b.append(o != null ? o.toString() : "null");
            }
        }
        return b.toString();
    }
1117444
def concat(self, operand, start=0, end=0, offset=0):
        """"""
        if not Gauged.map_concat(self.ptr, operand.ptr, start, end, offset):
            raise MemoryError
1004009
private String combine(String org, String add) {
		if (null == org) {
			return add;
		}
		if (null == add || org.equals(add) || org.startsWith(add + ", ") || org.endsWith(", " + add)) {
			return org;
		}
		return org + ", " + add;
	}
510646
protected String concat(String first, String second) {
        return first == null ? second : String.format("%s.%s", first, second);
    }
1027407
public static String concatenate(EvaluationContext ctx, Object... args) {
        StringBuilder sb = new StringBuilder();
        for (Object arg : args) {
            sb.append(Conversions.toString(arg, ctx));
        }
        return sb.toString();
    }
200665
def p_concat(self, p):
        ''
        p[0] = Concat(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1156018
private function concatenateObjects()
    {
        $output = "";

        if (empty($this->objectList)) return $output;

        foreach ($this->objectList as $object) {
            if ($object->isValid()) {
                $output .= $object->getData();

                $modifiedTime = $object->getLastModifiedTimestamp();

                if (!empty($modifiedTime) && $modifiedTime > $this->lastModifiedTime) {
                    $this->lastModifiedTime = $modifiedTime;
                }
            } else {
                $output .= $this->handleInvalidFile($object->getValue());
            }
        }

        if (!empty($this->lastModifiedTime)) {
            $output = $this->formatLastModifiedTime() . $output;
        }

        return $output;
    }
204083
private String combine(String parent, String child) {
    if (parent.length() > 0) {
      return parent.concat(".").concat(child);
    } else {
      return child;
    }
  }