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 DefaultDomain {

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

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

  void customer() {
    add(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"));
  }
}

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

void city() {
  add(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)
          .foregroundColorProvider(new CityColorProvider())
          .description("Cities of the World")
          .caption("City"));
}

add(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)
                .nullable(false))
        .stringFactory(StringFactory.builder()
                .value(Address.STREET)
                .text(", ")
                .value(Address.CITY)
                .build())
        .keyGenerator(identity())
        .smallDataset(true)
        .caption("Address"));

.stringFactory(new CustomerToString())

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

  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 CityColorProvider implements ColorProvider {

  private static final long serialVersionUID = 1;

  private static final String YELLOW = "#ffff00";
  private static final String GREEN = "#00ff00";

  @Override
  public Object color(Entity cityEntity, Attribute<?> attribute) {
    if (attribute.equals(City.POPULATION) &&
            cityEntity.get(City.POPULATION) > 1_000_000) {
      return YELLOW;
    }
    City city = cityEntity.castTo(City.class);
    if (attribute.equals(City.NAME) && city.capital()) {
      return GREEN;
    }

    return null;
  }
}

.foregroundColorProvider(new CityColorProvider())

final class CityValidator extends DefaultEntityValidator implements Serializable {

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

final class Location implements Serializable {

  private static final long serialVersionUID = 1;

  private final double latitude;
  private final double longitude;

  public Location(double latitude, double longitude) {
    this.latitude = latitude;
    this.longitude = longitude;
  }

  public double latitude() {
    return latitude;
  }

  public double longitude() {
    return longitude;
  }

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

  @Override
  public boolean equals(Object other) {
    if (this == other) {
      return true;
    }
    if (other == null || getClass() != other.getClass()) {
      return false;
    }
    Location location = (Location) other;

    return Double.compare(location.latitude, latitude) == 0
            && Double.compare(location.longitude, longitude) == 0;
  }

  @Override
  public int hashCode() {
    return Objects.hash(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) {
    if (location == null) {
      return null;
    }

    return "POINT (" + location.longitude() + " " + location.latitude() + ")";
  }

  @Override
  public Location fromColumnValue(String columnValue) {
    if (columnValue == null) {
      return null;
    }

    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),

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.referencedEntity(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.referencedEntity(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.referencedEntity(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.referencedEntity(Track.ALBUM_FK);

EntityConnection connection = connectionProvider.connection();

Entities entities = connection.entities();

connection.beginTransaction();
try {
  Entity artist = entities.builder(Artist.TYPE)
          .with(Artist.NAME, "The Band")
          .build();
  connection.insert(artist);

  Entity album = entities.builder(Album.TYPE)
          .with(Album.ARTIST_FK, artist)
          .with(Album.TITLE, "The Album")
          .build();
  connection.insert(album);

  connection.commitTransaction();
}
catch (DatabaseException e) {
  connection.rollbackTransaction();
  throw e;
}
catch (Exception e) {
  connection.rollbackTransaction();
  throw new RuntimeException(e);
}

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().addDataListener(refreshing -> {
      if (refreshing) {
        System.out.println("Refresh is about to start");
      }
      else {
        System.out.println("Refresh is about to end");
      }
    });

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

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 code,
    // which calls the viewCustomerReport method in this class,
    // enabled only when the selection is not empty
    control(TableControl.PRINT).set(Control.builder(this::viewCustomerReport)
            .name("Customer report")
            .smallIcon(FrameworkIcons.instance().print())
            .enabled(tableModel().selectionModel().selectionNotEmpty())
            .build());
  }

  private void viewCustomerReport() throws Exception {
    List<Entity> selectedCustomers = tableModel().selectionModel().getSelectedItems();
    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().connectionProvider().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 code,
    // which calls the viewCustomerReport method in this class,
    // enabled only when the selection is not empty
    control(TableControl.PRINT).set(Control.builder(this::viewCustomerReport)
            .name("Customer report")
            .smallIcon(FrameworkIcons.instance().print())
            .enabled(tableModel().selectionModel().selectionNotEmpty())
            .build());
  }

  private void viewCustomerReport() throws Exception {
    List<Entity> selectedCustomers = tableModel().selectionModel().getSelectedItems();
    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().connectionProvider().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);

Event<String> event = Event.event();

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

// add a listener notified each time the event occurs
observer.addListener(() -> System.out.println("Event occurred"));

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

// data can be propagated by adding a Consumer as listener
observer.addDataListener(data -> System.out.println("Event: " + data));

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

// Event implements EventObserver so listeneres can be added
// directly without referring to the EventObserver
event.addListener(() -> System.out.println("Event"));

Value<Integer> value = Value.value();

value.set(2);

Value<Integer> otherValue = Value.value();

otherValue.link(value);

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

otherValue.set(3);

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

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

Integer initialValue = 42;
Integer nullValue = 0;

Value<Integer> value = Value.value(initialValue, nullValue);

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

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

value.set(null);

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

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

// an observer handles the listeners for a State but can not modify it
StateObserver observer = state.observer();
// a not observer is always available
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.addDataListener(value -> System.out.println("State: " + value));

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

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

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

Control control = Control.builder(() ->
                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.createDatabase(url);

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

    H2DatabaseFactory databaseFactory = new H2DatabaseFactory();

    Database database = databaseFactory.createDatabase(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);

java.sql.Connection connection = databaseConnection.getConnection();

// Define a class representing the table rows
public static final class TableRow {
  
  public static final int STRING_COLUMN_INDEX = 0;
  public static final int INTEGER_COLUMN_INDEX = 1;

  private final String stringValue;

  private final Integer integerValue;

  TableRow(String stringValue, Integer integerValue) {
    this.stringValue = stringValue;
    this.integerValue = integerValue;
  }

  String stringValue() {
    return stringValue;
  }

  Integer integerValue() {
    return integerValue;
  }
}

public static FilteredTableModel<TableRow, Integer> createFilteredTableModel() {
  // Define a factory for the table columns
  ColumnFactory<Integer> columnFactory = () -> asList(
          FilteredTableColumn.builder(STRING_COLUMN_INDEX)
                  .headerValue("String")
                  .columnClass(String.class)
                  .build(),
          FilteredTableColumn.builder(INTEGER_COLUMN_INDEX)
                  .headerValue("Integer")
                  .columnClass(Integer.class)
                  .build());

  // Define a column value provider, providing the table column values
  ColumnValueProvider<TableRow, Integer> columnValueProvider = (row, columnIdentifier) -> {
    switch (columnIdentifier) {
      case STRING_COLUMN_INDEX:
        return row.stringValue();
      case INTEGER_COLUMN_INDEX:
        return row.integerValue();
      default:
        throw new IllegalArgumentException();
    }
  };

  // Define an item supplier responsible for supplying the table row items,
  // without one the table can be populated by adding items manually
  Supplier<Collection<TableRow>> itemSupplier = () -> asList(
          new TableRow("A string", 42),
          new TableRow("Another string", 43));

  // Create the table model
  FilteredTableModel<TableRow, Integer> tableModel =
          FilteredTableModel.builder(columnFactory, columnValueProvider)
                  .itemSupplier(itemSupplier)
                  // if true then the item supplier is called in a
                  // background thread when the model is refreshed
                  .asyncRefresh(false)
                  .build();

  // Populate the model
  tableModel.refresh();

  // Select the first row
  FilteredTableSelectionModel<TableRow> selectionModel = tableModel.selectionModel();
  selectionModel.setSelectedIndex(0);

  // With async refresh enabled
  // tableModel.refreshThen(items ->
  //        selectionModel.setSelectedIndex(0));

  // Search for the value "43" in the table
  FilteredTableSearchModel searchModel = tableModel.searchModel();
  searchModel.searchPredicate().set(value -> value.equals("43"));

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

  return tableModel;
}

// See FilteredTableModel example
FilteredTableModel<TableRow, Integer> tableModel = createFilteredTableModel();

FilteredTable<TableRow, Integer> filteredTable = FilteredTable.builder(tableModel)
        .doubleClickAction(Control.control(() ->
                tableModel.selectionModel().selectedItem()
                        .ifPresent(System.out::println)))
        .autoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
        .build();

State somethingEnabledState = State.state(true);

Control control = Control.builder(() -> 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");
  }
};
Control actionControl = Control.actionControlBuilder(actionCommand)
        .name("Do something else")
        .mnemonic('S')
        .build();

JButton somethingElseButton = new JButton(actionControl);

State state = State.state();

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

Value<Boolean> booleanValue = Value.value();

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

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

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

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

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

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