buf.append(':');
                buf.append(port);
            }
            buf.append('/');
        }
        return buf.toString();
    }

    /**
     * Returns the SMB server address.
     * @return the server address
     */
    public String getServer() {
        return server;
    }

    /**
     * Sets the SMB server address.
     * @param server the server address to set
     */

     *
     * @param <E> the element type
     * @param value the single value returned by the iterator
     * @return an {@link Iterable} wrapping a {@link SingleValueIterator}
     */
    public static <E> Iterable<E> iterable(final E value) {
        return () -> new SingleValueIterator<>(value);
    }

    /**
     * Constructs an instance.
     *

    }

    /**
     * @param ts
     * @return
     */
    private static byte[] encode(final long ts) {
        final byte[] data = new byte[8];
        SMBUtil.writeInt8(ts, data, 0);
        return data;
    }

    /**
     * Gets the timestamp value from this AV pair
     *
     * @return the timestamp
     */
    public long getTimestamp() {
        return SMBUtil.readInt8(getRaw(), 0);
    }

      delegate.dispatcher = value.wrap()
    }

  val port: Int
    get() {
      before() // This implicitly starts the delegate.
      return delegate.port
    }

  val hostName: String
    get() {
      before() // This implicitly starts the delegate.
      return delegate.hostName
    }

  var protocolNegotiationEnabled: Boolean by delegate::protocolNegotiationEnabled

  @get:JvmName("protocols")

                    return;
                }
            }
            throw new DcerpcException("Bad endpoint: " + endpoint);
        }
        if (options == null) {
            options = new HashMap();
        }
        options.put(key, val);
    }

    Object getOption(final String key) {
        if (key.equals("endpoint")) {
            return endpoint;
        }

  }

  @Override
  public int count(@Nullable Object element) {
    return forward.count(element);
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return forward.firstEntry();
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override

		if time.Now().After(ent.ExpiresAt) {
			return value, false
		}
		return ent.Value, true
	}
	return
}

// Remove removes the provided key from the cache, returning if the
// key was contained.
func (c *LRU[K, V]) Remove(key K) bool {
	c.mu.Lock()
	defer c.mu.Unlock()
	if ent, ok := c.items[key]; ok {
		c.removeElement(ent)
		return true
	}
	return false
}

                return entity;
            });
        case CrudMode.EDIT:
            if (form instanceof EditForm) {
                return ComponentUtil.getComponent(WebConfigService.class).getWebConfig(((EditForm) form).id);
            }
            break;
        default:
            break;
        }
        return OptionalEntity.empty();
    }

    /**

        }
        if (DEFAULT_FIELD.equals(field)) {
            return convertDefaultTermQuery(fessConfig, context, termQuery, boost, field, text);
        }
        if (SORT_FIELD.equals(field)) {
            return convertSortQuery(fessConfig, context, termQuery, boost, field, text);
        }
        if (SITE_FIELD.equals(field)) {
            return convertSiteQuery(fessConfig, context, termQuery, boost, field, text);
        }

        this.realm = realm;
    }

    /**
     * Get the Kerberos realm
     *
     * @return the kerberos realm
     */
    public String getRealm() {
        return this.realm;
    }

    /**
     * Get the <code>Subject</code> object.
     *
     * @return Subject represents the user who perform Kerberos authentication.
     *         It contains the tickets retrieve from KDC.
     */