The BND Utilities package (biz.aQute.bnd.util) provides comprehensive utility classes for the BND OSGi toolchain. It offers essential building blocks for Java bytecode manipulation, functional programming constructs, type signature parsing, stream processing, memoization, and immutable collections - all designed for maximum reusability across OSGi bundle development, build tooling, and enterprise Java applications.
<dependency>
<groupId>biz.aQute.bnd</groupId>
<artifactId>biz.aQute.bnd.util</artifactId>
<version>7.1.0</version>
</dependency>// Class file manipulation
import aQute.bnd.classfile.ClassFile;
import aQute.bnd.classfile.ConstantPool;
import aQute.bnd.classfile.builder.ClassFileBuilder;
// Functional programming
import aQute.bnd.result.Result;
import aQute.bnd.memoize.Memoize;
// Stream utilities
import aQute.bnd.stream.MapStream;
// Immutable collections
import aQute.bnd.unmodifiable.Lists;
import aQute.bnd.unmodifiable.Maps;
import aQute.bnd.unmodifiable.Sets;
// Signature parsing
import aQute.bnd.signatures.ClassSignature;
import aQute.bnd.signatures.MethodSignature;import aQute.bnd.classfile.ClassFile;
import aQute.bnd.result.Result;
import aQute.bnd.memoize.Memoize;
import aQute.bnd.stream.MapStream;
import aQute.bnd.unmodifiable.Lists;
// Parse class file
ClassFile classFile = ClassFile.parseClassFile(inputStream);
System.out.println("Class: " + classFile.this_class);
// Use Result for error handling
Result<String> result = Result.ok("success");
String value = result.orElse("default");
// Memoize expensive computations
Memoize<String> memoized = Memoize.supplier(() -> expensiveComputation());
String cached = memoized.get(); // Computed once, cached thereafter
// Process key-value streams
Map<String, Integer> counts = MapStream.of(data)
.filterValue(v -> v > 0)
.mapValue(v -> v * 2)
.collect(MapStream.toMap());
// Create immutable collections
List<String> items = Lists.of("a", "b", "c");The BND Utilities package is organized into six core modules:
Complete Java class file parsing, manipulation, and generation with full support for all JVM bytecode features including modules, records, sealed classes, and type annotations.
public class ClassFile extends ElementInfo {
public static ClassFile parseClassFile(DataInput in) throws IOException;
public void write(DataOutput out) throws IOException;
public byte[] write() throws IOException;
}
public class ConstantPool {
public int size();
public <T> T entry(int index);
public String utf8(int utf8_index);
public String className(int class_info_index);
}Programmatic construction of Java class files using fluent builder patterns with support for all bytecode features, modules, and reflection-based generation.
public class ClassFileBuilder {
public ClassFileBuilder(int access_flags, int major_version, int minor_version, String this_class, String super_class, String... interfaces);
public ClassFileBuilder(ClassFile classFile);
public ClassFileBuilder access(int access);
public ClassFileBuilder addField(FieldInfo field);
public ClassFileBuilder addMethod(MethodInfo method);
public ClassFile build();
}
public class ModuleInfoBuilder extends ClassFileBuilder {
public ModuleInfoBuilder(int major_version, int minor_version, String module_name);
public ModuleInfoBuilder requires(String module, int flags);
public ModuleInfoBuilder exports(String pkg, String... to);
public ModuleInfoBuilder provides(String service, String... providers);
}
public static class ReflectBuilder {
public static ClassFileBuilder fromClass(Class<?> clazz);
}Exception-safe functional programming constructs including Result monad for error handling and memoization utilities for performance optimization.
public interface Result<V> {
static <V> Result<V> ok(V value);
static <V> Result<V> err(CharSequence error);
boolean isOk();
boolean isErr();
V unwrap();
V orElse(V orElse);
<U> Result<U> map(FunctionWithException<? super V, ? extends U> mapper);
<U> Result<U> flatMap(FunctionWithException<? super V, ? extends Result<? extends U>> mapper);
}
public interface Memoize<S> extends Supplier<S> {
static <T> Memoize<T> supplier(Supplier<? extends T> supplier);
S peek();
boolean isPresent();
<R> Memoize<R> map(Function<? super S, ? extends R> mapper);
}Advanced stream operations for key-value data processing with MapStream interface providing specialized operations for Map-like data structures.
public interface MapStream<K, V> extends BaseStream<Entry<K, V>, MapStream<K, V>> {
static <K, V> MapStream<K, V> of(Map<? extends K, ? extends V> map);
static <K, V> MapStream<K, V> empty();
Stream<K> keys();
Stream<V> values();
MapStream<K, V> filterKey(Predicate<? super K> predicate);
MapStream<K, V> filterValue(Predicate<? super V> predicate);
<R> MapStream<K, R> mapValue(Function<? super V, ? extends R> mapper);
<R> MapStream<R, V> mapKey(Function<? super K, ? extends R> mapper);
}Complete Java generic signature parsing and resolution system supporting all aspects of the Java generic type system including wildcards, bounds, and complex type hierarchies.
public class ClassSignature implements Signature {
public final TypeParameter[] typeParameters;
public final ClassTypeSignature superClass;
public final ClassTypeSignature[] superInterfaces;
public static ClassSignature of(String signature);
}
public class MethodSignature implements Signature {
public final TypeParameter[] typeParameters;
public final JavaTypeSignature[] parameterTypes;
public final Result resultType;
public final ThrowsSignature[] throwTypes;
public static MethodSignature of(String signature);
}High-performance immutable collection implementations providing List, Set, and Map variants with efficient copy-on-write semantics and builder patterns.
public class Lists {
public static <E> List<E> of();
public static <E> List<E> of(E e1);
public static <E> List<E> of(E... elements);
public static <E> List<E> copyOf(Collection<? extends E> collection);
public static <E> Collector<E, ?, List<E>> toList();
}
public class Maps {
public static <K, V> Map<K, V> of();
public static <K, V> Map<K, V> of(K k1, V v1);
public static <K, V> Map<K, V> copyOf(Map<? extends K, ? extends V> map);
}