Appends the value and qualifier to the appropriate arrays
@param next_qualifier The next qualifier to append
@param next_value The next value to append
767231
private void append(final byte[] next_qualifier, final byte[] next_value) {
    ensureCapacity(next_qualifier, next_value);

    // Now let's simply concatenate all the values together.
    System.arraycopy(next_value, 0, batched_value, value_index, next_value.length);
    value_index += next_value.length;

    // Now let's concatenate all the qualifiers together.
    System.arraycopy(next_qualifier, 0, batched_qualifier, qualifier_index, 
        next_qualifier.length);
    qualifier_index += next_qualifier.length;
  }
663171
public void append(String firstVal, String... otherVals) throws IOException {
		output.append(firstVal);
		for (String v : otherVals)
			output.append(valSep).append(v);
		output.append(lineSep);
	}
772778
def sub_step(value, type = :next)
      val = value.abs
      type = :prev if value < 0
      command(type == :next ? "sub_step #{val}" : "sub_step #{-val}" )
    end
1023837
private void putColumn(byte[] family, byte[] qualifier, byte[] qualifierValue)
    {
        this.columns.put(Bytes.toString(family) + ":" + Bytes.toString(qualifier), qualifierValue);
    }
1277553
@Override
  protected void copyFromNew() {
    advancedValueSumList = newAdvancedValueSumList;
    advancedValueSumOfLogsList = newAdvancedValueSumOfLogsList;
    advancedValueSumOfSquaresList = newAdvancedValueSumOfSquaresList;
    advancedValueMinList = newAdvancedValueMinList;
    advancedValueMaxList = newAdvancedValueMaxList;
    advancedValueNList = newAdvancedValueNList;
  }
1047116
def p_qualifierType_1(p):
    
    dv = None
    if len(p) == 5:
        dv = p[4]
    p[0] = (p[2], True, p[3], dv)
422251
def next_column
      # TODO take care of multipliers
      _calculate_column_offsets unless @coffsets
      c = @column_pointer.next
      cp = @coffsets[c]
      #$log.debug " next_column #{c} , #{cp} "
      @curpos = cp if cp
      down() if c < @column_pointer.last_index
      fire_column_event :ENTER_COLUMN
    end
1358832
@Override
	public void addNextProcessor(ChainedGlobalProcessor<T> nextProcessor) {

		if (this.nextProcessor == null) {
			this.nextProcessor = nextProcessor;
		} else {
			this.nextProcessor.addNextProcessor(nextProcessor);
		}
	}
104924
public void addNextValue(Object val) {
    long newVal = Long.parseLong(val.toString());
    if (this.maxVal < newVal) {
      this.maxVal = newVal;
    }
  }
1112381
private void initNewListBasic() {
    newAdvancedValueSumList = operations.createVector1(newSize);
    newAdvancedValueSumOfLogsList = operations.createVector2(newSize);
    newAdvancedValueSumOfSquaresList = operations.createVector1(newSize);
    newAdvancedValueMinList = operations.createVector1(newSize);
    newAdvancedValueMaxList = operations.createVector1(newSize);
    newAdvancedValueNList = new long[newSize];
  }
334634
def p_qualifierDeclaration(p):
    # pylint: disable=line-too-long
      # noqa: E501
    qualtype = p[3]
    dt, is_array, array_size, value = qualtype
    qualname = p[2]
    scopes = p[4]
    if len(p) == 5:
        flist = []
    else:
        flist = p[5]

    flavors = _build_flavors(p[0], flist)

    p[0] = CIMQualifierDeclaration(
        qualname, dt, value=value, is_array=is_array, array_size=array_size,
        scopes=scopes, **flavors)
157235
protected void setValue(int newPosition, T1[] values, int number,
      boolean currentExisting) {
    if (number > 0) {
      T1 valueSum = null;
      T2 valueSumOfLogs = null;
      T1 valueSumOfSquares = null;
      T1 valueMin = null;
      T1 valueMax = null;
      for (int i = 0; i < number; i++) {
        valueSum = (i == 0) ? values[i] : operations.add11(valueSum, values[i]);
        valueSumOfLogs = (i == 0) ? operations.log1(values[i])
            : operations.add22(valueSumOfLogs, operations.log1(values[i]));
        valueSumOfSquares = (i == 0)
            ? operations.product11(values[i], values[i])
            : operations.add11(valueSumOfSquares,
                operations.product11(values[i], values[i]));
        valueMin = (i == 0) ? values[i] : operations.min11(valueMin, values[i]);
        valueMax = (i == 0) ? values[i] : operations.max11(valueMax, values[i]);
      }
      setValue(newPosition, valueSum, valueSumOfLogs, valueSumOfSquares,
          valueMin, valueMax, number, currentExisting);
    }
  }
425291
public void addArgAttrs(List<Attribute> next) {
        int i;
        int max;
        Attribute attr;

        max = getArgCount();
        for (i = 0; i < max; i++) {
            attr = getArgAttribute(i);
            if (next.indexOf(attr) == -1) {
                next.add(attr);
            }
        }
    }
705976
public void addNextValue(Object val) {
    if (this.numItems <= this.maxNumItems) {
      uniqItems.put(val.toString(), "1");
      this.numItems = this.uniqItems.size();
    }
  }
955014
private String _write_feature_qualifier(String key, String value, boolean quote) {
		String line = "";
		if(null == value) {
			line = QUALIFIER_INDENT_STR + "/" + key + lineSep;
			return line;
		}
		if(quote) {  // quote should be true for numerics
			line = QUALIFIER_INDENT_STR + "/" + key + "=\"" + value + "\"";
		} else {
			line = QUALIFIER_INDENT_STR + "/" + key + "=" + value;
		}
		if(line.length() <= MAX_WIDTH) {
			return line + lineSep;
		}
		String goodlines = "";
		while(!"".equals(line.replaceAll("^\\s+", ""))) {
			if(line.length() <= MAX_WIDTH) {
				goodlines += line + lineSep;
				break;
			}
			//Insert line break...
			int index;
			for(index = Math.min(line.length()-1, MAX_WIDTH); index > QUALIFIER_INDENT ; index--) {
				if(' ' == line.charAt(index)) {
					break;
				}
			}
			if(' ' != line.charAt(index)) {
				//no nice place to break...
				index = MAX_WIDTH;
			}
			assert index <= MAX_WIDTH;
			goodlines += line.substring(0,index) + lineSep;
			line = QUALIFIER_INDENT_STR + line.substring(index).replaceAll("^\\s+", "");
		}
		return goodlines;
	}
106747
public void setQualifier(String qualifier) {
        SystemAssert.requireArgument(qualifier != null && !qualifier.isEmpty(), "Namespace qualifier cannot be null or empty.");
        this.qualifier = qualifier;
    }
153337
private void compileAssignment(Sequence sequence, TokenList tokens, TokenList.Token t0) {
        // see if it is assign or a range
        List<Variable> range = parseAssignRange(sequence, tokens, t0);

        TokenList.Token t1 = t0.next;
        if (t1.getType() != Type.SYMBOL || t1.getSymbol() != Symbol.ASSIGN)
            throw new ParseError("Expected assignment operator next");

        // Parse the right side of the equation
        TokenList tokensRight = tokens.extractSubList(t1.next, tokens.last);
        compileTokens(sequence, tokensRight);
        if (tokensRight.getLast().getType() != Type.VARIABLE)
            throw new RuntimeException("BUG the last token must be a variable");

        // copy the results into the output
        Variable variableRight = tokensRight.getFirst().getVariable();
        if (range == null) {
            // no range, so copy results into the entire output matrix
            sequence.output = createVariableInferred(t0, variableRight);
            sequence.addOperation(Operation.copy(variableRight, sequence.output));
        } else {
            // a sub-matrix range is specified.  Copy into that inner part
            if (t0.getType() == Type.WORD) {
                throw new ParseError("Can't do lazy variable initialization with submatrices. " + t0.getWord());
            }
            sequence.addOperation(Operation.copy(variableRight, t0.getVariable(), range));
        }
    }