This issue can't be edited
Because it belongs to an archived project. Jira admins can restore projects from the archive.
Create facility for OGM core and Dialects to receive custom metadata (annotation, programmatic) associated to entities, properties or associations
Description
Environment
is followed up by
required for
Activity
Emmanuel BernardJuly 27, 2012 at 4:33 PM
Here is my next rev on options. I tried to make it more type-safe for the read API and simplify it at the same time.
Iteration number 2
By merging the notion of `Option` and `OptionValueTupple` in a single element and using the Option class
as identifier for the option, we simplify the number of classes and make it more type safe when using it.
Options would then be identified by their class and possibly their unique identifier.
Note that we end up using classes instead of interfaces for the design. Is that a bad thing?
// Provided by Hibernate OGM
public abstract class Option<Type extends Option<Type,Identifier>, Identifier> {
private Class<Type> type;
public Option(Class<Type> type) { this.type = type; }
public abstract Identifier getOptionIdentifier();
public Class<Type> getOptionType() { return type; }
public boolean equals(Object that) {
//equals based on getOptionIdentifier() and getOptionType()
}
public int hashCode() {
//same as equals
}
}
// Provided by Hibernate OGM
/**
* Specialized class used by options that defined only once.
* Most options should subclass this class
*/
public abstract class UniqueOption<Type extends UniqueOption<Type>>
extends Option<Type,Object> {
private static Object IDENTITY = new Object();
public UniqueOption(Class<Type> type) { super(type); }
public Object getOptionIdentifier() { return IDENTITY; }
}
// Some examples
// Simple unique option
public class Quorum extends UniqueOption<Quorum> {
public Quorum(int read, int write) {
super(Quorum.class);
this.read = read;
this.write = write;
}
public void getRead(int read) { this.read = read; }
private int read;
public void getWrite(int write) { this.write = write; }
private int write;
}
// multiple options
public class NamedQuery extends Option<NamedQuery, String> {
public NamedQuery(String name, String hql) {
super(NamedQuery.class);
this.name = name;
this.hql = hql;
}
public String getOptionIdentifier() { return name; }
public String getName() { return name; }
private String name;
public String getHql() { return hql; }
private String hql;
}
//Usage in GridDialect
// getOption is only for unique options
Quorum quorum = context.inGlobalContext().getOption( Quorum );
// for multiple options, use getOptions
Map<String, NamedQuery> queries =
context.inEntityContext().getOptions(NamedQuery.class);
//The next line does not compile as NamedQuery is not a UniqueOption
//NamedQuery query = context.inEntityContext().getOption(NamedQuery.class);
//API of getOption(s)
public <O extends UniqueOption<O>> O getOption(Class<O> optionType);
public <I,O extends Option<O,I>> Map<I,O> getOptions(Class<O> optionType);
//TODO should it be a map, or is a `Set` sufficient?Please let me know if I'm mad 
Emmanuel BernardJuly 25, 2012 at 10:04 AM
QuorumOptionValueTuple and NamedQueryOptionValueTuple are two options shown in my previous comment. Due to JIRA weirdness you ened to scroll on the code blocks to see them.
Sanne GrinoveroJuly 25, 2012 at 12:27 AM
ah right, missed the obvious.
How would an example look like for
a Class object in particular an annotation class object
?
Emmanuel BernardJuly 24, 2012 at 10:54 PM
I am not following you, Option is a generic parameter so you can make it whatever you want.
For example
public class Foo implements OptionValueTuple<Address,String> {
Address getOption() { ... }
String getValue() { ... }
}Sanne GrinoveroJuly 24, 2012 at 9:48 PMEdited
About these two fragments:
public interface OptionValueTuple<Option,Value> {
Option getOption();
Value getValue();
}Option can be of any type, in particular it could be represented as
an enum value
a Class object in particular an annotation class object
a String
How can I implement that interface but change the return type of getOption() to something different?
I guess you mean my custom OptionValueTuple should return a custom MultiOption ?
Details
Assignee
Davide D'AltoDavide D'AltoReporter
Emmanuel BernardEmmanuel BernardParticipants
Davide D'AltoEmmanuel BernardSanne GrinoveroFix versions
Priority
Critical
Details
Details
Assignee
Reporter
Participants
Fix versions
Priority
Critical
Typically we should be able to transfer the following metadata to the MongoDB driver
@Entity public class User { @ManyToMany @EmbeddedInDocument public Set<Address> addresses; }The facility should be extensible to make sure a driver can add any necessary custom metadata.
A programmatic mapping API would be useful too.