Add some kerning data

@param first The first character
@param second The second character
@param offset The kerning offset to apply
9189
public void addKerning(int first, int second, int offset) {
        kerning.add(new KerningData(first, second, offset));
    }
747555
private void copyToOffset(int offset) {
    final int minCapacity = 2 * (offset + nbrruns);
    if (valueslength.length < minCapacity) {
      // expensive case where we need to reallocate
      int newCapacity = valueslength.length;
      while (newCapacity < minCapacity) {
        newCapacity = (newCapacity == 0) ? DEFAULT_INIT_SIZE
            : newCapacity < 64 ? newCapacity * 2
                : newCapacity < 1024 ? newCapacity * 3 / 2 : newCapacity * 5 / 4;
      }
      short[] newvalueslength = new short[newCapacity];
      copyValuesLength(this.valueslength, 0, newvalueslength, offset, nbrruns);
      this.valueslength = newvalueslength;
    } else {
      // efficient case where we just copy
      copyValuesLength(this.valueslength, 0, this.valueslength, offset, nbrruns);
    }
  }
693406
public static ListValue of(String first, String... other) {
    return newBuilder().addValue(first, other).build();
  }
431861
public static String firstUpperCase(String s) {
		String first = s.length() > 0 ? s.substring(0, 1).toUpperCase() : "";
		String second = s.length() > 1 ? s.substring(1).toLowerCase() : "";
		return first + second;
	}
486628
def addKerning(self, instanceLocation=None, sources=None):
        
        items = []
        kerningObject = self.font.kerning
        kerningMasters = []
        if instanceLocation is None:
            instanceLocation = self.locationObject

        if sources is None:
            # kerning has no special requests, add the default sources
            sources = self.sources
        for sourceName, (source, sourceLocation) in sources.items():
            if sourceName in self.muted['kerning']:
                # kerning in this master was muted, so do not add.
                if self.verbose and self.logger:
                    self.logger.info("\tMuting kerning data for %s", instanceLocation)
                continue
            if len(source.kerning.keys())>0:
                items.append((sourceLocation, MathKerning(source.kerning, source.groups)))
        if items:
            m = None
            try:
                bias, m = buildMutator(items, axes=self.axes)
            except:
                if self.logger:
                    self.logger.exception("\tError processing kerning data. %s", items)
                return
            instanceObject = m.makeInstance(instanceLocation)
            if self.roundGeometry:
                instanceObject.round()
            instanceObject.extractKerning(self.font)
111462
public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }
580133
public void addChildren( AstNode first,
                             AstNode second ) {
        if (first != null) {
            this.addLastChild(first);
        }
        if (second != null) {
            this.addLastChild(second);
        }
    }
787788
public static void swap(final int[][] array, final long first, final long second)
    {
        final int t = array[segment(first)][displacement(first)];
        array[segment(first)][displacement(first)] = array[segment(second)][displacement(second)];
        array[segment(second)][displacement(second)] = t;
    }
624779
public static String getCommonPrefixPath(String first, String second) {

        List<String> firstComponents = getPathComponents(first);
        List<String> secondComponents = getPathComponents(second);
        int minSize = Math.min(firstComponents.size(), secondComponents.size());
        StringBuffer resultBuffer = new StringBuffer();
        for (int i = 0; i < minSize; i++) {
            if (firstComponents.get(i).equals(secondComponents.get(i))) {
                resultBuffer.append("/");
                resultBuffer.append(firstComponents.get(i));
            } else {
                break;
            }
        }
        String result = resultBuffer.toString();
        if (result.length() == 0) {
            result = "/";
        }
        return result;
    }
960850
private static void appendIndentedNewLine(int indentLevel, StringBuilder stringBuilder) {
        stringBuilder.append("\n");
        for (int i = 0; i < indentLevel; i++) {
            // Assuming indention using 2 spaces
            stringBuilder.append("  ");
        }
    }
1292120
private static boolean substringStartsWith(String string, int offset, String substring) {
    return string.regionMatches(offset, substring, 0, substring.length());
  }
939766
@SafeVarargs
  /* #end */
  public final void addFirst(KType... elements) {
    ensureBufferSpace(elements.length);
    for (KType k : elements) {
      addFirst(k);
    }
  }
625148
private void newBuffer(int offset) {
    if (maxBufferSize >= 0) {
      buffer = new int[maxBufferSize];
      isByte = new boolean[maxBufferSize];
      bufferOffset = offset;
      currentBufferSize = 0;
    }
  }
577663
@Override
	public boolean add(P polyline, double precision,
			OutputParameter<P> firstNeighbour,
			OutputParameter<P> secondNeighbour) {
		if (add(polyline)) {
			Point2d point;

			point = polyline.getPointAt(0);
			if (point != null) {
				firstNeighbour.set(getNearestEnd(polyline, point, precision));
			}

			point = polyline.getPointAt(polyline.getPointCount() - 1);
			if (point != null) {
				secondNeighbour.set(getNearestEnd(polyline, point, precision));
			}

			return true;
		}

		return false;
	}
458970
public void setSecond(final int SECOND) {
        second = SECOND % 60;
        calculateAngles(hour, minute, second);
        repaint(getInnerBounds());
    }
618632
static boolean areAdjacent(Token first, Token second) {
    return first.endLine == second.beginLine && first.endColumn == second.beginColumn - 1;
  }
76161
public static String intersectSeq(final String first, final String second) {
    return intersectSeq(first, second, DELIMITER);
  }