or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

builder.mdclassfile.mdcollections.mdfunctional.mdindex.mdsignatures.mdstream.md
tile.json

tessl/maven-biz-a-qute-bnd--biz-a-qute-bnd-util

Utility classes for the Bnd toolchain including functional programming constructs, stream utilities, class file manipulation, Java signature parsing, memoization, and immutable collections

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/biz.aQute.bnd/biz.aQute.bnd.util@7.1.x

To install, run

npx @tessl/cli install tessl/maven-biz-a-qute-bnd--biz-a-qute-bnd-util@7.1.0

index.mddocs/

BND Utilities

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.

Package Information

  • Package Name: biz.aQute.bnd.util
  • Package Type: maven
  • Language: Java
  • Installation: 
    <dependency>
  <groupId>biz.aQute.bnd</groupId>
  <artifactId>biz.aQute.bnd.util</artifactId>
  <version>7.1.0</version>
</dependency>

Core Imports

// 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;

Basic Usage

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");

Architecture

The BND Utilities package is organized into six core modules:

  • Class File Processing: Complete Java bytecode manipulation capabilities with full JVM specification compliance
  • Functional Programming: Result monad for exception-safe error handling and function composition
  • Memoization: Advanced caching strategies with configurable eviction policies and resource management
  • Stream Processing: Enhanced stream operations specifically designed for key-value data processing
  • Type Signatures: Complete Java generic signature parsing and resolution system
  • Immutable Collections: High-performance immutable data structures with zero-copy operations

Capabilities

Class File Manipulation

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);
}

Class File Processing

Class File Building

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);
}

Class File Building

Functional Programming

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);
}

Functional Programming

Stream Processing

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);
}

Stream Processing

Type Signature Parsing

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);
}

Type Signature Parsing

Immutable Collections

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);
}

Immutable Collections