javax.persistence.EnumType Java Examples

public static void checkEnum(List<Class<?>> classes) throws Exception {
	for (Class<?> cls : classes) {
		List<Field> fields = FieldUtils.getFieldsListWithAnnotation(cls, FieldDescribe.class);
		for (Field field : fields) {
			if (field.getType().isEnum()) {
				Enumerated enumerated = field.getAnnotation(Enumerated.class);
				Column column = field.getAnnotation(Column.class);
				if (null == enumerated || (!Objects.equals(EnumType.STRING, enumerated.value())) || (null == column)
						|| column.length() > 200) {
					System.err.println(String.format("checkEnum error: class: %s, field: %s.", cls.getName(),
							field.getName()));
				}
			}
		}
	}
}
 

/**
 * @return the status
 */
@Enumerated(EnumType.STRING)
@Column(length = 100)
public TeamAttendeeStatus getStatus()
{
  return status;
}
 

/**
 * Adds a @MapKeyEnumerated annotation to the specified annotationList if the specified element
 * contains a map-key-enumerated sub-element. This should only be the case for
 * element-collection, many-to-many, or one-to-many associations.
 */
private void getMapKeyEnumerated(List<Annotation> annotationList, Element element) {
	Element subelement = element != null ? element.element( "map-key-enumerated" ) : null;
	if ( subelement != null ) {
		AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyEnumerated.class );
		EnumType value = EnumType.valueOf( subelement.getTextTrim() );
		ad.setValue( "value", value );
		annotationList.add( AnnotationFactory.create( ad ) );
	}
}
 

/**
 * Gets type of event action. AUDIO or DISPLAY
 * 
 * @return the reminderType
 */
@Enumerated(EnumType.STRING)
@Column(name = "reminder_action_type")
public ReminderActionType getReminderActionType()
{
  return reminderActionType;
}
 

/** -> Gantt */
@Deprecated
@Enumerated(EnumType.STRING)
@Column(name = "gantt_rel_type", length = 15)
public GanttRelationType getGanttRelationType()
{
  return ganttRelationType;
}
 

/**
* Gets the gender.
*
* @return the gender
*/
  @Basic
  @Column(name = "GENDER")
  @Enumerated(EnumType.STRING)
  public SexType getGender() {
      return gender;
  }
 

/**
* Gets the role description.
*
* @return the role description
*/
  @Basic
  @Column(name = "ROLE_DESCRIPTION")
  @Enumerated(EnumType.STRING)
  public DocumentPersonReferenceRoleType getRoleDescription() {
      return roleDescription;
  }
 

/**
* Gets the value.
*
* @return the value
*/
  @Basic
  @Column(name = "VALUE_")
  @Enumerated(EnumType.STRING)
  public LendingTypeCategory getValue() {
      return value;
  }
 

/**
* Gets the value.
*
* @return the value
*/
  @Basic
  @Column(name = "VALUE_")
  @Enumerated(EnumType.STRING)
  public RegionCategory getValue() {
      return value;
  }
 

@Enumerated(EnumType.STRING)
@Column(name = "timesheet_booking_status", length = 20, nullable = false)
public TimesheetBookingStatus getTimesheetBookingStatus()
{
  if (timesheetBookingStatus == null) {
    return TimesheetBookingStatus.DEFAULT;
  } else {
    return timesheetBookingStatus;
  }
}
 

/**
* Gets the concern.
*
* @return the concern
*/
  @Basic
  @Column(name = "CONCERN")
  @Enumerated(EnumType.STRING)
  public VoteIssueType getConcern() {
      return concern;
  }
 

/**
* Gets the vote.
*
* @return the vote
*/
  @Basic
  @Column(name = "VOTE")
  @Enumerated(EnumType.STRING)
  public VoteDecision getVote() {
      return vote;
  }
 

/**
* Gets the ballot type.
*
* @return the ballot type
*/
  @Basic
  @Column(name = "BALLOT_TYPE")
  @Enumerated(EnumType.STRING)
  public BallotType getBallotType() {
      return ballotType;
  }
 

/**
* Gets the vote.
*
* @return the vote
*/
  @Basic
  @Column(name = "VOTE")
  @Enumerated(EnumType.STRING)
  public VoteDecision getVote() {
      return vote;
  }
 

/**
* Gets the org code.
*
* @return the org code
*/
  @Basic
  @Column(name = "ORG_CODE")
  @Enumerated(EnumType.STRING)
  public OrgCode getOrgCode() {
      return orgCode;
  }
 

@ElementCollection(targetClass = Role.class, fetch = FetchType.EAGER)
@CollectionTable(name = "USER_ROLES", joinColumns = @JoinColumn(name = "USER_ID"))
@Enumerated(EnumType.STRING)
@Column(name = "role", nullable = false)
public Set<Role> getRoles() {
	return roles;
}
 

/**
 * @return the status
 */
@Enumerated(EnumType.STRING)
@Column(length = 10)
public KontoStatus getStatus()
{
  return status;
}
 

@Enumerated(EnumType.STRING)
@Column(length = 20)
public ToDoStatus getStatus()
{
  return status;
}
 

@Enumerated(EnumType.STRING)
public UserType getType() {
	return type;
}
 

@Enumerated(EnumType.STRING)
@Column(nullable = false)
public Status getStatus() {
    return status;
}
 

@Enumerated(EnumType.STRING)
@Column(length = PRIORITY_LENGTH)
public Priority getPriority()
{
  return priority;
}
 

/**
 * Gets the status.
 *
 * @return the status
 */
@Enumerated(EnumType.STRING)
   @Column(name = "status")
public Status getStatus() {
	return status;
}
 

@Enumerated(EnumType.STRING)
public Health getHealth() {
    return health;
}
 

@Override
public DatabaseFieldConfig createFieldConfig(DatabaseType databaseType, Field field) {
	Column columnAnnotation = field.getAnnotation(Column.class);
	Basic basicAnnotation = field.getAnnotation(Basic.class);
	Id idAnnotation = field.getAnnotation(Id.class);
	GeneratedValue generatedValueAnnotation = field.getAnnotation(GeneratedValue.class);
	OneToOne oneToOneAnnotation = field.getAnnotation(OneToOne.class);
	ManyToOne manyToOneAnnotation = field.getAnnotation(ManyToOne.class);
	JoinColumn joinColumnAnnotation = field.getAnnotation(JoinColumn.class);
	Enumerated enumeratedAnnotation = field.getAnnotation(Enumerated.class);
	Version versionAnnotation = field.getAnnotation(Version.class);

	if (columnAnnotation == null && basicAnnotation == null && idAnnotation == null && oneToOneAnnotation == null
			&& manyToOneAnnotation == null && enumeratedAnnotation == null && versionAnnotation == null) {
		return null;
	}

	DatabaseFieldConfig config = new DatabaseFieldConfig();
	String fieldName = field.getName();
	if (databaseType.isEntityNamesMustBeUpCase()) {
		fieldName = databaseType.upCaseEntityName(fieldName);
	}
	config.setFieldName(fieldName);

	if (columnAnnotation != null) {
		if (stringNotEmpty(columnAnnotation.name())) {
			config.setColumnName(columnAnnotation.name());
		}
		if (stringNotEmpty(columnAnnotation.columnDefinition())) {
			config.setColumnDefinition(columnAnnotation.columnDefinition());
		}
		config.setWidth(columnAnnotation.length());
		config.setCanBeNull(columnAnnotation.nullable());
		config.setUnique(columnAnnotation.unique());
	}
	if (basicAnnotation != null) {
		config.setCanBeNull(basicAnnotation.optional());
	}
	if (idAnnotation != null) {
		if (generatedValueAnnotation == null) {
			config.setId(true);
		} else {
			// generatedValue only works if it is also an id according to {@link GeneratedValue)
			config.setGeneratedId(true);
		}
	}
	if (oneToOneAnnotation != null || manyToOneAnnotation != null) {
		// if we have a collection then make it a foreign collection
		if (Collection.class.isAssignableFrom(field.getType())
				|| ForeignCollection.class.isAssignableFrom(field.getType())) {
			config.setForeignCollection(true);
			if (joinColumnAnnotation != null && stringNotEmpty(joinColumnAnnotation.name())) {
				config.setForeignCollectionColumnName(joinColumnAnnotation.name());
			}
			if (manyToOneAnnotation != null) {
				FetchType fetchType = manyToOneAnnotation.fetch();
				if (fetchType != null && fetchType == FetchType.EAGER) {
					config.setForeignCollectionEager(true);
				}
			}
		} else {
			// otherwise it is a foreign field
			config.setForeign(true);
			if (joinColumnAnnotation != null) {
				if (stringNotEmpty(joinColumnAnnotation.name())) {
					config.setColumnName(joinColumnAnnotation.name());
				}
				config.setCanBeNull(joinColumnAnnotation.nullable());
				config.setUnique(joinColumnAnnotation.unique());
			}
		}
	}
	if (enumeratedAnnotation != null) {
		EnumType enumType = enumeratedAnnotation.value();
		if (enumType != null && enumType == EnumType.STRING) {
			config.setDataType(DataType.ENUM_STRING);
		} else {
			config.setDataType(DataType.ENUM_INTEGER);
		}
	}
	if (versionAnnotation != null) {
		// just the presence of the version...
		config.setVersion(true);
	}
	if (config.getDataPersister() == null) {
		config.setDataPersister(DataPersisterManager.lookupForField(field));
	}
	config.setUseGetSet(DatabaseFieldConfig.findGetMethod(field, databaseType, false) != null
			&& DatabaseFieldConfig.findSetMethod(field, databaseType, false) != null);
	return config;
}
 

@Column(nullable = false)
@Enumerated(EnumType.STRING)
public AuthenticationLogContext getContext() {
	return context;
}
 

@Enumerated(EnumType.STRING)
@Column(name = "mode_of_payment_type", length = 13)
public ModeOfPaymentType getModeOfPaymentType()
{
  return modeOfPaymentType;
}
 

@Column(nullable = false)
@Enumerated(EnumType.STRING)
public LicenceStatus getStatus() {
	return status;
}
 

@Enumerated(EnumType.STRING)
public InvoiceState getInvoiceState() {
	return invoiceState;
}
 

@Enumerated(EnumType.STRING)
@Column(name = "post_type", length = 100, nullable = false)
public PostType getType()
{
  return type;
}
 

@Column(nullable = false)
@Enumerated(EnumType.STRING)
public PublisherPaymentRequestStatus getStatus() {
	return status;
}