*
     * @param array
     *            the array
     * @param value
     *            the value to search for
     * @return {@literal true} if the array contains the specified value
     */
    public static boolean contains(final long[] array, final long value) {
        return indexOf(array, value) > -1;
    }

    /**
     * Returns {@literal true} if the array contains the specified value.

        this.css = css;
    }

    /**
     * Sets a custom attribute name-value pair that this pruned tag should match.
     *
     * @param name the attribute name to match
     * @param value the attribute value to match
     */
    public void setAttr(final String name, final String value) {
        attrName = name;
        attrValue = value;
    }

    @Override
    public String toString() {

	if index >= int64(len(r.csvRecord)) {
		// No value found for column 'name', hence return null
		// value
		return sql.FromNull(), nil
	}

	return sql.FromBytes([]byte(r.csvRecord[index])), nil
}

// Set - sets the value for a column name.
func (r *Record) Set(name string, value *sql.Value) (sql.Record, error) {
	r.columnNames = append(r.columnNames, name)
	r.csvRecord = append(r.csvRecord, value.CSVString())
	return r, nil
}

				if value, isZero := field.ValueOf(stmt.Context, stmt.ReflectValue); !isZero {
					stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.Eq{Column: field.DBName, Value: value}}})
				}
			}
		}
	}

	switch value := updatingValue.Interface().(type) {
	case map[string]interface{}:
		set = make([]clause.Assignment, 0, len(value))

		keys := make([]string, 0, len(value))

        return new InnerInterpolator() {
            @Override
            public String interpolate(String value) {
                if (value != null && value.contains("${")) {
                    String c = cache.get(value);
                    if (c == null) {
                        try {
                            c = interpolator.interpolate(value, recursionInterceptor);
                        } catch (InterpolationException e) {

	builder.WriteString(" NOT LIKE ")
	builder.AddVar(builder, like.Value)
}

func eqNil(value interface{}) bool {
	if valuer, ok := value.(driver.Valuer); ok && !eqNilReflect(valuer) {
		value, _ = valuer.Value()
	}

	return value == nil || eqNilReflect(value)
}

func eqNilReflect(value interface{}) bool {
	reflectValue := reflect.ValueOf(value)
	return reflectValue.Kind() == reflect.Ptr && reflectValue.IsNil()

public class UnhashableObject implements Comparable<UnhashableObject> {
  private final int value;

  public UnhashableObject(int value) {
    this.value = value;
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object instanceof UnhashableObject) {
      UnhashableObject that = (UnhashableObject) object;
      return this.value == that.value;
    }
    return false;
  }

  @Override

    }

    /**
     * Returns the value of the request header.
     * @return The value of the request header.
     */
    public String getValue() {
        return value;
    }

    /**
     * Sets the value of the request header.
     * @param value The value of the request header.
     */
    public void setValue(final String value) {
        this.value = value;
    }

    /**

    private Profile newProfile(String key, String value) {
        ActivationProperty ap =
                ActivationProperty.newBuilder().name(key).value(value).build();

        Activation a = Activation.newBuilder().property(ap).build();

        Profile p = Profile.newBuilder().activation(a).build();

        return p;
    }

    private Properties newProperties(String key, String value) {
        Properties props = new Properties();

  }

  @Override
  public V get(Object key) {
    checkNotNull(key);
    Timestamped<V> value = cachingHashMap.get(key);

    if (value == null) {
      statsCounter.recordMisses(1);
      return null;
    } else if (!isExpired(value)) {
      statsCounter.recordHits(1);
      value.updateTimestamp();
      return value.getValue();
    } else {
      statsCounter.recordEviction();
      statsCounter.recordMisses(1);