# How To - Recipes

Here you will see different recipes or "how to" guides for **several topics**.

Most of these ideas would be more or less **independent**, and in most cases you should only need to study them if they apply directly to **your project**.

If something seems interesting and useful to your project, go ahead and check it, but otherwise, you might probably just skip them.

/// tip

      (
        if (host.startsWith("[") && host.endsWith("]")) {
          decodeIpv6(host, 1, host.length - 1)
        } else {
          decodeIpv6(host, 0, host.length)
        }
      ) ?: return null

    val address = canonicalizeInetAddress(inetAddressByteArray)
    if (address.size == 16) return inet6AddressToAscii(address)
    if (address.size == 4) return inet4AddressToAscii(address) // An IPv4-mapped IPv6 address.

  fun encodeQuery(
    host: String,
    type: Int,
  ): ByteString =
    Buffer().apply {
      writeShort(0) // query id
      writeShort(256) // flags with recursion
      writeShort(1) // question count
      writeShort(0) // answerCount
      writeShort(0) // authorityResourceCount
      writeShort(0) // additional

      val nameBuf = Buffer()
      val labels = host.split('.').dropLastWhile { it.isEmpty() }

        val host = url.host
        return host.substring(1, host.length - 5).lowercase()
      }

      override fun canonicalize(s: String): String = s.lowercase()
    },

    PATH {
      override fun urlString(value: String): String = "http://example.com/a${value}z/"

      override fun encodedValue(url: HttpUrl): String {
        val path = url.encodedPath
        return path.substring(2, path.length - 2)
      }

        return LaRequestUtil.getOptionalRequest().map(req -> {
            for (final Tuple3<String, String, String> host : vHosts) {
                final String headerValue = req.getHeader(host.getValue1());
                if (host.getValue2().equalsIgnoreCase(headerValue)) {
                    return func.apply(host.getValue3());
                }
            }
            return defaultValue;
        }).orElse(defaultValue);
    }

		}
		b.fill() // buffer is empty
	}
	c := b.buf[b.r]
	b.r++
	b.lastByte = int(c)
	return c, nil
}

// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
//
// UnreadByte returns an error if the most recent method called on the
// [Reader] was not a read operation. Notably, [Reader.Peek], [Reader.Discard], and [Reader.WriteTo] are not
// considered read operations.

    `--enforce-node-allocatable=””`
  * Hard Eviction Thresholds will be subtracted from Capacity while calculating
    Node Allocatable. This will result in a reduction of schedulable capacity in
    clusters post upgrade where kubelet hard eviction has been turned on for
    memory. To opt-out set `--experimental-allocatable-ignore-eviction=true`.
  * More details on these feature here:

 *
 * <tr><td width="20%"><code>
 *  smb1://host/share/a/b/
 * </code></td><td width="20%"><code>
 *  c/d/
 * </code></td><td><code>
 *  smb1://host/share/a/b/c/d/
 * </code></td></tr>
 * 
 * <tr><td width="20%"><code>
 *  smb1://host/share/foo/bar/
 * </code></td><td width="20%"><code>
 *  /share2/zig/zag
 * </code></td><td><code>
 *  smb1://host/share2/zig/zag
 * </code></td></tr>
 * 

    }
    public NbtSocket( NbtAddress address, int port ) throws IOException {
        this( address, port, null, 0 );
    }
    public NbtSocket( NbtAddress address, int port,
                                InetAddress localAddr, int localPort ) throws IOException {
        this( address, null, port, localAddr, localPort );
    }
    public NbtSocket( NbtAddress address, String calledName, int port,

	}
	m.handlers.init()
	if ctx == nil {
		ctx = context.Background()
	}

	for _, host := range o.Hosts {
		if host == o.Local {
			if found {
				return nil, fmt.Errorf("grid: local host found multiple times")
			}
			found = true
			// No connection to local.
			continue
		}
		m.targets[host] = newConnection(connectionParams{
			ctx:           ctx,
			id:            m.ID,