public void addMaxLength(final String mimeType, final long maxLength) {
        if (StringUtil.isBlank(mimeType)) {
            throw new CrawlerSystemException("MIME type is a blank.");
        }
        if (maxLength < 0) {
            throw new CrawlerSystemException("The value of maxLength is invalid.");
        }
        maxLengthMap.put(mimeType, maxLength);
    }

    public long getMaxLength(final String mimeType) {

@SuppressWarnings ( "javadoc" )
public class PacUnicodeString {

    private short length;
    private short maxLength;
    private int pointer;


    public PacUnicodeString ( short length, short maxLength, int pointer ) {
        super();
        this.length = length;
        this.maxLength = maxLength;
        this.pointer = pointer;
    }


    public short getLength () {
        return this.length;
    }

// with given validation rule and a set of enum values, following the convention of existing tests.
// The test has two checks, first with maxLength unset to check if maxLength can be concluded from enums,
// second with maxLength set to ensure it takes precedence.
func genEnumWithRuleAndValues(rule string, values ...string) func(maxLength *int64) *schema.Structural {

   * @param offset the start offset in the data
   * @param maxLength the maximum number of bytes to write
   * @return the number of bytes written to {@code dest}
   * @throws IndexOutOfBoundsException if there is not enough room in {@code dest}
   */
  @CanIgnoreReturnValue
  public int writeBytesTo(byte[] dest, int offset, int maxLength) {
    maxLength = Ints.min(maxLength, bits() / 8);

    public static String abbreviateJavaPackage(@Nonnull String qualifiedClassName, int maxLength) {
        if (qualifiedClassName.length() <= maxLength || qualifiedClassName.indexOf(PACKAGE_SEPARATOR) == -1) {
            return qualifiedClassName;
        }

        final int maxLengthWithoutEllipsis = maxLength - 3;
        int beginIdx = 0;
        // We always want to include className, even if longer than max length

   * @param offset the start offset in the data
   * @param maxLength the maximum number of bytes to write
   * @return the number of bytes written to {@code dest}
   * @throws IndexOutOfBoundsException if there is not enough room in {@code dest}
   */
  @CanIgnoreReturnValue
  public int writeBytesTo(byte[] dest, int offset, int maxLength) {
    maxLength = Ints.min(maxLength, bits() / 8);

                      maxLength: 253
                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
                      type: string
                    kind:
                      description: Kind is kind of the target resource.
                      maxLength: 63
                      minLength: 1

// The result of the estimation is the length of the longest possible value.
func estimateMaxStringEnumLength(s Schema) int64 {
	var maxLength int64
	for _, v := range s.Enum() {
		if s, ok := v.(string); ok && int64(len(s)) > maxLength {
			maxLength = int64(len(s))
		}
	}
	return maxLength
}

// estimateMaxArrayItemsPerRequest estimates the maximum number of array items with

                    description: Group is the group of the referent.
                    maxLength: 253
                    pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
                    type: string
                  kind:
                    description: Kind is kind of the referent.
                    maxLength: 63
                    minLength: 1

                                        {
                                            "type": "string",
                                            "minLength": 3,
                                            "maxLength": 50,
                                            "pattern": "^fixedquery$",
                                        },
                                        {"type": "null"},
                                    ],