* <p>
     * When specified, only the listed types will be available for injection,
     * even if the class implements or extends other types. If empty, the
     * default behavior is to make all supertypes available for injection.
     * <p>
     * Example:
     * <pre>
     * {@literal @}Typed({Service.class, Monitored.class})
     * public class ServiceImpl implements Service, Monitored, Logging {

	buf := make([]byte, 4)
	rb.Read(buf)
	fmt.Println(string(buf))
}
```

It is possible to use an existing buffer with by replacing `New` with `NewBuffer`.


# Blocking vs Non-blocking

The default behavior of the ring buffer is non-blocking, 
meaning that reads and writes will return immediately with an error if the operation cannot be completed.
If you want to block when reading or writing, you must enable it:

```go

import java.util.ListIterator;
import org.jspecify.annotations.Nullable;

/**
 * A list iterator which forwards all its method calls to another list iterator. Subclasses should
 * override one or more methods to modify the behavior of the backing iterator as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class forwards calls to <i>only some</i> {@code

import org.jspecify.annotations.Nullable;

/**
 * A concurrent map which forwards all its method calls to another concurrent map. Subclasses should
 * override one or more methods to modify the behavior of the backing map as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class forwards calls to <i>only some</i> {@code

 *   <li>{@link org.apache.maven.api.cache.RequestCacheFactory} - Factory for creating cache instances</li>
 *   <li>{@link org.apache.maven.api.cache.CacheMetadata} - Configuration for cache behavior and lifecycle</li>
 * </ul>
 * <p>
 * The caching system supports different retention periods through {@link org.apache.maven.api.cache.CacheRetention}:
 * <ul>

                "-a, --all             Apply all upgrades (equivalent to --model-version 4.1.0 --infer --model --plugins)");
        context.unindent();
        context.println();
        context.info("Default behavior: --model and --plugins are applied if no other options are specified");
        context.println();

        return 0;
    }

import java.util.ListIterator;
import org.jspecify.annotations.Nullable;

/**
 * A list iterator which forwards all its method calls to another list iterator. Subclasses should
 * override one or more methods to modify the behavior of the backing iterator as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class forwards calls to <i>only some</i> {@code

   *
   * <p><b>Warning:</b> as with all function types in this package, avoid depending on the specific
   * {@code equals}, {@code hashCode} or {@code toString} behavior of the returned function. A
   * future migration to {@code java.util.function} will not preserve this behavior.
   *
   * <p>As discussed above, prefer to use the method reference {@code Object::toString} instead,

   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Equivalence} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Equivalence} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */

import org.jspecify.annotations.Nullable;

/**
 * A {@link BlockingQueue} which forwards all its method calls to another {@link BlockingQueue}.
 * Subclasses should override one or more methods to modify the behavior of the backing collection
 * as desired per the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator
 * pattern</a>.
 *