femto libs

import me.bechberger.femtolz4.LZ4FrameOutputStream;
import me.bechberger.femtolz4.LZ4FrameInputStream;
import java.nio.file.Files;
import java.nio.file.Path;

// Compress
try (var out = new LZ4FrameOutputStream(
        Files.newOutputStream(Path.of("data.lz4")))) {
    out.write(myBytes);
}

// Decompress
try (var in = new LZ4FrameInputStream(
        Files.newInputStream(Path.of("data.lz4")))) {
    byte[] restored = in.readAllBytes();
}

new LZ4FrameOutputStream(out)     // level 1 — fastest, good ratio (default)
new LZ4FrameOutputStream(out, 5)  // balanced
new LZ4FrameOutputStream(out, 9)  // best ratio, still fast (LEVEL_MAX / LEVEL_DEFAULT)
new LZ4FrameOutputStream(out, 10) // optimal parser, ~5–10× slower, +1.5–2.6% ratio over 9

try (var in = new LZ4FrameInputStream(rawStream, true)) {
    byte[] frameData = in.readAllBytes();
}
// rawStream is now positioned immediately after the LZ4 end mark

LZ4.Compressor c = LZ4.compressor(LZ4.LEVEL_FAST); // or any level
for (byte[] chunk : chunks) {
    try (var out = new LZ4FrameOutputStream(sink, c)) {
        out.write(chunk);
    }
}

byte[] compressed = LZ4.compress(data);      // level 1 (fastest)
byte[] compressed = LZ4.compressHigh(data);  // level 9 (best ratio)

// Decompress — you must supply the original uncompressed size
byte[] original = LZ4.decompress(compressed, originalSize);

// Pre-allocate a destination buffer
int maxLen = LZ4.maxCompressedLength(data.length);
byte[] dst  = new byte[maxLen];
int len     = LZ4.compress(data, 0, data.length, dst, 0, LZ4.MAX_CHAIN);

@Command(name = "greet", description = "Greet a person")
class GreetCmd implements Callable<Integer> {
    @Option(names = {"-n", "--name"}, description = "Name to greet", required = true)
    String name;

    @Option(names = {"-c", "--count"}, description = "Count (default: ${DEFAULT-VALUE})", defaultValue = "1")
    int count;

    @Override
    public Integer call() {
        for (int i = 0; i < count; i++) System.out.println("Hello, " + name + "!");
        return 0;
    }
}

@Command(name = "myapp", version = "1.0.0", subcommands = {GreetCmd.class})
public class App implements Runnable {
    public void run() {}
    public static void main(String[] args) { FemtoCli.run(new App(), args); }
}

@Command(name = "myapp")
public class App implements Runnable {
    @Command(name = "status", description = "Show status")
    int status() {
        System.out.println("OK");
        return 0;
    }

    @Override
    public void run() {}

    public static void main(String[] args) { FemtoCli.run(new App(), args); }
}

// -javaagent:agent.jar=start,interval=1ms
// -javaagent:agent.jar=stop,output=recording.jfr,verbose
public static void premain(String agentArgs, Instrumentation inst) {
    FemtoCli.builder()
        .alertOnMixedStyleInAgent(true) // warn if user passes --opts instead of ,opts
        .runAgent(new MyAgent(), agentArgs);
}

static class CommonOpts {
    @Option(names = {"-v", "--verbose"})
    boolean verbose;
}

@Command(name = "build")
static class BuildCmd implements Runnable {
    @Mixin CommonOpts common;

    public void run() {
        if (common.verbose) System.out.println("verbose build");
    }
}

@Command(name = "root", subcommands = {Sub.class})
public class Root implements Runnable {
    @Option(names = "--config", defaultValue = "default.conf")
    String config;
    public void run() {}
}

@Command(name = "sub")
static class Sub implements Runnable {
    Spec spec;

    public void run() {
        Root root = spec.getParent(Root.class);
        System.out.println("config: " + root.config);
    }
}

import me.bechberger.util.json.JSONParser;

Map<String, Object> user = (Map<String, Object>)
    JSONParser.parse("{\"name\": \"Alice\", \"age\": 30}");
String name = (String) user.get("name");   // "Alice"
double age  = (Double) user.get("age");    // 30.0

List<Object> tags = (List<Object>)
    JSONParser.parse("[\"java\", \"profiling\"]");

import me.bechberger.util.json.PrettyPrinter;

Object value = JSONParser.parse(rawJson);

// Indented output (2 spaces per level)
String pretty  = PrettyPrinter.prettyPrint(value);

// Single-line output
String compact = PrettyPrinter.compactPrint(value);

import me.bechberger.util.femtoschema.Schemas;
import me.bechberger.util.femtoschema.ValidationResult;

var userSchema = Schemas.object()
    .required("name", Schemas.string().withMinLength(1))
    .required("age",  Schemas.number().withMinimum(0))
    .optional("email", Schemas.string());

ValidationResult r = userSchema.validate(
    Map.of("name", "", "age", -1.0)
);
r.getErrors().forEach(e ->
    System.out.println(e.path() + ": " + e.message())
);
// name: must have minimum length 1
// age: must be >= 0.0

// Enum — only the listed values are valid
var status = Schemas.enumOf("ACTIVE", "INACTIVE", "SUSPENDED");

// Discriminated union — dispatch on the "type" field
var notificationSchema = Schemas.sumType("type")
    .variant("email", Schemas.object()
        .required("type",    Schemas.enumOf("email"))
        .required("address", Schemas.string()))
    .variant("sms", Schemas.object()
        .required("type",        Schemas.enumOf("sms"))
        .required("phoneNumber", Schemas.string()));

notificationSchema.validate(
    Map.of("type", "email", "address", "alice@example.com")
).isValid(); // true

import me.bechberger.util.femtoschema.Schemas;
import me.bechberger.util.femtoschema.TypeSchema;

var schema = Schemas.object()
    .required("name", Schemas.string().withMinLength(1))
    .required("age",  Schemas.number().withMinimum(0));

// Export to JSON string
String json = Schemas.toJsonSchemaString(schema);

// Import back
TypeSchema imported = Schemas.fromJsonSchemaString(json);

<plugin>
  <groupId>me.bechberger</groupId>
  <artifactId>femtojar</artifactId>
  <version>VERSION</version>
  <executions>
    <execution>
      <goals><goal>reencode-jars</goal></goals>
    </execution>
  </executions>
</plugin>

java -jar femtojar-cli.jar app.jar                    # rewrite in place
java -jar femtojar-cli.jar app.jar app-optimized.jar  # write to separate file
java -jar femtojar-cli.jar app.jar app-optimized.jar --compression zopfli
java -jar femtojar-cli.jar app.jar app-optimized.jar --proguard --proguard-config proguard.conf

<configuration>
  <proguard>
    <enabled>true</enabled>
    <!-- optional: add extra keep rules -->
    <options>-dontobfuscate</options>
  </proguard>
</configuration>

<configuration>
  <compressionMode>ZOPFLI</compressionMode>  <!-- or MAX for 100 iterations -->
</configuration>

<configuration>
  <jars>
    <jar>
      <in>myapp-shaded.jar</in>
      <out>myapp-shaded-femto.jar</out>
    </jar>
  </jars>
</configuration>