Append - Pushes the given object(s) on to the end of this
 Linked List. The expression returns the list itself, so several
 appends may be chained together. See also #pop for the opposite effect.
325183
def push *elements
      elements.each do |element|
        node = LLNode.new(element, nil, @last)
        @first = node if @first.nil?
        @last.next = node unless @last.nil?
        @last = node
        @size += 1
      end
      self
    end
910237
public HashCodeBuilder append(final Object object) {
        if (object == null) {
            iTotal = iTotal * iConstant;

        } else {
            if(object.getClass().isArray()) {
                // 'Switch' on type of array, to dispatch to the correct handler
                // This handles multi dimensional arrays
                if (object instanceof long[]) {
                    append((long[]) object);
                } else if (object instanceof int[]) {
                    append((int[]) object);
                } else if (object instanceof short[]) {
                    append((short[]) object);
                }
191845
function append(a,b)
{
	if (a.table.length === 0)
	{
		return b;
	}
	if (b.table.length === 0)
	{
		return a;
	}

	var c = append_(a, b);

	// Check if both nodes can be crunshed together.
	if (c[0].table.length + c[1].table.length <= M)
	{
		if (c[0].table.length === 0)
		{
			return c[1];
		}
		if (c[1].table.length === 0)
		{
			return c[0];
		}

		// Adjust .table and .lengths
		c[0].table = c[0].table.concat(c[1].table);
		if (c[0].height > 0)
		{
			var len = length(c[0]);
			for (var i = 0; i < c[1].lengths.length; i++)
			{
				c[1].lengths[i] += len;
			}
			c[0].lengths = c[0].lengths.concat(c[1].lengths);
		}

		return c[0];
	}

	if (c[0].height > 0)
	{
		var toRemove = calcToRemove(a, b);
		if (toRemove > E)
		{
			c = shuffle(c[0], c[1], toRemove);
		}
	}

	return siblise(c[0], c[1]);
}
1104990
public StrBuilder append(char[] src, int srcPos, int length) {
		return insert(this.position, src, srcPos, length);
	}
1294152
public void appendTo(Appendable app) throws IOException {
        appendPropTo(app, mPrime.getName(), isOuterJoin(0));
        StorableProperty<?>[] chain = mChain;
        if (chain != null) {
            for (int i=0; i<chain.length; i++) {
                app.append('.');
                appendPropTo(app, chain[i].getName(), isOuterJoin(i + 1));
            }
        }
    }
153277
def append_list_continuation(self, linenum, indent, continuation):
        
        frame = self.current_frame()
        assert isinstance(frame,FieldFrame) or isinstance(frame,ListContinuationFrame)
        if isinstance(frame, FieldFrame):
            assert frame.indent < indent and frame.container.contains(ROOT_PATH, frame.field_name)
        if isinstance(frame, ListContinuationFrame):
            assert frame.indent == indent and frame.container.contains(ROOT_PATH, frame.field_name)
            self.pop_frame()
        frame.container.append_field(ROOT_PATH, frame.field_name, continuation)
        frame = ListContinuationFrame(linenum, indent, frame.path, frame.container, frame.field_name, continuation)
        self.push_frame(frame)
1365900
def append_sibling_object(self, linenum, indent, path):
        
        frame = self.current_frame()
        assert frame.indent is not None and frame.indent == indent
        self.pop_frame()
        self.append_child_object(linenum, indent, path)
1251247
def append(self, point):
        
        point = Point(point)
        self._elements.append(point)
642378
private void appendParamValue(StringBuilder param, StringBuilder result) {
        if (param == null)
            throw UncheckedTemplateException.invalidArgumentName(param);

        // Object name is the parameter that should be found in the map.
        // If it's followed by points, the points remain in the "param" buffer.
        final String objectName  = takeUntilDotOrEnd(param);
        final Object objectValue = arguments.get(objectName);

        Object toAppend;
        if (param.length() != 0) {
            // If this is a chain object.method1.method2.method3
            // we recurse
            toAppend = valueInChain(objectValue, param);
        } else {
            // We evaluate if the obejct is an array
            // If it's an array we print it nicely
            toAppend = evaluateIfArray(objectValue);
        }
        if (null != toAppend) {
            result.append(toAppend);
        }

    }
181797
def append(self, value):
        
        nodes = parse_anything(value).nodes
        for node in nodes:
            self.nodes.append(node)
186617
public static void appendCall(StringBuilder sb, String begin, String separator,
      String end, List<? extends CharSequence> args) {
    int size = begin.length();
    // Typically just-in-time compiler would eliminate Iterator in case foreach is used,
    // however the code below uses indexed iteration to keep the conde independent from
    // various JIT implementations (== avoid Iterator allocations even for not-so-smart JITs)
    // see https://bugs.openjdk.java.net/browse/JDK-8166840
    // see http://2016.jpoint.ru/talks/cheremin/ (video and slides)
    int numberOfArguments = args.size();
    for (int i = 0; i < numberOfArguments; i++) {
      size += args.get(i).length();
    }
    size += separator.length() * (numberOfArguments - 1);
    sb.ensureCapacity(sb.length() + size + 1);
    sb.append(begin);
    for (int i = 0; i < numberOfArguments; i++) {
      if (i > 0) {
        sb.append(separator);
      }
      sb.append(args.get(i));
    }
    sb.append(end);
  }
1360470
public final <A extends Appendable> A appendTo(A appendable, Object[] parts) throws IOException {
    return appendTo(appendable, Arrays.asList(parts));
  }
313141
def Append(self, x, p):
        
        self.xs.append(x)
        self.ps.append(p)
430531
Append append(String format, Object... args) {
    return append(String.format(format, args));
  }
301297
def __append_list(append_to, value):
    """"""
    if value is not None:
        if isinstance(value, list):
            append_to.extend(value)
        else:
            append_to.append(value)
1175498
protected static boolean appendParams(StringBuilder SB, Object optParam, List<String> finishedParams, boolean alreadyAppended) {
		if (optParam != null) {
			if (optParam instanceof String) {
				List<String> nameValuePairs=StringUtility.splitString((String)optParam, '&');
				int len=nameValuePairs.size();
				for(int i=0;i<len;i++) {
					SB.append(alreadyAppended?'&':'?');
					String S=nameValuePairs.get(i);
					int pos=S.indexOf('=');
					if(pos==-1) {
						SB.append(S);
						alreadyAppended=true;
					} else {
						String name=S.substring(0, pos);
						if(!finishedParams.contains(name)) {
							SB.append(S);
							finishedParams.add(name);
							alreadyAppended=true;
						}
					}
				}
			} else if (optParam instanceof String[]) {
				String[] SA = (String[]) optParam;
				int len = SA.length;
				for (int c = 0; c < len; c += 2) {
					String name=SA[c];
					if(!finishedParams.contains(name)) {
						SB.append(alreadyAppended?'&':'?').append(name).append('=').append(SA[c + 1]);
						finishedParams.add(name);
						alreadyAppended=true;
					}
				}
			} else throw new IllegalArgumentException("Unsupported type for optParam: " + optParam.getClass().getName());
		}
		return alreadyAppended;
	}
1369271
def append(self, list_name, value):
        """"""
        with self.lock:
            l = self.lists.get(list_name)
            if l:
                l.append(value)
            else:
                l = [value]
            self.lists[list_name] = l