EgretDoc
Back to Home
Location:system/aio.memcache

Module

Module documentation.

moduleaio.memcache

Classes

Classes and inheritance.

classaio.memcache::ResultList
@brief`ResultList` type.
@details`ResultList` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class ResultList {
    /*
    @brief `values` field.
classaio.memcache::Conn
@brief`Conn` type.
@details`Conn` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class Conn {
    /*
    @brief `fd` field.
classaio.memcache::UdpClient
@brief`UdpClient` type.
@details`UdpClient` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class UdpClient {
    /*
    @brief `fd` field.
classaio.memcache::Pool
@brief`Pool` type.
@details`Pool` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class Pool {
    /*
    @brief `cfg` field.
classaio.memcache::ShardedClient
@brief`ShardedClient` type.
@details`ShardedClient` encapsulates state and operations exported by the system module. It commonly stores runtime handles, protocol state, buffers, configuration, or collection data. Its methods define the primary behavior for the type. If the type owns external resources, prefer `dispose` or `close` for deterministic release.
class ShardedClient {
    /*
    @brief `servers` field.

Functions

Free functions and class methods.

functionaio.memcache::ResultList.init
Signaturefunc init(self: aio.memcache.ResultList) -> Void
    func init(self: aio.memcache.ResultList) -> Void {
        self.values = new collections.Vector<protocol.memcache.Item>();
    }
@briefInitializes a `ResultList` instance.
@detailsEstablishes the initial field state for `ResultList` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::ResultList.len
Signaturefunc len(self: aio.memcache.ResultList) -> Int
    func len(self: aio.memcache.ResultList) -> Int {
        return self.values.len();
    }
@briefReturns the element count or byte length with `ResultList.len`.
@detailsExecutes the `len` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `Int`.
functionaio.memcache::ResultList.get
Signaturefunc get(self: aio.memcache.ResultList, idx: Int) -> protocol.memcache.Item
    func get(self: aio.memcache.ResultList, idx: Int) -> protocol.memcache.Item {
        return self.values.get_unchecked(idx);
    }
@briefReads the element for `ResultList.get`.
@detailsExecutes the `get` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • idxZero-based index.
@returnReturns the operation result as `protocol.memcache.Item`.
functionaio.memcache::ResultList.push
Signaturefunc push(self: aio.memcache.ResultList, value: protocol.memcache.Item) -> Void
    func push(self: aio.memcache.ResultList, value: protocol.memcache.Item) -> Void {
        _ = self.values.push(value);
    }
@briefAppends an element with `ResultList.push`.
@detailsExecutes the `push` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • valueValue to write or store.
@returnVoid
functionaio.memcache::ResultList.deinit
Signaturefunc deinit(self: aio.memcache.ResultList) -> Void
    func deinit(self: aio.memcache.ResultList) -> Void {
    }
}
@briefReleases fallback resources at the end of the `ResultList` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::Conn.init
Signaturefunc init(self: aio.memcache.Conn, fd: Int, timeout_ms: Int = 5000) -> Void
    func init(self: aio.memcache.Conn, fd: Int, timeout_ms: Int = 5000) -> Void {
        self.fd = fd;
        self.tls_h = 0;
@briefInitializes a `Conn` instance.
@detailsEstablishes the initial field state for `Conn` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • fdOperating-system file descriptor or socket descriptor.
  • timeout_msTimeout in milliseconds; negative values usually select blocking or default timeout behavior.
@returnVoid
functionaio.memcache::Conn.set_timeouts
Signaturefunc set_timeouts(self: aio.memcache.Conn, read_timeout_ms: Int, write_timeout_ms: Int) -> Void
    func set_timeouts(self: aio.memcache.Conn, read_timeout_ms: Int, write_timeout_ms: Int) -> Void {
        self.read_timeout_ms = read_timeout_ms;
        self.write_timeout_ms = write_timeout_ms;
@briefSets state or configuration with `Conn.set_timeouts`.
@detailsExecutes the `set_timeouts` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • read_timeout_msTime interval or timeout value in milliseconds.
  • write_timeout_msTime interval or timeout value in milliseconds.
@returnVoid
functionaio.memcache::Conn.clear_error
Signaturefunc clear_error(self: aio.memcache.Conn) -> Void
    func clear_error(self: aio.memcache.Conn) -> Void {
        self.last_error = new protocol.memcache.Error();
    }
@briefProvides the system library operation `Conn.clear_error`.
@detailsExecutes the `clear_error` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::Conn.close
Signaturefunc close(self: aio.memcache.Conn) -> Void
    func close(self: aio.memcache.Conn) -> Void {
        if self.closed {
            return;
@briefCloses resources and makes later operations unavailable with `Conn.close`.
@detailsExecutes the `close` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::Conn.dispose
Signaturefunc dispose(self: aio.memcache.Conn) -> Void
    func dispose(self: aio.memcache.Conn) -> Void {
        _ = self.close();
    }
@briefExplicitly releases resources owned by `Conn`.
@detailsThis method deterministically cleans up file descriptors, network connections, native handles, buffers, or other external resources. Implementations should be idempotent where possible, and repeated calls must not corrupt object state.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::Conn.deinit
Signaturefunc deinit(self: aio.memcache.Conn) -> Void
    func deinit(self: aio.memcache.Conn) -> Void {
        if !self.closed {
            _ = self.close();
@briefReleases fallback resources at the end of the `Conn` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::Conn.expect_ok
Signaturefunc expect_ok(self: aio.memcache.Conn, response: protocol.memcache.Response) -> ErrCode
    func expect_ok(self: aio.memcache.Conn, response: protocol.memcache.Response) -> ErrCode {
        if response.is_error() {
            return net.memcache.err_code_from_memcache(response.error);
@briefProvides the system library operation `Conn.expect_ok`.
@detailsExecutes the `expect_ok` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • responseResponse object or response payload decoded, encoded, or returned by the operation.
@returnReturns `ErrCode`; on success the error code is `std.OK` or `OK`, and on failure the error code describes the failure while any returned value contains the usable partial result when available.
functionaio.memcache::UdpClient.init
Signaturefunc init(self: aio.memcache.UdpClient, fd: Int, host: String, port: Int, timeout_ms: Int = 5000) -> Void
    func init(self: aio.memcache.UdpClient, fd: Int, host: String, port: Int, timeout_ms: Int = 5000) -> Void {
        self.fd = fd;
        self.host = host;
@briefInitializes a `UdpClient` instance.
@detailsEstablishes the initial field state for `UdpClient` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • fdOperating-system file descriptor or socket descriptor.
  • hostHost name or listen address.
  • portPort number.
  • timeout_msTimeout in milliseconds; negative values usually select blocking or default timeout behavior.
@returnVoid
functionaio.memcache::UdpClient.alloc_request_id
Signaturefunc alloc_request_id(self: aio.memcache.UdpClient) -> Int
    func alloc_request_id(self: aio.memcache.UdpClient) -> Int {
        let id: Int = self.next_request_id;
        self.next_request_id += 1;
@briefProvides the system library operation `UdpClient.alloc_request_id`.
@detailsExecutes the `alloc_request_id` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnReturns the operation result as `Int`.
functionaio.memcache::UdpClient.close
Signaturefunc close(self: aio.memcache.UdpClient) -> Void
    func close(self: aio.memcache.UdpClient) -> Void {
        if !self.closed {
            _ = aio.udp.close(self.fd);
@briefCloses resources and makes later operations unavailable with `UdpClient.close`.
@detailsExecutes the `close` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::UdpClient.deinit
Signaturefunc deinit(self: aio.memcache.UdpClient) -> Void
    func deinit(self: aio.memcache.UdpClient) -> Void {
        _ = self.close();
    }
@briefReleases fallback resources at the end of the `UdpClient` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::connect_udp
Signaturefunc connect_udp(cfg: protocol.memcache.Config) -> aio.memcache.UdpClient, ErrCode
func connect_udp(cfg: protocol.memcache.Config) -> aio.memcache.UdpClient, ErrCode {
    let fd, err = aio.udp.bind("0.0.0.0", 0);
    if err != std.OK {
@briefProvides the system library operation `connect_udp`.
@detailsExecutes the `connect_udp` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • cfgConfiguration value or pointer used to initialize or control the operation.
@returnReturns `aio.memcache.UdpClient, ErrCode`; on success the error code is `std.OK` or `OK`, and on failure the error code describes the failure while any returned value contains the usable partial result when available.
functionaio.memcache::Pool.init
Signaturefunc init(self: aio.memcache.Pool, cfg: net.memcache.PoolConfig) -> Void
    func init(self: aio.memcache.Pool, cfg: net.memcache.PoolConfig) -> Void {
        self.cfg = cfg;
        self.idle = new collections.Vector<aio.memcache.Conn>();
@briefInitializes a `Pool` instance.
@detailsEstablishes the initial field state for `Pool` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • cfgConfiguration value or pointer used to initialize or control the operation.
@returnVoid
functionaio.memcache::Pool.should_discard
Signaturefunc should_discard(self: aio.memcache.Pool, conn: aio.memcache.Conn) -> Bool
    func should_discard(self: aio.memcache.Pool, conn: aio.memcache.Conn) -> Bool {
        let now: Int = time.now_ms();
        if conn.closed || conn.broken || self.cfg.max_idle_ms > 0 && now - conn.last_used_at_ms > self.cfg.max_idle_ms || self.cfg.max_lifetime_ms > 0 && now - conn.created_at_ms > self.cfg.max_lifetime_ms {
@briefProvides the system library operation `Pool.should_discard`.
@detailsExecutes the `should_discard` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • connConnection object or native connection handle used for network I/O.
@returnReturns a boolean result; true means the condition holds or the operation succeeded.
functionaio.memcache::Pool.release
Signaturefunc release(self: aio.memcache.Pool, conn: aio.memcache.Conn) -> Void
    func release(self: aio.memcache.Pool, conn: aio.memcache.Conn) -> Void {
        conn.borrowed_at_ms = 0;
        if self.should_discard(conn) {
@briefProvides the system library operation `Pool.release`.
@detailsExecutes the `release` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • connConnection object or native connection handle used for network I/O.
@returnVoid
functionaio.memcache::Pool.close
Signaturefunc close(self: aio.memcache.Pool) -> Void
    func close(self: aio.memcache.Pool) -> Void {
        if self.closed {
            return;
@briefCloses resources and makes later operations unavailable with `Pool.close`.
@detailsExecutes the `close` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::Pool.deinit
Signaturefunc deinit(self: aio.memcache.Pool) -> Void
    func deinit(self: aio.memcache.Pool) -> Void {
        _ = self.close();
    }
@briefReleases fallback resources at the end of the `Pool` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::ShardedClient.init
Signaturefunc init(self: aio.memcache.ShardedClient) -> Void
    func init(self: aio.memcache.ShardedClient) -> Void {
        self.servers = new collections.Vector<net.memcache.Server>();
        self.pools = new collections.Vector<aio.memcache.Pool>();
@briefInitializes a `ShardedClient` instance.
@detailsEstablishes the initial field state for `ShardedClient` so other methods can be called safely. Constructor logic should keep fields consistent and avoid leaking partially initialized resources.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::ShardedClient.add_server
Signaturefunc add_server(self: aio.memcache.ShardedClient, server: net.memcache.Server, cfg: net.memcache.PoolConfig) -> Void
    func add_server(self: aio.memcache.ShardedClient, server: net.memcache.Server, cfg: net.memcache.PoolConfig) -> Void {
        let index: Int = self.servers.len();
        _ = self.servers.push(server);
@briefProvides the system library operation `ShardedClient.add_server`.
@detailsExecutes the `add_server` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • serverServer address, descriptor, or connection target used by the operation.
  • cfgConfiguration value or pointer used to initialize or control the operation.
@returnVoid
functionaio.memcache::ShardedClient.pool_for_key
Signaturefunc pool_for_key(self: aio.memcache.ShardedClient, key: String) -> aio.memcache.Pool, ErrCode
    func pool_for_key(self: aio.memcache.ShardedClient, key: String) -> aio.memcache.Pool, ErrCode {
        let index: Int = self.hasher.pick(key);
        if index < 0 || index >= self.pools.len() {
@briefProvides the system library operation `ShardedClient.pool_for_key`.
@detailsExecutes the `pool_for_key` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
  • keyKey name.
@returnReturns `aio.memcache.Pool, ErrCode`; on success the error code is `std.OK` or `OK`, and on failure the error code describes the failure while any returned value contains the usable partial result when available.
functionaio.memcache::ShardedClient.close
Signaturefunc close(self: aio.memcache.ShardedClient) -> Void
    func close(self: aio.memcache.ShardedClient) -> Void {
        if self.closed {
            return;
@briefCloses resources and makes later operations unavailable with `ShardedClient.close`.
@detailsExecutes the `close` system-library API. The documented parameters define the accepted inputs, ownership requirements, range limits, and timeout behavior for this call. Callers must check returned `ErrCode` values or boolean status values before using the result.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid
functionaio.memcache::ShardedClient.deinit
Signaturefunc deinit(self: aio.memcache.ShardedClient) -> Void
    func deinit(self: aio.memcache.ShardedClient) -> Void {
        _ = self.close();
    }
@briefReleases fallback resources at the end of the `ShardedClient` lifetime.
@detailsThis destructor hook is called by object lifetime management to clean up underlying resources that were not released explicitly. Normal application code should prefer `dispose`, `close`, or the module-specific close function to release resources at a deterministic time.
@param
  • selfThe current instance whose fields, handles, buffers, or external resources are read or modified by this method.
@returnVoid

Variables

Class fields (var).

varaio.memcache::ResultList.values
Typecollections.Vector<protocol.memcache.Item>
@brief`values` field.
@detailsHolds the `values` value for each `ResultList` instance. The field type is `collections.Vector<protocol.memcache.Item>`, and constructors and methods keep it synchronized with the object's runtime state.
    var values: collections.Vector<protocol.memcache.Item>;

    /*
varaio.memcache::Conn.fd
TypeInt
@brief`fd` field.
@detailsStores the underlying file descriptor or socket descriptor. The field type is `Int`, and it is maintained by the constructors and methods of `Conn`.
    var fd: Int;
    /*
    @brief `tls_h` field.
varaio.memcache::Conn.tls_h
TypeInt
@brief`tls_h` field.
@detailsHolds the `tls_h` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var tls_h: Int;
    /*
    @brief `tls_enabled` field.
varaio.memcache::Conn.tls_enabled
TypeBool
@brief`tls_enabled` field.
@detailsHolds the `tls_enabled` value for each `Conn` instance. The field type is `Bool`, and constructors and methods keep it synchronized with the object's runtime state.
    var tls_enabled: Bool;
    /*
    @brief `timeout_ms` field.
varaio.memcache::Conn.timeout_ms
TypeInt
@brief`timeout_ms` field.
@detailsStores the default timeout in milliseconds. The field type is `Int`, and it is maintained by the constructors and methods of `Conn`.
    var timeout_ms: Int;
    /*
    @brief `read_timeout_ms` field.
varaio.memcache::Conn.read_timeout_ms
TypeInt
@brief`read_timeout_ms` field.
@detailsHolds the `read_timeout_ms` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var read_timeout_ms: Int;
    /*
    @brief `write_timeout_ms` field.
varaio.memcache::Conn.write_timeout_ms
TypeInt
@brief`write_timeout_ms` field.
@detailsHolds the `write_timeout_ms` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var write_timeout_ms: Int;
    /*
    @brief `closed` field.
varaio.memcache::Conn.closed
TypeBool
@brief`closed` field.
@detailsIndicates whether the resource has already been closed. The field type is `Bool`, and it is maintained by the constructors and methods of `Conn`.
    var closed: Bool;
    /*
    @brief `broken` field.
varaio.memcache::Conn.broken
TypeBool
@brief`broken` field.
@detailsHolds the `broken` value for each `Conn` instance. The field type is `Bool`, and constructors and methods keep it synchronized with the object's runtime state.
    var broken: Bool;
    /*
    @brief `reader` field.
varaio.memcache::Conn.reader
Typeprotocol.memcache.Reader
@brief`reader` field.
@detailsHolds the `reader` value for each `Conn` instance. The field type is `protocol.memcache.Reader`, and constructors and methods keep it synchronized with the object's runtime state.
    var reader: protocol.memcache.Reader;
    /*
    @brief `last_error` field.
varaio.memcache::Conn.last_error
Typeprotocol.memcache.Error
@brief`last_error` field.
@detailsHolds the `last_error` value for each `Conn` instance. The field type is `protocol.memcache.Error`, and constructors and methods keep it synchronized with the object's runtime state.
    var last_error: protocol.memcache.Error;
    /*
    @brief `protocol_mode` field.
varaio.memcache::Conn.protocol_mode
Typeprotocol.memcache.ProtocolMode
@brief`protocol_mode` field.
@detailsHolds the `protocol_mode` value for each `Conn` instance. The field type is `protocol.memcache.ProtocolMode`, and constructors and methods keep it synchronized with the object's runtime state.
    var protocol_mode: protocol.memcache.ProtocolMode;
    /*
    @brief `created_at_ms` field.
varaio.memcache::Conn.created_at_ms
TypeInt
@brief`created_at_ms` field.
@detailsHolds the `created_at_ms` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var created_at_ms: Int;
    /*
    @brief `last_used_at_ms` field.
varaio.memcache::Conn.last_used_at_ms
TypeInt
@brief`last_used_at_ms` field.
@detailsHolds the `last_used_at_ms` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var last_used_at_ms: Int;
    /*
    @brief `borrowed_at_ms` field.
varaio.memcache::Conn.borrowed_at_ms
TypeInt
@brief`borrowed_at_ms` field.
@detailsHolds the `borrowed_at_ms` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var borrowed_at_ms: Int;
    /*
    @brief `use_count` field.
varaio.memcache::Conn.use_count
TypeInt
@brief`use_count` field.
@detailsHolds the `use_count` value for each `Conn` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var use_count: Int;

    /*
varaio.memcache::UdpClient.fd
TypeInt
@brief`fd` field.
@detailsStores the underlying file descriptor or socket descriptor. The field type is `Int`, and it is maintained by the constructors and methods of `UdpClient`.
    var fd: Int;
    /*
    @brief `tls_h` field.
varaio.memcache::UdpClient.host
TypeString
@brief`host` field.
@detailsStores a host name or network address. The field type is `String`, and it is maintained by the constructors and methods of `UdpClient`.
    var host: String;
    /*
    @brief `port` field.
varaio.memcache::UdpClient.port
TypeInt
@brief`port` field.
@detailsStores a port number. The field type is `Int`, and it is maintained by the constructors and methods of `UdpClient`.
    var port: Int;
    /*
    @brief `timeout_ms` field.
varaio.memcache::UdpClient.timeout_ms
TypeInt
@brief`timeout_ms` field.
@detailsStores the default timeout in milliseconds. The field type is `Int`, and it is maintained by the constructors and methods of `UdpClient`.
    var timeout_ms: Int;
    /*
    @brief `read_timeout_ms` field.
varaio.memcache::UdpClient.max_datagram_bytes
TypeInt
@brief`max_datagram_bytes` field.
@detailsHolds the `max_datagram_bytes` value for each `UdpClient` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var max_datagram_bytes: Int;
    /*
    @brief `next_request_id` field.
varaio.memcache::UdpClient.next_request_id
TypeInt
@brief`next_request_id` field.
@detailsHolds the `next_request_id` value for each `UdpClient` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var next_request_id: Int;
    /*
    @brief `closed` field.
varaio.memcache::UdpClient.closed
TypeBool
@brief`closed` field.
@detailsIndicates whether the resource has already been closed. The field type is `Bool`, and it is maintained by the constructors and methods of `UdpClient`.
    var closed: Bool;
    /*
    @brief `broken` field.
varaio.memcache::Pool.cfg
Typenet.memcache.PoolConfig
@brief`cfg` field.
@detailsHolds the `cfg` value for each `Pool` instance. The field type is `net.memcache.PoolConfig`, and constructors and methods keep it synchronized with the object's runtime state.
    var cfg: net.memcache.PoolConfig;
    /*
    @brief `idle` field.
varaio.memcache::Pool.idle
Typecollections.Vector<aio.memcache.Conn>
@brief`idle` field.
@detailsHolds the `idle` value for each `Pool` instance. The field type is `collections.Vector<aio.memcache.Conn>`, and constructors and methods keep it synchronized with the object's runtime state.
    var idle: collections.Vector<aio.memcache.Conn>;
    /*
    @brief `mu` field.
varaio.memcache::Pool.mu
Typesync.Mutex
@brief`mu` field.
@detailsHolds the `mu` value for each `Pool` instance. The field type is `sync.Mutex`, and constructors and methods keep it synchronized with the object's runtime state.
    var mu: sync.Mutex;
    /*
    @brief `cond` field.
varaio.memcache::Pool.cond
Typesync.CondVar
@brief`cond` field.
@detailsHolds the `cond` value for each `Pool` instance. The field type is `sync.CondVar`, and constructors and methods keep it synchronized with the object's runtime state.
    var cond: sync.CondVar;
    /*
    @brief `open_count` field.
varaio.memcache::Pool.open_count
TypeInt
@brief`open_count` field.
@detailsHolds the `open_count` value for each `Pool` instance. The field type is `Int`, and constructors and methods keep it synchronized with the object's runtime state.
    var open_count: Int;
    /*
    @brief `closed` field.
varaio.memcache::Pool.closed
TypeBool
@brief`closed` field.
@detailsIndicates whether the resource has already been closed. The field type is `Bool`, and it is maintained by the constructors and methods of `Pool`.
    var closed: Bool;
    /*
    @brief `broken` field.
varaio.memcache::ShardedClient.servers
Typecollections.Vector<net.memcache.Server>
@brief`servers` field.
@detailsHolds the `servers` value for each `ShardedClient` instance. The field type is `collections.Vector<net.memcache.Server>`, and constructors and methods keep it synchronized with the object's runtime state.
    var servers: collections.Vector<net.memcache.Server>;
    /*
    @brief `pools` field.
varaio.memcache::ShardedClient.pools
Typecollections.Vector<aio.memcache.Pool>
@brief`pools` field.
@detailsHolds the `pools` value for each `ShardedClient` instance. The field type is `collections.Vector<aio.memcache.Pool>`, and constructors and methods keep it synchronized with the object's runtime state.
    var pools: collections.Vector<aio.memcache.Pool>;
    /*
    @brief `hasher` field.
varaio.memcache::ShardedClient.hasher
Typenet.memcache.ConsistentHash
@brief`hasher` field.
@detailsHolds the `hasher` value for each `ShardedClient` instance. The field type is `net.memcache.ConsistentHash`, and constructors and methods keep it synchronized with the object's runtime state.
    var hasher: net.memcache.ConsistentHash;
    /*
    @brief `closed` field.
varaio.memcache::ShardedClient.closed
TypeBool
@brief`closed` field.
@detailsIndicates whether the resource has already been closed. The field type is `Bool`, and it is maintained by the constructors and methods of `ShardedClient`.
    var closed: Bool;
    /*
    @brief `broken` field.