@Override public boolean equals(Object o) { if (o == null || ! Proxy.isProxyClass(o.getClass())) { return false; } Object invocationHandler = Proxy.getInvocationHandler(o); return invocationHandler instanceof TuplePojo && ((TuplePojo) invocationHandler).tuple.equals(tuple); }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getDeclaringClass().isAssignableFrom(getClass())) { return method.invoke(this, args); } return tuple.get(keyMap.get(method)); }
@Override public int hashCode() { return tuple.hashCode(); }
/** * Convert the supplied {@link Command} into a {@link CommandJson} object suitable for JSON serialisation. * @param command The {@link Command} to convert. * @param objectMapper The {@link ObjectMapper} to use to convert the {@link Command}'s parameters into JSON nodes. * @return The converted {@link CommandJson}. */ public static CommandJson of(Command command, ObjectMapper objectMapper) { Function<Object, JsonNode> serialiser = objectMapper::valueToTree; return of( command.getAggregateId().getType(), command.getAggregateId().getId(), command.getCommandName().getName(), command.getCommandName().getVersion(), command.getCommandTimestamp().getTimestamp().toEpochMilli(), command.getCommandTimestamp().getStreamId(), command.getProcessingId().map(UUID::toString).orElse(""), command.getParameters().serialise(serialiser) ); }
/** * Make a tuple of the supplied values, first validating that they conform to this schema. * @param values The values to put in the Tuple. * @return The created Tuple. */ public Tuple make(Object[] values) { if (values == null) throw new IllegalArgumentException("value must not be null"); if (values.length != slots.length) throw new IllegalArgumentException( String.format("Expected %s values, but received %s", slots.length, values.length)); if (!typesMatch(values)) { throw new IllegalArgumentException(describeTypeMismatches(values)); } return new Tuple(this, values); }
@Override public String toString() { return tuple.toString(); } }
public static <T> T wrapping(Tuple tuple, Class<? extends T> pojoClass) { return pojoClass.cast(Proxy.newProxyInstance(pojoClass.getClassLoader(), new Class<?>[] { pojoClass }, new TuplePojo(tuple, getTupleMap(pojoClass, tuple.getSchema())))); }
private Object[] getBindArguments(Event event) { return new Object[] { event.getAggregateId().getType(), event.getAggregateId().getId(), Date.from(event.getEventTimestamp().getTimestamp()), event.getEventTimestamp().getStreamId(), event.getProcessingId().orElseThrow(() -> new IllegalArgumentException("Event has no processing id")), event.getEventName().getName(), event.getEventName().getVersion(), event.getParameters().serialise(serialiser), event.getCharacteristics() }; }
/** * Build a tuple using the supplied key/value pairs, first validating that the keys belong to this schema and are complete. * @param keyValues The TupleKeyValues to use to create the Tuple. * @return The created Tuple. */ public Tuple make(TupleKeyValue...keyValues) { if (keyValues == null) throw new IllegalArgumentException("keyValues must not be null"); if (!Stream.of(keyValues).allMatch(kv -> kv.belongsToSchema(this))) { throw new IllegalArgumentException(String.format( "Keys %s do not all belong to schema %s", getKeyNames(keyValues), this)); } if (Stream.of(keyValues).map(TupleKeyValue::getTupleKey).distinct().count() != slots.length) { throw new IllegalArgumentException(String.format( "Not all slots in %s filled by provided keys %s", this, getKeyNames(keyValues))); } Object[] values = new Object[slots.length]; Stream.of(keyValues).forEach(kv -> kv.build(values)); return new Tuple(this, values); }
/** * Convert an {@link Event} to a serialisable {@link EventJson} object, using the supplied {@link ObjectMapper} * to serialise the event's parameters to JSON nodes. * @param event The {@link Event} to serialise. * @param objectMapper The {@link ObjectMapper} to use to serialise the event's parameters to JSON nodes. * @return The mapped {@link EventJson}. */ public static EventJson of(Event event, ObjectMapper objectMapper) { Function<Object, JsonNode> serialiser = objectMapper::valueToTree; return of( event.getAggregateId().getType(), event.getAggregateId().getId(), event.getEventName().getName(), event.getEventName().getVersion(), event.getEventTimestamp().getTimestamp().toEpochMilli(), event.getEventTimestamp().getStreamId(), event.getProcessingId().map(UUID::toString).orElse(""), event.getCharacteristics(), event.getParameters().serialise(serialiser) ); }
private void populateArgsFromTuple(Event event, TupleKey[] tupleKeys, Object[] args) { int keyIndex = 0; int argIndex = offset; final Tuple parameters = event.getParameters(); while (keyIndex < tupleKeys.length) { args[argIndex++] = parameters.get(tupleKeys[keyIndex++]); } }
private void populateArgsFromTuple(Command command, Object[] args) { IntStream.range(0, tupleKeys.length).forEach(i -> args[i + 2] = command.getParameters().get(tupleKeys[i])); }