Manual

public interface Store {

  DomainType DOMAIN = DomainType.domainType("Store");

  interface City {
    EntityType TYPE = DOMAIN.entityType("store.city"); //(1)

    Column<Integer> ID = TYPE.integerColumn("id"); //(2)
    Column<String> NAME = TYPE.stringColumn("name");
  }

  interface Customer {
    EntityType TYPE = DOMAIN.entityType("store.customer");

    Column<Integer> ID = TYPE.integerColumn("id");
    Column<String> NAME = TYPE.stringColumn("name");
    Column<Integer> CITY_ID = TYPE.integerColumn("city_id");

    ForeignKey CITY_FK = TYPE.foreignKey("city", CITY_ID, City.ID);
  }
}

public static class StoreImpl extends DomainModel {

  public StoreImpl() {
    super(Store.DOMAIN); //(1)
    add(city(), customer());
  }

  EntityDefinition city() {
    return City.TYPE.define(
                    City.ID.define()
                            .primaryKey(),
                    City.NAME.define()
                            .column()
                            .caption("Name")
                            .nullable(false))
            .keyGenerator(KeyGenerator.identity())
            .caption("Cities")
            .build();
  }

  EntityDefinition customer() {
    return Customer.TYPE.define(
                    Customer.ID.define()
                            .primaryKey(),
                    Customer.NAME.define()
                            .column()
                            .caption("Name")
                            .maximumLength(42),
                    Customer.CITY_ID.define()
                            .column(),
                    Customer.CITY_FK.define()
                            .foreignKey()
                            .caption("City"))
            .keyGenerator(KeyGenerator.identity())
            .caption("Customers")
            .build();
  }
}

provides is.codion.framework.domain.Domain
          with is.codion.framework.demos.store.domain.StoreImpl;

is.codion.framework.demos.store.domain.StoreImpl

Domain store = new StoreImpl();

Entities entities = store.entities();

Entity city = entities.builder(City.TYPE)
        .with(City.NAME, "Reykjavík")
        .build();

Entity.Key customerKey = entities.keyBuilder(Customer.TYPE)
        .with(Customer.ID, 42)
        .build();

Entity customer = Entity.builder(customerKey)
        .with(Customer.NAME, "John")
        .with(Customer.CITY_FK, city)
        .build();

EntityDefinition customerDefinition = entities.definition(Customer.TYPE);

EntityDefinition cityDefinition = customerDefinition.foreignKeys().referencedBy(Customer.CITY_FK);

List<Column<?>> cityPrimaryKeyColumns = cityDefinition.primaryKey().columns();

Country.CAPITAL_FK.define()
        .foreignKey()
        .caption("Capital"),

EntityDefinition city() {
  return City.TYPE.define(
                  City.ID.define()
                          .primaryKey(),
                  City.NAME.define()
                          .column()
                          .caption("Name")
                          .searchable(true)
                          .nullable(false)
                          .maximumLength(35),
                  City.COUNTRY_CODE.define()
                          .column()
                          .nullable(false),
                  City.COUNTRY_FK.define()
                          .foreignKey()
                          .caption("Country"),
                  City.DISTRICT.define()
                          .column()
                          .caption("District")
                          .nullable(false)
                          .maximumLength(20),
                  City.POPULATION.define()
                          .column()
                          .caption("Population")
                          .nullable(false)
                          .numberFormatGrouping(true),
                  City.LOCATION.define()
                          .column()
                          .caption("Location")
                          .columnClass(String.class, new LocationConverter())
                          .comparator(new LocationComparator()))
          .keyGenerator(sequence("world.city_seq"))
          .validator(new CityValidator())
          .orderBy(ascending(City.NAME))
          .stringFactory(City.NAME)
          .description("Cities of the World")
          .caption("City")
          .build();
}

return Address.TYPE.define(
                Address.ID.define()
                        .primaryKey(),
                Address.STREET.define()
                        .column()
                        .caption("Street")
                        .nullable(false)
                        .maximumLength(120),
                Address.CITY.define()
                        .column()
                        .caption("City")
                        .nullable(false)
                        .maximumLength(50),
                Address.VALID.define()
                        .column()
                        .caption("Valid")
                        .columnHasDefaultValue(true)
                        .defaultValue(true)
                        .nullable(false))
        .stringFactory(StringFactory.builder()
                .value(Address.STREET)
                .text(", ")
                .value(Address.CITY)
                .build())
        .keyGenerator(identity())
        .smallDataset(true)
        .caption("Address")
        .build();

.stringFactory(new CustomerToString())

private static final class CustomerToString implements Function<Entity, String>, Serializable {

  @Serial
  private static final long serialVersionUID = 1;

  @Override
  public String apply(Entity customer) {
    StringBuilder builder =
            new StringBuilder(customer.get(Customer.LAST_NAME))
                    .append(", ")
                    .append(customer.get(Customer.FIRST_NAME));
    if (customer.isNotNull(Customer.EMAIL)) {
      builder.append(" <")
              .append(customer.get(Customer.EMAIL))
              .append(">");
    }

    return builder.toString();
  }
}

final class CityValidator extends DefaultEntityValidator implements Serializable {

  @Serial
  private static final long serialVersionUID = 1;

  @Override
  public void validate(Entity city) throws ValidationException {
    super.validate(city);
    //after a call to super.validate() values that are not nullable
    //(such as country and population) are guaranteed to be non-null
    Entity country = city.get(City.COUNTRY_FK);
    Integer cityPopulation = city.get(City.POPULATION);
    Integer countryPopulation = country.get(Country.POPULATION);
    if (countryPopulation != null && cityPopulation > countryPopulation) {
      throw new ValidationException(City.POPULATION,
              cityPopulation, "City population can not exceed country population");
    }
  }
}

.validator(new CityValidator())

Column<Location> LOCATION = TYPE.column("location", Location.class);

record Location(double latitude, double longitude) implements Serializable {

  @Override
  public String toString() {
    return "[" + latitude + "," + longitude + "]";
  }
}

City.LOCATION.define()
        .column()
        .caption("Location")
        .columnClass(String.class, new LocationConverter())
        .comparator(new LocationComparator()))

private static final class LocationConverter implements Converter<Location, String> {

  @Override
  public String toColumnValue(Location location,
                              Statement statement) {
    return "POINT (" + location.longitude() + " " + location.latitude() + ")";
  }

  @Override
  public Location fromColumnValue(String columnValue) {
    String[] latLon = columnValue
            .replace("POINT (", "")
            .replace(")", "")
            .split(" ");

    return new Location(parseDouble(latLon[1]), parseDouble(latLon[0]));
  }
}

public final class WorldObjectMapperFactory extends DefaultEntityObjectMapperFactory {

  private static final String LATITUDE = "latitude";
  private static final String LONGITUDE = "longitude";

  public WorldObjectMapperFactory() {
    super(World.DOMAIN);
  }

  @Override
  public EntityObjectMapper entityObjectMapper(Entities entities) {
    EntityObjectMapper objectMapper = super.entityObjectMapper(entities);
    objectMapper.addSerializer(Location.class, new LocationSerializer());
    objectMapper.addDeserializer(Location.class, new LocationDeserializer());

    return objectMapper;
  }

  private static final class LocationSerializer extends StdSerializer<Location> {

    private LocationSerializer() {
      super(Location.class);
    }

    @Override
    public void serialize(Location location, JsonGenerator generator, SerializerProvider provider) throws IOException {
      generator.writeStartObject();
      generator.writeNumberField(LATITUDE, location.latitude());
      generator.writeNumberField(LONGITUDE, location.longitude());
      generator.writeEndObject();
    }
  }

  private static final class LocationDeserializer extends StdDeserializer<Location> {

    private LocationDeserializer() {
      super(Location.class);
    }

    @Override
    public Location deserialize(JsonParser parser, DeserializationContext ctxt) throws IOException, JacksonException {
      JsonNode node = parser.getCodec().readTree(parser);

      return new Location(node.get(LATITUDE).asDouble(), node.get(LONGITUDE).asDouble());
    }
  }
}

  provides is.codion.framework.json.domain.EntityObjectMapperFactory
          with is.codion.framework.demos.world.domain.api.WorldObjectMapperFactory;

EntityConnectionProvider connectionProvider = EntityConnectionProvider.builder()
        .domainType(Petstore.DOMAIN)
        .clientTypeId("Manual")
        .user(User.parse("scott:tiger"))
        .build();

Entities entities = connectionProvider.entities();

EntityConnection connection = connectionProvider.connection();

//populate a new category
Entity insects = entities.builder(Category.TYPE)
        .with(Category.NAME, "Insects")
        .with(Category.DESCRIPTION, "Creepy crawlies")
        .build();

insects = connection.insertSelect(insects);

//populate a new product for the insect category
Entity smallBeetles = entities.builder(Product.TYPE)
        .with(Product.CATEGORY_FK, insects)
        .with(Product.NAME, "Small Beetles")
        .with(Product.DESCRIPTION, "Beetles on the smaller side")
        .build();

connection.insert(smallBeetles);

//see what products are available for the Cats category
Entity categoryCats = connection.selectSingle(Category.NAME.equalTo("Cats"));

List<Entity> cats = connection.select(Product.CATEGORY_FK.equalTo(categoryCats));

cats.forEach(System.out::println);

Condition liveAlbums =
        Album.TITLE.like("Live%");

Entity metallica = selectArtist("Metallica");

Condition metallicaAlbums =
        Album.ARTIST_FK.equalTo(metallica);

Condition allArtistsCondition =
        Condition.all(Artist.TYPE);

Condition liveMetallicaAlbumsCondition =
        Condition.and(liveAlbums, metallicaAlbums);

Select selectLiveMetallicaAlbums =
        Select.where(liveMetallicaAlbumsCondition)
                .orderBy(OrderBy.descending(Album.NUMBER_OF_TRACKS))
                .build();

Update removeLiveMetallicaAlbumCovers =
        Update.where(liveMetallicaAlbumsCondition)
                .set(Album.COVER, null)
                .build();

codion.db.limitForeignKeyFetchDepth=false

LocalEntityConnection.LIMIT_FOREIGN_KEY_FETCH_DEPTH.set(false);

connection.setLimitForeignKeyFetchDepth(false);

InvoiceLine.INVOICE_FK.define()
        .foreignKey(0)
        .hidden(true),

Track.ALBUM_FK.define()
        .foreignKey(2)
        .attributes(Album.ARTIST_FK, Album.TITLE),

EntityConnection connection = connectionProvider.connection();

List<Entity> tracks = connection.select(
        Track.NAME.like("Bad%"));

Entity track = tracks.get(0);

Entity genre = track.get(Track.GENRE_FK);
Entity mediaType = track.get(Track.MEDIATYPE_FK);
Entity album = track.get(Track.ALBUM_FK);

// fetch depth for Track.ALBUM_FK is 2, which means two levels of
// references are fetched, so we have the artist here as well
Entity artist = album.get(Album.ARTIST_FK);

EntityConnection connection = connectionProvider.connection();

List<Entity> tracks = connection.select(
        Select.where(Track.NAME.like("Bad%"))
                .fetchDepth(0)
                .build());

Entity track = tracks.get(0);

// fetch depth is 0, so this 'genre' instance is null
Entity genre = track.get(Track.GENRE_FK);

// using track.entity(Track.GENRE_FK) you get a 'genre'
// instance containing only the primary key, since the condition
// fetch depth limit prevented it from being selected
genre = track.entity(Track.GENRE_FK);

EntityConnection connection = connectionProvider.connection();

List<Entity> tracks = connection.select(
        Select.where(Track.NAME.like("Bad%"))
                .fetchDepth(Track.ALBUM_FK, 0)
                .build());

Entity track = tracks.get(0);

Entity genre = track.get(Track.GENRE_FK);
Entity mediaType = track.get(Track.MEDIATYPE_FK);

// this 'album' instance is null, since the condition
// fetch depth limit prevented it from being selected
Entity album = track.get(Track.ALBUM_FK);

// using track.entity(Track.ALBUM_FK) you get a 'album'
// instance containing only the primary key, since the condition
// fetch depth limit prevented it from being selected
album = track.entity(Track.ALBUM_FK);

Database.DATABASE_URL.set("jdbc:h2:mem:h2db");
Database.DATABASE_INIT_SCRIPTS.set("src/main/sql/create_schema.sql");

LocalEntityConnectionProvider connectionProvider =
        LocalEntityConnectionProvider.builder()
                .domain(new ChinookImpl())
                .user(User.parse("scott:tiger"))
                .build();

LocalEntityConnection entityConnection =
        connectionProvider.connection();

DatabaseConnection databaseConnection =
        entityConnection.databaseConnection();

// the underlying JDBC connection is available in a local connection
Connection connection = databaseConnection.getConnection();

connectionProvider.close();

RemoteEntityConnectionProvider connectionProvider =
        RemoteEntityConnectionProvider.builder()
                .domainType(Chinook.DOMAIN)
                .user(User.parse("scott:tiger"))
                .clientTypeId(EntityConnectionProviderDemo.class.getSimpleName())
                .hostName("localhost")
                .registryPort(1099)
                .build();

EntityConnection entityConnection =
        connectionProvider.connection();

Entities entities = entityConnection.entities();

Entity track = entityConnection.select(entities.primaryKey(Track.TYPE, 42L));

connectionProvider.close();

HttpEntityConnectionProvider connectionProvider =
        HttpEntityConnectionProvider.builder()
                .domainType(Chinook.DOMAIN)
                .clientTypeId(EntityConnectionProviderDemo.class.getSimpleName())
                .user(User.parse("scott:tiger"))
                .hostName("localhost")
                .port(8080)
                .https(false)
                .build();

EntityConnection entityConnection = connectionProvider.connection();

Entities entities = entityConnection.entities();

entityConnection.select(entities.primaryKey(Track.TYPE, 42L));

connectionProvider.close();

public class CustomerTableModel extends SwingEntityTableModel {

  public CustomerTableModel(EntityConnectionProvider connectionProvider) {
    super(new CustomerEditModel(connectionProvider));
  }
}

public class CustomerEditModel extends SwingEntityEditModel {

  public CustomerEditModel(EntityConnectionProvider connectionProvider) {
    super(Customer.TYPE, connectionProvider);
  }
}

public class StoreApplicationModel extends SwingEntityApplicationModel {

  public StoreApplicationModel(EntityConnectionProvider connectionProvider) {
    super(connectionProvider);

    CustomerModel customerModel = new CustomerModel(connectionProvider);
    CustomerAddressModel customerAddressModel = new CustomerAddressModel(connectionProvider);

    customerModel.addDetailModel(customerAddressModel);

    //populate the model with rows from the database
    customerModel.tableModel().refresh();

    addEntityModel(customerModel);
  }
}

public class CustomerModel extends SwingEntityModel {

  public CustomerModel(EntityConnectionProvider connectionProvider) {
    super(new CustomerTableModel(connectionProvider));
    bindEvents();
  }

  private void bindEvents() {
    tableModel().refresher().observer().addConsumer(refreshing -> {
      if (refreshing) {
        System.out.println("Refresh is about to start");
      }
      else {
        System.out.println("Refresh is about to end");
      }
    });

    editModel().value(Customer.FIRST_NAME).addConsumer(value ->
            System.out.println("First name changed to " + value));
  }
}

public class AddressPanel extends EntityPanel {

  public AddressPanel(SwingEntityModel addressModel) {
    super(addressModel, new AddressEditPanel(addressModel.editModel()));
  }
}

SwingEntityModel addressModel =
        new SwingEntityModel(Address.TYPE, connectionProvider);

EntityPanel addressPanel =
        new EntityPanel(addressModel,
                new AddressEditPanel(addressModel.editModel()));

public class CustomerPanel extends EntityPanel {

  public CustomerPanel(SwingEntityModel entityModel) {
    super(entityModel);
    SwingEntityModel addressModel =
            entityModel.detailModel(Address.TYPE);
    addDetailPanel(new AddressPanel(addressModel));
  }
}

createTextField(Customer.FIRST_NAME)
        .columns(12);

setLayout(gridLayout(1, 1));
addInputPanel(Customer.FIRST_NAME);

ColumnDefinition<String> firstNameDefinition =
        editModel().entityDefinition().columns().definition(Customer.FIRST_NAME);

//create the text field
JTextField firstNameField = new JTextField();
firstNameField.setColumns(12);
firstNameField.setToolTipText(firstNameDefinition.description());
//associate the text field with the first name attribute
component(Customer.FIRST_NAME).set(firstNameField);

//wrap the text field in a ComponentValue
ComponentValue<String, JTextField> firstNameFieldValue =
        new AbstractTextComponentValue<String, JTextField>(firstNameField) {
          @Override
          protected String getComponentValue() {
            return component().getText();
          }

          @Override
          protected void setComponentValue(String text) {
            component().setText(text);
          }
        };

//link the component value to the attribute value in the edit model
firstNameFieldValue.link(editModel().value(Customer.FIRST_NAME));

//create the first name label
JLabel firstNameLabel = new JLabel(firstNameDefinition.caption());
//associate the label with the text field
firstNameLabel.setLabelFor(firstNameField);

//create an input panel, with the label and text field
JPanel firstNamePanel = new JPanel(borderLayout());
firstNamePanel.add(firstNameLabel, BorderLayout.NORTH);
firstNamePanel.add(firstNameField, BorderLayout.CENTER);

setLayout(gridLayout(1, 1));
add(firstNamePanel);

JLabel label = createLabel(Demo.TEXT)
        .build();

JPanel inputPanel = createInputPanel(Demo.TEXT);

public class CustomerTablePanel extends EntityTablePanel {

  public CustomerTablePanel(SwingEntityTableModel tableModel) {
    super(tableModel);
    // associate a custom Control with the PRINT control key,
    // which calls the viewCustomerReport method in this class,
    // enabled only when the selection is not empty
    control(PRINT).set(Control.builder()
            .command(this::viewCustomerReport)
            .name("Customer report")
            .smallIcon(FrameworkIcons.instance().print())
            .enabled(tableModel().selection().empty().not())
            .build());
  }

  private void viewCustomerReport() throws Exception {
    List<Entity> selectedCustomers = tableModel().selection().items().get();
    if (selectedCustomers.isEmpty()) {
      return;
    }

    Collection<String> customerIds = Entity.values(Customer.ID, selectedCustomers);
    Map<String, Object> reportParameters = new HashMap<>();
    reportParameters.put("CUSTOMER_IDS", customerIds);

    JasperPrint customerReport = tableModel().connection()
            .report(Customer.REPORT, reportParameters);

    Dialogs.componentDialog(new JRViewer(customerReport))
            .owner(this)
            .modal(false)
            .title("Customer Report")
            .size(new Dimension(800, 600))
            .show();
  }
}

public class CustomerTablePanel extends EntityTablePanel {

  public CustomerTablePanel(SwingEntityTableModel tableModel) {
    super(tableModel);
    // associate a custom Control with the PRINT control key,
    // which calls the viewCustomerReport method in this class,
    // enabled only when the selection is not empty
    control(PRINT).set(Control.builder()
            .command(this::viewCustomerReport)
            .name("Customer report")
            .smallIcon(FrameworkIcons.instance().print())
            .enabled(tableModel().selection().empty().not())
            .build());
  }

  private void viewCustomerReport() throws Exception {
    List<Entity> selectedCustomers = tableModel().selection().items().get();
    if (selectedCustomers.isEmpty()) {
      return;
    }

    Collection<String> customerIds = Entity.values(Customer.ID, selectedCustomers);
    Map<String, Object> reportParameters = new HashMap<>();
    reportParameters.put("CUSTOMER_IDS", customerIds);

    JasperPrint customerReport = tableModel().connection()
            .report(Customer.REPORT, reportParameters);

    Dialogs.componentDialog(new JRViewer(customerReport))
            .owner(this)
            .modal(false)
            .title("Customer Report")
            .size(new Dimension(800, 600))
            .show();
  }
}

EntityConnection connection = connectionProvider.connection();

EntityDefinition customerDefinition =
        connection.entities().definition(Customer.TYPE);

Iterator<Entity> customerIterator =
        connection.select(all(Customer.TYPE)).iterator();

JasperReportsDataSource<Entity> dataSource =
        new JasperReportsDataSource<>(customerIterator,
                (entity, reportField) ->
                        entity.get(customerDefinition.attributes().get(reportField.getName())));

JRReport customerReport = fileReport("reports/customer.jasper");

JasperPrint jasperPrint = JasperReports.fillReport(customerReport, dataSource);

// specify an event propagating
// a String as the event data
Event<String> event = Event.event();

// an observer manages the listeners
// for an Event but can not trigger it
Observer<String> observer = event.observer();

// add a listener if you're not
// interested in the event data
observer.addListener(() -> System.out.println("Event occurred"));

event.run();//output: 'Event occurred'

// or a consumer if you're
// interested in the event data
observer.addConsumer(data -> System.out.println("Event: " + data));

event.accept("info");//output: 'Event: info'

// Event implements Observer so
// listeneres can be added directly without
// referring to the Observer
event.addConsumer(System.out::println);

// a nullable value with 2 as the initial value
Value<Integer> value =
        Value.value(2);

value.set(4);

// a non-null value using 0 as null replacement
Value<Integer> otherValue =
        Value.builder()
                .nonNull(0)
                // linked to the value above
                .link(value)
                .build();

System.out.println(otherValue.get());// output: 4

otherValue.set(3);

System.out.println(value.get());// output: 3

value.addConsumer(System.out::println);

otherValue.addListener(() ->
        System.out.println("Value changed: " + otherValue.get()));

Integer initialValue = 42;
Integer nullValue = 0;

Value<Integer> value =
        Value.builder()
                .nonNull(nullValue)
                .value(initialValue)
                .build();

System.out.println(value.nullable());//output: false

System.out.println(value.get());// output: 42

value.set(null); //or value.clear();

System.out.println(value.get());//output: 0

// a boolean state, false by default
State state = State.state();

// an observer manages the listeners for a State but can not modify it
StateObserver observer = state.observer();
// a not observer is always available, which is
// always the reverse of the original state
StateObserver not = state.not();

// add a listener notified each time the state changes
observer.addListener(() -> System.out.println("State changed"));

state.set(true);//output: 'State changed'

observer.addConsumer(value -> System.out.println("State: " + value));

state.set(null);//output: 'State: false'

// State extends StateObserver so listeners can be added
// directly without referring to the StateObserver
state.addListener(() -> System.out.println("State changed"));

private static final class IntegerValue {

  private final State negative = State.state(false);
  private final Value<Integer> integer = Value.builder()
          .nonNull(0)
          .consumer(value -> negative.set(value < 0))
          .build();

  /**
   * Increment the value by one
   */
  public void increment() {
    integer.map(value -> value + 1);
  }

  /**
   * Decrement the value by one
   */
  public void decrement() {
    integer.map(value -> value - 1);
  }

  /**
   * @return an observer notified each time the value changes
   */
  public Observer<Integer> changed() {
    return integer.observer();
  }

  /**
   * @return a state observer indicating whether the value is negative
   */
  public StateObserver negative() {
    return negative.observer();
  }
}

State state = State.state();

Action action = new AbstractAction("action") {
  @Override
  public void actionPerformed(ActionEvent e) {
    System.out.println("Hello Action");
  }
};

Utilities.linkToEnabledState(state, action);

System.out.println(action.isEnabled());// output: false

state.set(true);

System.out.println(action.isEnabled());// output: true

State state = State.state();

CommandControl control = Control.builder()
        .command(() -> System.out.println("Hello Control"))
        .enabled(state)
        .build();

System.out.println(control.isEnabled());// output: false

state.set(true);

System.out.println(control.isEnabled());// output: true

System.setProperty("codion.db.url", "jdbc:h2:mem:h2db");

Database database = Database.instance();

Database.DATABASE_URL.set("jdbc:h2:mem:h2db");

Database database = Database.instance();

String url = "jdbc:h2:mem:h2db";

DatabaseFactory databaseFactory = DatabaseFactory.instance(url);

Database database = databaseFactory.create(url);

String url = "jdbc:h2:mem:h2db";

H2DatabaseFactory databaseFactory = new H2DatabaseFactory();

Database database = databaseFactory.create(url);

Database.DATABASE_URL.set("jdbc:h2:mem:h2db");

Database database = Database.instance();

User user = User.parse("scott:tiger");

java.sql.Connection connection = database.createConnection(user);

Database.DATABASE_URL.set("jdbc:h2:mem:h2db");

Database database = Database.instance();

User user = User.parse("scott:tiger");

DatabaseConnection databaseConnection =
        DatabaseConnection.databaseConnection(database, user);

databaseConnection.startTransaction();
try {
  java.sql.Connection connection = databaseConnection.getConnection();
  connection.createStatement().execute("select 1");
  databaseConnection.commitTransaction();
}
catch (SQLException e) {
  databaseConnection.rollbackTransaction();
  throw new DatabaseException(e);
}
catch (Exception e) {
  databaseConnection.rollbackTransaction();
  throw new RuntimeException(e);
}

databaseConnection.close();

// Define a record representing the table rows
public record Person(String name, int age) {}

// Define an enum identifying the table columns
public enum PersonColumn {
  NAME,
  AGE
}

// Implement Columns, specifying the table columns
public static final class PersonColumns implements Columns<Person, PersonColumn> {

  private static final List<PersonColumn> COLUMNS = List.of(PersonColumn.values());

  @Override
  public List<PersonColumn> identifiers() {
    return COLUMNS;
  }

  @Override
  public Class<?> columnClass(PersonColumn column) {
    return switch (column) {
      case NAME -> String.class;
      case AGE -> Integer.class;
    };
  }

  @Override
  public Object value(Person person, PersonColumn column) {
    return switch (column) {
      case NAME -> person.name();
      case AGE -> person.age();
    };
  }
}

public static FilterTableModel<Person, PersonColumn> createFilterTableModel() {
  // Implement an item supplier responsible for supplying
  // the table items when the table data is refreshed.
  // Without one the table can be populated by adding items manually
  Supplier<Collection<Person>> supplier = () -> List.of(
          new Person("John", 42),
          new Person("Mary", 43));

  // Create the table model
  FilterTableModel<Person, PersonColumn> tableModel =
          FilterTableModel.builder(new PersonColumns())
                  .supplier(supplier)
                  .build();

  // Populate the model
  tableModel.refresh();

  // Select the first row
  tableModel.selection().index().set(0);

  return tableModel;
}

// See FilterTableModel example
FilterTableModel<Person, PersonColumn> tableModel = createFilterTableModel();

List<FilterTableColumn<PersonColumn>> columns = List.of(
        FilterTableColumn.builder(PersonColumn.NAME)
                .headerValue("Name")
                .build(),
        FilterTableColumn.builder(PersonColumn.AGE)
                .headerValue("Age")
                .build());

FilterTable<Person, PersonColumn> filterTable = FilterTable.builder(tableModel, columns)
        .doubleClickAction(Control.command(() ->
                tableModel.selection().item().optional()
                        .ifPresent(System.out::println)))
        .autoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
        .build();

// Search for the value "43" in the table
FilterTableSearchModel searchModel = filterTable.searchModel();
searchModel.predicate().set(value -> value.equals("43"));

FilterTableSearchModel.RowColumn searchResult = searchModel.currentResult().get();
System.out.println(searchResult); // row: 1, column: 1

State somethingEnabledState = State.state(true);

CommandControl control = Control.builder()
        .command(() -> System.out.println("Doing something"))
        .name("Do something")
        .mnemonic('D')
        .enabled(somethingEnabledState)
        .build();

JButton somethingButton = new JButton(control);

Control.ActionCommand actionCommand = actionEvent -> {
  if ((actionEvent.getModifiers() & ActionEvent.SHIFT_MASK) != 0) {
    System.out.println("Doing something else");
  }
};
CommandControl actionControl = Control.builder()
        .action(actionCommand)
        .name("Do something else")
        .mnemonic('S')
        .build();

JButton somethingElseButton = new JButton(actionControl);

State state = State.state();

ToggleControl toggleStateControl = Control.builder()
        .toggle(state)
        .build();

JToggleButton toggleButton = Components.toggleButton()
        .toggleControl(toggleStateControl)
        .text("Change state")
        .mnemonic('C')
        .build();

Value<Boolean> booleanValue = Value.builder()
        .nonNull(false)
        .build();

ToggleControl toggleValueControl = Control.builder()
        .toggle(booleanValue)
        .build();

JCheckBox checkBox = Components.checkBox()
        .toggleControl(toggleValueControl)
        .text("Change value")
        .mnemonic('V')
        .build();

Controls controls = Controls.builder()
        .control(Control.builder()
                .command(this::doFirst)
                .name("First")
                .mnemonic('F'))
        .control(Control.builder()
                .command(this::doSecond)
                .name("Second")
                .mnemonic('S'))
        .control(Controls.builder()
                .name("Submenu")
                .control(Control.builder()
                        .command(this::doSubFirst)
                        .name("Sub-first")
                        .mnemonic('b'))
                .control(Control.builder()
                        .command(this::doSubSecond)
                        .name("Sub-second")
                        .mnemonic('u')))
        .build();

JMenu menu = Components.menu(controls).build();

Control firstControl = Control.builder()
        .command(this::doFirst)
        .name("First")
        .mnemonic('F')
        .build();
Control secondControl = Control.builder()
        .command(this::doSecond)
        .name("Second")
        .mnemonic('S')
        .build();

Controls twoControls = Controls.builder()
        .controls(firstControl, secondControl)
        .build();

JPanel buttonPanel = Components.buttonPanel(twoControls).build();