/*-------------------------------------------------[ Add ]---------------------------------------------------
494533
public void add(AsciiString name, String value){
        if(name==null || value==null)
            return;
        Header head = entry(name, true);
        if(head.value==null)
            head.value = value;
        else{
            Header newHeader = newHeader(name);
            newHeader.value = value;
            Header tail = head.samePrev;
            tail.sameNext = newHeader;
            newHeader.samePrev = tail;
            head.samePrev = newHeader;
        }
        assert validateLinks();
    }
486985
void add(final Argument argument) {
        if (argument != null) {
            if (argument.multipleValuesAllowed()) {
                Collection<Argument> arguments = map.get(argument.getKey());
                if (arguments == null) {
                    arguments = new ArrayList<>();
                    map.put(argument.getKey(), arguments);
                }
                arguments.add(argument);
            } else {
                set(argument);
            }
        }
    }
1009764
public void add(Object... aChunk) {
        List<Object> list;
        if (aChunk.length == 1 && aChunk[0] instanceof List) {
            @SuppressWarnings("unchecked")
            List<Object> l = (List<Object>) aChunk[0];
            list = l;
        } else {
            list = Arrays.asList(aChunk);
        }
        list.forEach(chunk -> {
            if (chunk instanceof String) {
                this.add((String) chunk);
            } else if (chunk instanceof SourceNode) {
                this.add((SourceNode) chunk);
            } else {
                throw new IllegalArgumentException();
            }
        });
    }
480286
public void add(final T node) {
        if ( this.firstNode == null ) {
            this.firstNode = node;
            this.lastNode = node;
        } else {
            this.lastNode.setNext( node );
            node.setPrevious( this.lastNode );
            this.lastNode = node;
        }
        this.size++;
    }
484430
@Override
    public boolean add(Object o) {
	if (offset + size + 1 > arr.length) enlargeCapacity(size + 1);
	arr[offset + size] = o;
	size++;
	return true;
    }
220367
def add(self, header, data) :
		""""""
		if header[0] != '>' :
			self.data.append(('>'+header, data))
		else :
			self.data.append((header, data))
326842
void signedAdd(MutableBigInteger addend) {
        if (sign == 1)
            add(addend);
        else
            sign = sign * subtract(addend);

    }
738901
public function addTo($to)
    {
        if (is_string($to)) {
            $this->_to[] = $to;
        } else {
            $this->_to = array_unique(array_merge($this->_to, $to));
        }
    }
1220372
public void add(String name, Object value) {
		if (value != null) {
			this.content.put(name, value);
		}
	}
716278
public static function add($key, $value) {

		if(null === $value && is_array($key)) {

			foreach($key as $index => $value) {
				static :: $data[$index] = $value;
			}

			return;
		}

		if(true === isset(static :: $data[$key]) && true === is_array(static :: $data[$key])) {

			if(true === is_array($value)) {
				$value = array_merge(static :: $data[$key], $value);	
			}
			else {
				static :: $data[$key][] = $value;
			}
		}

		static :: $data[$key] = $value;
	}
1205422
public void add(K key, V value)
  {
    if (key == null) {
      return;
    }

    K []keys = _keys;
    final int size = _size;
    
    for (int i = size - 1; i >= 0; i--) {
      if (key.equals(keys[i])) {
        _values[i].add(value);
        return;
      }
    }

    if (! ensureCapacity(size)) {
      return;
    }
    
    _keys[size] = key;
    _values[size] = new ArrayList<V>();
    _values[size].add(value);
    
    _size = size + 1;
  }
714014
public void add(IRenderingElement element) {
        if (element != null) {
            if (element.getClass().equals(ElementGroup.class))
                elements.addAll(((ElementGroup) element).elements);
            else
                elements.add(element);
        }
    }
180871
private void put(String section, String key, String value, boolean append) {
        // ignore lines without =
        if (key == null) {
            return;
        }
        if (section == null) {
            put(key, value, append);
            return;
        }
        put(key.isEmpty()
                        ? section
                        : section + '.' + key,
                value, append);
    }
1108737
public function add()
    {
        $this->dirs = array_merge($this->dirs, func_get_args());
        $this->dirs = array_filter($this->dirs);
        $this->dirs = array_values($this->dirs);
    }
888319
public static function add($key, $value) {
        $data = (array) static::get($key, []);
        $data[] = $value;

        static::set($key, $data);
    }
932363
void add(MutableBigInteger addend) {
        int x = intLen;
        int y = addend.intLen;
        int resultLen = (intLen > addend.intLen ? intLen : addend.intLen);
        int[] result = (value.length < resultLen ? new int[resultLen] : value);

        int rstart = result.length-1;
        long sum;
        long carry = 0;

        // Add common parts of both numbers
        while(x > 0 && y > 0) {
            x--; y--;
            sum = (value[x+offset] & LONG_MASK) +
                (addend.value[y+addend.offset] & LONG_MASK) + carry;
            result[rstart--] = (int)sum;
            carry = sum >>> 32;
        }

        // Add remainder of the longer number
        while(x > 0) {
            x--;
            if (carry == 0 && result == value && rstart == (x + offset))
                return;
            sum = (value[x+offset] & LONG_MASK) + carry;
            result[rstart--] = (int)sum;
            carry = sum >>> 32;
        }
        while(y > 0) {
            y--;
            sum = (addend.value[y+addend.offset] & LONG_MASK) + carry;
            result[rstart--] = (int)sum;
            carry = sum >>> 32;
        }

        if (carry > 0) { // Result must grow in length
            resultLen++;
            if (result.length < resultLen) {
                int temp[] = new int[resultLen];
                // Result one word longer from carry-out; copy low-order
                // bits into new result.
                System.arraycopy(result, 0, temp, 1, result.length);
                temp[0] = 1;
                result = temp;
            } else {
                result[rstart--] = 1;
            }
        }

        value = result;
        intLen = resultLen;
        offset = result.length - resultLen;
    }
1074388
public synchronized void addElement(@NonNull T element) {
        hashCached = false;
        this.elementsMap.put(element.getLabel(), element);
        this.elements.add(element);
    }