func appendSettingFromTag(tag reflect.StructTag, value string) reflect.StructTag {
	t := tag.Get("gorm")
	if strings.Contains(t, value) {
		return tag
	}
	return reflect.StructTag(fmt.Sprintf(`gorm:"%s;%s"`, value, t))
}

// GetRelationsValues get relations's values from a reflect value
func GetRelationsValues(ctx context.Context, reflectValue reflect.Value, rels []*Relationship) (reflectResults reflect.Value) {
	for _, rel := range rels {

        }
        final int[] values = new int[2];
        values[0] = Integer.parseInt(froms[0]);
        if (values[0] < 0 || values[0] > 23) {
            throw new FessSystemException("Invalid format: " + time);
        }
        values[1] = Integer.parseInt(froms[1]);
        if (values[1] < 0 || values[1] > 59) {
            throw new FessSystemException("Invalid format: " + time);

  // in the short hash. We saw that a mask of 0x7f would keep the 7-bit value 0x6f from a full
  // hashcode of 0x89abcdef. The imaginary `hash` value would then be the remaining top 25 bits,
  // 0x89abcd80. To this is added (or'd) the `next` value, which is an index within `entries`
  // (and therefore within `keys` and `values`) of another entry that has the same short hash

    // forward map ordered by currency (even for country values)
    assertThat(bimap.values()).containsExactly(Country.CANADA, Country.CHILE).inOrder();
    // backward map ordered by country
    assertThat(bimap.inverse().keySet()).containsExactly(Country.CANADA, Country.CHILE).inOrder();
    // backward map ordered by country (even for currency values)
    assertThat(bimap.inverse().values()).containsExactly(Currency.DOLLAR, Currency.PESO).inOrder();

    keyIterator.next();
    keyIterator.remove();
    assertFalse(underlying.containsKey("c"));

    Collection<String> values = map.values();
    values.remove("4");
    assertFalse(underlying.containsKey("d"));

    Iterator<String> valueIterator = values.iterator();
    valueIterator.next();
    valueIterator.remove();
    assertFalse(underlying.containsKey("e"));

  @Override
  protected void assertGet(K key, V... values) {
    assertGet(key, asList(values));
  }

  @Override
  protected void assertGet(K key, Collection<? extends V> values) {
    assertEqualInOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualInOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {

      SampleElements<Entry<K, V>> mapEntries(SampleElements<K> keys, SampleElements<V> values) {
    return new SampleElements<>(
        mapEntry(keys.e0(), values.e0()),
        mapEntry(keys.e1(), values.e1()),
        mapEntry(keys.e2(), values.e2()),
        mapEntry(keys.e3(), values.e3()),
        mapEntry(keys.e4(), values.e4()));
  }

  public E e0() {
    return e0;
  }

  public E e1() {

     * Returns true if the array is empty, otherwise false.
     *
     * @param values The array.
     * @return True if the array is empty, otherwise false.
     */
    protected boolean isEmptyArray(final String[] values) {
        if (values == null || values.length == 0) {
            return true;
        }
        return stream(values).get(stream -> stream.allMatch(StringUtil::isBlank));
    }

    /**

    }
  }

  @LazyInit private transient @Nullable Collection<V> values;

  @Override
  public Collection<V> values() {
    Collection<V> result = values;
    return (result == null) ? values = createValues() : result;
  }

  Collection<V> createValues() {
    return new Values();
  }

  Iterator<V> valuesIterator() {

   */
  fun toDer(
    writer: DerWriter,
    value: T,
  )

  fun toDer(value: T): ByteString {
    val buffer = Buffer()
    val writer = DerWriter(buffer)
    toDer(writer, value)
    return buffer.readByteString()
  }

  /**
   * Returns an adapter that expects this value wrapped by another value. Typically this occurs
   * when a value has both a context or application tag and a universal tag.
   *