Mapping enums to entities with Groovy - groovy

Question

I have the following database table:
widget_types
------------
widget_type_id
widget_type_name
widget_type_alias
widget_type_description
This corresponds to the following Groovy entity class:
class WidgetType extends BaseLookupEntity {
Long id
String name
String alias
String description
}
In reality, WidgetType/widget_types really ought to be enums, because they are reference/lookup types with a small number of valid values:
RedWidget
SillyWidget
HappyWidget
BerserkingWidget
SausageWidget
For reasons outside the scope of this question, it is not really possible for me to OR/map the widget_types table to an enum. And so I have created a "helper enum":
enum WidgetTypeLookup {
Red,
Silly,
Happy,
Berserking,
Sausage
static WidgetTypeLookup toWidgetTypeLookup(WidgetType type) {
// TODO: ???
null
}
}
The idea here is that the JPA/OR layer will create WidgetType instances, but to be able to get real use out of them (type safety, etc.), I'd like to be able to convert them to WidgetTypeLookups:
// Inside some method...
WidgetType widgetType = getSomehowButStillNotSureWhichTypeItIs()
WidgetTypeLookup wtLookup = WidgetTypeLookup.toWidgetTypeLookup(widgetType)
switch(wtLookup) {
case Happy:
// etc...
}
So I'm struggling to find an efficient "Groovy way" of converting between the POGO type and the enum. Basically implementing the helper method. Any ideas?

Answer 1

I agree with the other answer that there might be better way to address your problem by improving OO design. Although I'll try to fit into your approach.
First - couldn't you just do it as follow and map the name as enum straight away?
class WidgetType extends BaseLookupEntity {
Long id
WidgetName name
String alias
String description
enum WidgetName {
Red,
Silly,
Happy,
Berserking,
Sausage
}
}
Second - the method you want to implement could be implemented like:
static WidgetTypeLookup toWidgetTypeLookup(WidgetType type) {
values().find {
it.name() == type.name
}
}
However:
the condition may need to be adjusted if names don't exactly match
you may need to handle somehow the case when there is no matching enum found
the name of the method should be rather something as fromWidgetType() then you'll have call like WidgetTypeLookup.fromWidgetType(widgetType) instead of redundant WidgetTypeLookup.toWidgetTypeLookup(widgetType)
Third - Even more groovy would be to implement custom type conversion as follows (I altered original classes names to reflect better what they are IMHO):
enum WidgetType {
Red,
Silly,
Happy,
Berserking,
Sausage
}
class WidgetTypeDetails {
Long id
String name
String alias
String description
Object asType(Class clazz) {
if (clazz == WidgetType) {
WidgetType.values().find {
it.name() == this.name
}
}
}
}
Then you can go like:
WidgetType widgetType = new WidgetTypeDetails(name: 'Red') as WidgetType

Answer 2

An enum is a limited number of fixed elements, unless that table have only fixed rows, Widget Red/Silly/etc should be subclasses.
You could implement the helper method inside the WidgetType class and operate specializations from an inner enum (though they can't reference the outer class)
class WidgetType {
Long id
String name
String alias
String description
enum Type {
RED,
SAUSAGE {
def install(container) {
"installing elongated component into $container"
}
},
SILLY,
HAPPY,
BERSERKING
def install(container) {
"installed ${name()} into $container"
}
}
Type getType() {
Type.values().find { it.name() == name }
}
}
red = new WidgetType(name: 'RED')
assert red.type.install("main container") ==
"installed RED into main container"
sausage = new WidgetType(name: 'SAUSAGE')
assert sausage.type.install("display") ==
"installing elongated component into display"
I think widget.install() is cooler and more OO (in a sense I don't need to pull the object guts to do something).
Another solution would be if WidgetType were an abstract class, and your ORM would instantiate the correct concrete type based on a specific value:
abstract class WidgetType {
Long id
String name
String alias
String description
abstract install(container)
enum Type {
RED(RedWidget),
SAUSAGE(SausageWidget),
}
static WidgetType from(type, properties) {
Type.values().find { it.name() == type }
.clazz
.newInstance(properties: properties)
}
}
class RedWidget extends WidgetType {
def install(container) { 'red installing into $container' }
}
class SausageWidget extends WidgetType {
def install(container) { 'elongated component installing into $container' }
}
The fake ORM:
class ORM {
def container = [
(1) : [
id: 1,
name: 'RED',
alias: 'my red alias',
description: 'this art red' ],
(2) : [
id: 2,
name: 'SAUSAGE',
alias: 'long component',
description: 'sausage component' ]
]
def get(id) {
container[it].with {
WidgetType.from(it.name, id)
}
}
}
Testing:
red = new ORM().get(1)
assert red.install('main') ==
'red installing into main'
sausage = new ORM().get(2)
assert sausage.install('display') ==
'elongated component installing into display'