code stringlengths 73 34.1k | label stringclasses 1
value |
|---|---|
private MethodHandle findIdReadMethod() {
try {
Method readMethod = clazz.getMethod(READ_METHOD_NAME);
Class<?> dataClass = readMethod.getReturnType();
DataType dataType = IdentifierMetadata.DataType.forClass(dataClass);
if (dataType == null) {
String pattern = "Method %s in class %s... | java |
private MethodHandle findConstructor() {
try {
MethodHandle mh = MethodHandles.publicLookup().findConstructor(clazz,
MethodType.methodType(void.class, getIdType()));
return mh;
} catch (NoSuchMethodException | IllegalAccessException exp) {
String pattern = "Class %s requires a public... | java |
public static Object instantiate(MetadataBase metadata) {
try {
return metadata.getConstructorMetadata().getConstructorMethodHandle().invoke();
} catch (Throwable t) {
throw new EntityManagerException(t);
}
} | java |
public static PropertyMetadata getPropertyMetadata(Field field) {
Property property = field.getAnnotation(Property.class);
// For fields that have @Property annotation, we expect both setter and
// getter methods. For all other fields, we only treat them as
// persistable if we find valid getter and set... | java |
public static Object instantiateObject(Class<?> clazz) {
try {
Constructor<?> constructor = clazz.getConstructor();
return constructor.newInstance();
} catch (Exception exp) {
throw new EntityManagerException(exp);
}
} | java |
public static Object getFieldValue(FieldMetadata fieldMetadata, Object target) {
MethodHandle readMethod = fieldMetadata.getReadMethod();
try {
return readMethod.invoke(target);
} catch (Throwable t) {
throw new EntityManagerException(t.getMessage(), t);
}
} | java |
public static MethodHandle findStaticMethod(Class<?> clazz, String methodName,
Class<?> expectedReturnType, Class<?>... expectedParameterTypes) {
return findMethod(clazz, methodName, true, expectedReturnType, expectedParameterTypes);
} | java |
public static MethodHandle findInstanceMethod(Class<?> clazz, String methodName,
Class<?> expectedReturnType, Class<?>... expectedParameterTypes) {
return findMethod(clazz, methodName, false, expectedReturnType, expectedParameterTypes);
} | java |
private static MethodHandle findMethod(Class<?> clazz, String methodName, boolean staticMethod,
Class<?> expectedReturnType, Class<?>... expectedParameterTypes) {
MethodHandle methodHandle = null;
try {
Method method = clazz.getMethod(methodName, expectedParameterTypes);
int modifiers = method... | java |
public void setOptional(boolean optional) {
if (field.getType().isPrimitive() || field.isAnnotationPresent(Version.class)
|| field.isAnnotationPresent(CreatedTimestamp.class)
|| field.isAnnotationPresent(UpdatedTimestamp.class)) {
this.optional = false;
} else {
this.optional = optio... | java |
private void initializeSecondaryIndexer() {
SecondaryIndex secondaryIndexAnnotation = field.getAnnotation(SecondaryIndex.class);
if (secondaryIndexAnnotation == null) {
return;
}
String indexName = secondaryIndexAnnotation.name();
if (indexName == null || indexName.trim().length() == 0) {
... | java |
public static EntityListenersMetadata introspect(Class<?> entityClass) {
EntityListenersIntrospector introspector = new EntityListenersIntrospector(entityClass);
introspector.introspect();
return introspector.metadata;
} | java |
private List<Class<?>> getAllExternalListeners() {
Class<?> clazz = entityClass;
List<Class<?>> allListeners = new ArrayList<>();
boolean stop = false;
while (!stop) {
EntityListeners entityListenersAnnotation = clazz.getAnnotation(EntityListeners.class);
if (entityListenersAnnotation != nul... | java |
private void processExternalListener(Class<?> listenerClass) {
ExternalListenerMetadata listenerMetadata = ExternalListenerIntrospector
.introspect(listenerClass);
Map<CallbackType, Method> callbacks = listenerMetadata.getCallbacks();
if (callbacks != null) {
for (Map.Entry<CallbackType, Metho... | java |
private void validateExternalCallback(Method method, CallbackType callbackType) {
Class<?>[] parameters = method.getParameterTypes();
if (!parameters[0].isAssignableFrom(entityClass)) {
String message = String.format("Method %s in class %s is not valid for entity %s",
method.getName(), method.ge... | java |
private void processInternalListeners() {
List<Class<?>> internalListeners = getAllInternalListeners();
for (Class<?> internalListener : internalListeners) {
processInternalListener(internalListener);
}
} | java |
private List<Class<?>> getAllInternalListeners() {
Class<?> clazz = entityClass;
List<Class<?>> allListeners = new ArrayList<>();
boolean stop = false;
while (!stop) {
allListeners.add(0, clazz);
boolean excludeSuperClassListeners = clazz
.isAnnotationPresent(ExcludeSuperclassListe... | java |
private void processInternalListener(Class<?> listenerClass) {
InternalListenerMetadata listenerMetadata = InternalListenerIntrospector
.introspect(listenerClass);
Map<CallbackType, Method> callbacks = listenerMetadata.getCallbacks();
if (callbacks != null) {
for (Map.Entry<CallbackType, Metho... | java |
public Object getListener(Class<?> listenerClass) {
Object listener = listeners.get(listenerClass);
if (listener == null) {
listener = loadListener(listenerClass);
}
return listener;
} | java |
private Object loadListener(Class<?> listenerClass) {
synchronized (listenerClass) {
Object listener = listeners.get(listenerClass);
if (listener == null) {
listener = IntrospectionUtils.instantiateObject(listenerClass);
listeners.put(listenerClass, listener);
}
return listen... | java |
public static EmbeddableMetadata introspect(Class<?> embeddableClass) {
EmbeddableIntrospector introspector = new EmbeddableIntrospector(embeddableClass);
introspector.introspect();
return introspector.metadata;
} | java |
private void introspect() {
// Make sure the class is Embeddable
if (!embeddableClass.isAnnotationPresent(Embeddable.class)) {
String message = String.format("Class %s must have %s annotation", embeddableClass.getName(),
Embeddable.class.getName());
throw new EntityManagerException(message... | java |
private void processFields() {
List<Field> fields = IntrospectionUtils.getPersistableFields(embeddableClass);
for (Field field : fields) {
if (field.isAnnotationPresent(Embedded.class)) {
processEmbeddedField(field);
} else {
processSimpleField(field);
}
}
} | java |
public static EmbeddedMetadata introspect(EmbeddedField field, EntityMetadata entityMetadata) {
EmbeddedIntrospector introspector = new EmbeddedIntrospector(field, entityMetadata);
introspector.process();
return introspector.metadata;
} | java |
private void process() {
metadata = new EmbeddedMetadata(field);
// Make sure the class has @Embeddable annotation
if (!clazz.isAnnotationPresent(Embeddable.class)) {
String message = String.format("Class %s must have %s annotation", clazz.getName(),
Embeddable.class.getName());
throw... | java |
private void processFields() {
List<Field> children = IntrospectionUtils.getPersistableFields(clazz);
for (Field child : children) {
if (child.isAnnotationPresent(Embedded.class)) {
processEmbeddedField(child);
} else {
processSimpleField(child);
}
}
} | java |
private void processPropertyOverride(PropertyMetadata propertyMetadata) {
String qualifiedName = field.getQualifiedName() + "." + propertyMetadata.getField().getName();
Property override = entityMetadata.getPropertyOverride(qualifiedName);
if (override != null) {
String mappedName = override.name();
... | java |
private void validateIntent() {
if (entityMetadata.isProjectedEntity() && !intent.isValidOnProjectedEntities()) {
String message = String.format("Operation %s is not allowed for ProjectedEntity %s", intent,
entity.getClass().getName());
throw new EntityManagerException(message);
}
} | java |
private BaseEntity<?> marshal() {
marshalKey();
if (key instanceof Key) {
entityBuilder = Entity.newBuilder((Key) key);
} else {
entityBuilder = FullEntity.newBuilder(key);
}
marshalFields();
marshalAutoTimestampFields();
if (intent == Intent.UPDATE) {
marshalVersionField()... | java |
public static Key marshalKey(DefaultEntityManager entityManager, Object entity) {
Marshaller marshaller = new Marshaller(entityManager, entity, Intent.DELETE);
marshaller.marshalKey();
return (Key) marshaller.key;
} | java |
private void marshalKey() {
Key parent = null;
ParentKeyMetadata parentKeyMetadata = entityMetadata.getParentKeyMetadata();
if (parentKeyMetadata != null) {
DatastoreKey parentDatastoreKey = (DatastoreKey) getFieldValue(parentKeyMetadata);
if (parentDatastoreKey != null) {
parent = par... | java |
private static boolean isValidId(Object idValue, DataType identifierType) {
boolean validId = false;
if (idValue != null) {
switch (identifierType) {
case LONG:
case LONG_OBJECT:
validId = (long) idValue != 0;
break;
case STRING:
validId = ((String) id... | java |
private void createCompleteKey(Key parent, long id) {
String kind = entityMetadata.getKind();
if (parent == null) {
key = entityManager.newNativeKeyFactory().setKind(kind).newKey(id);
} else {
key = Key.newBuilder(parent, kind, id).build();
}
} | java |
private void createIncompleteKey(Key parent) {
String kind = entityMetadata.getKind();
if (parent == null) {
key = entityManager.newNativeKeyFactory().setKind(kind).newKey();
} else {
key = IncompleteKey.newBuilder(parent, kind).build();
}
} | java |
private void marshalFields() {
Collection<PropertyMetadata> propertyMetadataCollection = entityMetadata
.getPropertyMetadataCollection();
for (PropertyMetadata propertyMetadata : propertyMetadataCollection) {
marshalField(propertyMetadata, entity);
}
} | java |
private static void marshalField(PropertyMetadata propertyMetadata, Object target,
BaseEntity.Builder<?, ?> entityBuilder) {
Object fieldValue = IntrospectionUtils.getFieldValue(propertyMetadata, target);
if (fieldValue == null && propertyMetadata.isOptional()) {
return;
}
ValueBuilder<?, ?,... | java |
private void marshalEmbeddedFields() {
for (EmbeddedMetadata embeddedMetadata : entityMetadata.getEmbeddedMetadataCollection()) {
if (embeddedMetadata.getStorageStrategy() == StorageStrategy.EXPLODED) {
marshalWithExplodedStrategy(embeddedMetadata, entity);
} else {
ValueBuilder<?, ?, ?>... | java |
private void marshalWithExplodedStrategy(EmbeddedMetadata embeddedMetadata, Object target) {
try {
Object embeddedObject = initializeEmbedded(embeddedMetadata, target);
for (PropertyMetadata propertyMetadata : embeddedMetadata.getPropertyMetadataCollection()) {
marshalField(propertyMetadata, emb... | java |
private ValueBuilder<?, ?, ?> marshalWithImplodedStrategy(EmbeddedMetadata embeddedMetadata,
Object target) {
try {
Object embeddedObject = embeddedMetadata.getReadMethod().invoke(target);
if (embeddedObject == null) {
if (embeddedMetadata.isOptional()) {
return null;
}
... | java |
private void marshalUpdatedTimestamp() {
PropertyMetadata updatedTimestampMetadata = entityMetadata.getUpdatedTimestampMetadata();
if (updatedTimestampMetadata != null) {
applyAutoTimestamp(updatedTimestampMetadata, System.currentTimeMillis());
}
} | java |
private void marshalCreatedAndUpdatedTimestamp() {
PropertyMetadata createdTimestampMetadata = entityMetadata.getCreatedTimestampMetadata();
PropertyMetadata updatedTimestampMetadata = entityMetadata.getUpdatedTimestampMetadata();
long millis = System.currentTimeMillis();
if (createdTimestampMetadata !=... | java |
private void marshalVersionField() {
PropertyMetadata versionMetadata = entityMetadata.getVersionMetadata();
if (versionMetadata != null) {
long version = (long) IntrospectionUtils.getFieldValue(versionMetadata, entity);
ValueBuilder<?, ?, ?> valueBuilder = versionMetadata.getMapper().toDatastore(ve... | java |
private void initializeMapper() {
if (itemClass == null) {
itemMapper = CatchAllMapper.getInstance();
} else {
try {
itemMapper = MapperFactory.getInstance().getMapper(itemClass);
} catch (NoSuitableMapperException exp) {
itemMapper = CatchAllMapper.getInstance();
}
}... | java |
public void setJsonCredentialsFile(String jsonCredentialsPath) {
if (!Utility.isNullOrEmpty(jsonCredentialsPath)) {
setJsonCredentialsFile(new File(jsonCredentialsPath));
} else {
setJsonCredentialsFile((File) null);
}
} | java |
private void initializeMapper() {
if (valueClass == null) {
valueMapper = CatchAllMapper.getInstance();
} else {
try {
valueMapper = MapperFactory.getInstance().getMapper(valueClass);
} catch (NoSuitableMapperException exp) {
valueMapper = CatchAllMapper.getInstance();
}
... | java |
public static InternalListenerMetadata introspect(Class<?> listenerClass) {
InternalListenerMetadata cachedMetadata = cache.get(listenerClass);
if (cachedMetadata != null) {
return cachedMetadata;
}
synchronized (listenerClass) {
cachedMetadata = cache.get(listenerClass);
if (cachedMet... | java |
private void processMethods() {
Method[] methods = listenerClass.getDeclaredMethods();
for (Method method : methods) {
for (CallbackType callbackType : CallbackType.values()) {
if (method.isAnnotationPresent(callbackType.getAnnotationClass())) {
validateMethod(method, callbackType);
... | java |
private void validateMethod(Method method, CallbackType callbackType) {
int modifiers = method.getModifiers();
if (!Modifier.isPublic(modifiers)) {
String message = String.format("Method %s in class %s must be public", method.getName(),
method.getDeclaringClass().getName());
throw new Enti... | java |
public <E> E insert(E entity) {
try {
entityManager.executeEntityListeners(CallbackType.PRE_INSERT, entity);
FullEntity<?> nativeEntity = (FullEntity<?>) Marshaller.marshal(entityManager, entity,
Intent.INSERT);
Entity insertedNativeEntity = nativeWriter.add(nativeEntity);
@Suppres... | java |
@SuppressWarnings("unchecked")
public <E> List<E> insert(List<E> entities) {
if (entities == null || entities.isEmpty()) {
return new ArrayList<>();
}
try {
entityManager.executeEntityListeners(CallbackType.PRE_INSERT, entities);
FullEntity<?>[] nativeEntities = toNativeFullEntities(enti... | java |
@SuppressWarnings("unchecked")
public <E> E update(E entity) {
try {
entityManager.executeEntityListeners(CallbackType.PRE_UPDATE, entity);
Intent intent = (nativeWriter instanceof Batch) ? Intent.BATCH_UPDATE : Intent.UPDATE;
Entity nativeEntity = (Entity) Marshaller.marshal(entityManager, enti... | java |
@SuppressWarnings("unchecked")
public <E> List<E> update(List<E> entities) {
if (entities == null || entities.isEmpty()) {
return new ArrayList<>();
}
try {
Class<E> entityClass = (Class<E>) entities.get(0).getClass();
entityManager.executeEntityListeners(CallbackType.PRE_UPDATE, entitie... | java |
public <E> E updateWithOptimisticLock(E entity) {
PropertyMetadata versionMetadata = EntityIntrospector.getVersionMetadata(entity);
if (versionMetadata == null) {
return update(entity);
} else {
return updateWithOptimisticLockingInternal(entity, versionMetadata);
}
} | java |
public <E> List<E> updateWithOptimisticLock(List<E> entities) {
if (entities == null || entities.isEmpty()) {
return new ArrayList<>();
}
Class<?> entityClass = entities.get(0).getClass();
PropertyMetadata versionMetadata = EntityIntrospector.getVersionMetadata(entityClass);
if (versionMetadat... | java |
@SuppressWarnings("unchecked")
protected <E> E updateWithOptimisticLockingInternal(E entity, PropertyMetadata versionMetadata) {
Transaction transaction = null;
try {
entityManager.executeEntityListeners(CallbackType.PRE_UPDATE, entity);
Entity nativeEntity = (Entity) Marshaller.marshal(entityMana... | java |
@SuppressWarnings("unchecked")
protected <E> List<E> updateWithOptimisticLockInternal(List<E> entities,
PropertyMetadata versionMetadata) {
Transaction transaction = null;
try {
entityManager.executeEntityListeners(CallbackType.PRE_UPDATE, entities);
Entity[] nativeEntities = toNativeEntitie... | java |
public <E> E upsert(E entity) {
try {
entityManager.executeEntityListeners(CallbackType.PRE_UPSERT, entity);
FullEntity<?> nativeEntity = (FullEntity<?>) Marshaller.marshal(entityManager, entity,
Intent.UPSERT);
Entity upsertedNativeEntity = nativeWriter.put(nativeEntity);
@Suppres... | java |
@SuppressWarnings("unchecked")
public <E> List<E> upsert(List<E> entities) {
if (entities == null || entities.isEmpty()) {
return new ArrayList<>();
}
try {
entityManager.executeEntityListeners(CallbackType.PRE_UPSERT, entities);
FullEntity<?>[] nativeEntities = toNativeFullEntities(enti... | java |
public void delete(Object entity) {
try {
entityManager.executeEntityListeners(CallbackType.PRE_DELETE, entity);
Key nativeKey = Marshaller.marshalKey(entityManager, entity);
nativeWriter.delete(nativeKey);
entityManager.executeEntityListeners(CallbackType.POST_DELETE, entity);
} catch (... | java |
public void delete(List<?> entities) {
try {
entityManager.executeEntityListeners(CallbackType.PRE_DELETE, entities);
Key[] nativeKeys = new Key[entities.size()];
for (int i = 0; i < entities.size(); i++) {
nativeKeys[i] = Marshaller.marshalKey(entityManager, entities.get(i));
}
... | java |
public <E> void delete(Class<E> entityClass, DatastoreKey parentKey, long id) {
try {
EntityMetadata entityMetadata = EntityIntrospector.introspect(entityClass);
Key nativeKey = Key.newBuilder(parentKey.nativeKey(), entityMetadata.getKind(), id).build();
nativeWriter.delete(nativeKey);
} catch... | java |
public void deleteByKey(DatastoreKey key) {
try {
nativeWriter.delete(key.nativeKey());
} catch (DatastoreException exp) {
throw DatastoreUtils.wrap(exp);
}
} | java |
public void deleteByKey(List<DatastoreKey> keys) {
try {
Key[] nativeKeys = new Key[keys.size()];
for (int i = 0; i < keys.size(); i++) {
nativeKeys[i] = keys.get(i).nativeKey();
}
nativeWriter.delete(nativeKeys);
} catch (DatastoreException exp) {
throw DatastoreUtils.wrap... | java |
public void setNamedBindings(Map<String, Object> namedBindings) {
if (namedBindings == null) {
throw new IllegalArgumentException("namedBindings cannot be null");
}
this.namedBindings = namedBindings;
} | java |
public void addPositionalBindings(Object first, Object... others) {
positionalBindings.add(first);
positionalBindings.addAll(Arrays.asList(others));
} | java |
private void computeQualifiedName() {
if (parent != null) {
qualifiedName = parent.qualifiedName + "." + field.getName();
} else {
qualifiedName = field.getName();
}
} | java |
public void put(CallbackType callbackType, CallbackMetadata callbackMetadata) {
if (callbacks == null) {
callbacks = new EnumMap<>(CallbackType.class);
}
List<CallbackMetadata> callbackMetadataList = callbacks.get(callbackType);
if (callbackMetadataList == null) {
callbackMetadataList = new ... | java |
public List<CallbackMetadata> getCallbacks(CallbackType callbackType) {
return callbacks == null ? null : callbacks.get(callbackType);
} | java |
private static ConstructorMetadata loadMetadata(Class<?> clazz) {
synchronized (clazz) {
ConstructorMetadata metadata = cache.get(clazz);
if (metadata == null) {
ConstructorIntrospector introspector = new ConstructorIntrospector(clazz);
introspector.process();
metadata = introspe... | java |
private void process() {
metadataBuilder = ConstructorMetadata.newBuilder().setClazz(clazz);
MethodHandle mh = IntrospectionUtils.findDefaultConstructor(clazz);
if (mh != null) {
metadataBuilder.setConstructionStrategy(ConstructorMetadata.ConstructionStrategy.CLASSIC)
.setConstructorMethodHa... | java |
public static MethodHandle findNewBuilderMethod(Class<?> clazz) {
MethodHandle mh = null;
for (String methodName : NEW_BUILDER_METHOD_NAMES) {
mh = IntrospectionUtils.findStaticMethod(clazz, methodName, Object.class);
if (mh != null) {
break;
}
}
return mh;
} | java |
public static <T> T unmarshal(Entity nativeEntity, Class<T> entityClass) {
return unmarshalBaseEntity(nativeEntity, entityClass);
} | java |
public static <T> T unmarshal(ProjectionEntity nativeEntity, Class<T> entityClass) {
return unmarshalBaseEntity(nativeEntity, entityClass);
} | java |
@SuppressWarnings("unchecked")
private <T> T unmarshal() {
try {
instantiateEntity();
unmarshalIdentifier();
unmarshalKeyAndParentKey();
unmarshalProperties();
unmarshalEmbeddedFields();
// If using Builder pattern, invoke build method on the Builder to
// get the final ... | java |
private static <T> T unmarshalBaseEntity(BaseEntity<?> nativeEntity, Class<T> entityClass) {
if (nativeEntity == null) {
return null;
}
Unmarshaller unmarshaller = new Unmarshaller(nativeEntity, entityClass);
return unmarshaller.unmarshal();
} | java |
private void unmarshalIdentifier() throws Throwable {
IdentifierMetadata identifierMetadata = entityMetadata.getIdentifierMetadata();
Object id = ((Key) nativeEntity.getKey()).getNameOrId();
// If the ID is not a simple type...
IdClassMetadata idClassMetadata = identifierMetadata.getIdClassMetadata();
... | java |
private void unmarshalKeyAndParentKey() throws Throwable {
KeyMetadata keyMetadata = entityMetadata.getKeyMetadata();
if (keyMetadata != null) {
MethodHandle writeMethod = keyMetadata.getWriteMethod();
Key entityKey = (Key) nativeEntity.getKey();
writeMethod.invoke(entity, new DefaultDatastore... | java |
private void unmarshalProperties() throws Throwable {
Collection<PropertyMetadata> propertyMetadataCollection = entityMetadata
.getPropertyMetadataCollection();
for (PropertyMetadata propertyMetadata : propertyMetadataCollection) {
unmarshalProperty(propertyMetadata, entity);
}
} | java |
private void unmarshalEmbeddedFields() throws Throwable {
for (EmbeddedMetadata embeddedMetadata : entityMetadata.getEmbeddedMetadataCollection()) {
if (embeddedMetadata.getStorageStrategy() == StorageStrategy.EXPLODED) {
unmarshalWithExplodedStrategy(embeddedMetadata, entity);
} else {
... | java |
private void unmarshalWithExplodedStrategy(EmbeddedMetadata embeddedMetadata, Object target)
throws Throwable {
Object embeddedObject = initializeEmbedded(embeddedMetadata, target);
for (PropertyMetadata propertyMetadata : embeddedMetadata.getPropertyMetadataCollection()) {
unmarshalProperty(propert... | java |
private static void unmarshalWithImplodedStrategy(EmbeddedMetadata embeddedMetadata,
Object target, BaseEntity<?> nativeEntity) throws Throwable {
Object embeddedObject = null;
ConstructorMetadata constructorMetadata = embeddedMetadata.getConstructorMetadata();
FullEntity<?> nativeEmbeddedEntity = nul... | java |
private void unmarshalProperty(PropertyMetadata propertyMetadata, Object target)
throws Throwable {
unmarshalProperty(propertyMetadata, target, nativeEntity);
} | java |
public void setIdentifierMetadata(IdentifierMetadata identifierMetadata) {
if (this.identifierMetadata != null) {
String format = "Class %s has at least two fields, %s and %s, marked with %s annotation. "
+ "Only one field can be marked as an identifier. ";
String message = String.format(forma... | java |
public void setKeyMetadata(KeyMetadata keyMetadata) {
if (this.keyMetadata != null) {
String format = "Class %s has two fields, %s and %s marked with %s annotation. Only one "
+ "field can be marked as Key. ";
String message = String.format(format, entityClass.getName(), this.keyMetadata.getNa... | java |
public void setParentKetMetadata(ParentKeyMetadata parentKeyMetadata) {
if (this.parentKeyMetadata != null) {
String format = "Class %s has two fields, %s and %s marked with %s annotation. Only one "
+ "field can be marked as ParentKey. ";
String message = String.format(format, entityClass.get... | java |
public void setVersionMetadata(PropertyMetadata versionMetadata) {
if (this.versionMetadata != null) {
throwDuplicateAnnotationException(entityClass, Version.class, this.versionMetadata,
versionMetadata);
}
this.versionMetadata = versionMetadata;
} | java |
public void setCreatedTimestampMetadata(PropertyMetadata createdTimestampMetadata) {
if (this.createdTimestampMetadata != null) {
throwDuplicateAnnotationException(entityClass, CreatedTimestamp.class,
this.createdTimestampMetadata, createdTimestampMetadata);
}
this.createdTimestampMetadata =... | java |
public void updateMasterPropertyMetadataMap(String mappedName, String qualifiedName) {
String old = masterPropertyMetadataMap.put(mappedName, qualifiedName);
if (old != null) {
String message = "Duplicate property %s in entity %s. Check fields %s and %s";
throw new EntityManagerException(
... | java |
private void ensureUniqueProperties(EmbeddedMetadata embeddedMetadata,
StorageStrategy storageStrategy) {
if (embeddedMetadata.getStorageStrategy() == StorageStrategy.EXPLODED) {
for (PropertyMetadata propertyMetadata : embeddedMetadata.getPropertyMetadataCollection()) {
updateMasterPropertyMeta... | java |
private static void throwDuplicateAnnotationException(Class<?> entityClass,
Class<? extends Annotation> annotationClass, PropertyMetadata metadata1,
PropertyMetadata metadata2) {
String format = "Class %s has at least two fields, %s and %s, with an annotation of %s. "
+ "A given entity can have ... | java |
public static ExternalListenerMetadata introspect(Class<?> listenerClass) {
ExternalListenerMetadata cachedMetadata = cache.get(listenerClass);
if (cachedMetadata != null) {
return cachedMetadata;
}
synchronized (listenerClass) {
cachedMetadata = cache.get(listenerClass);
if (cachedMet... | java |
private void introspect() {
if (!listenerClass.isAnnotationPresent(EntityListener.class)) {
String message = String.format(
"Class %s must have %s annotation to be used as an EntityListener",
listenerClass.getName(), EntityListener.class.getName());
throw new EntityManagerException(m... | java |
public Mapper getMapper(Field field) {
PropertyMapper propertyMapperAnnotation = field.getAnnotation(PropertyMapper.class);
if (propertyMapperAnnotation != null) {
return createCustomMapper(field, propertyMapperAnnotation);
}
Class<?> fieldType = field.getType();
if (fieldType.equals(BigDecima... | java |
public Mapper getMapper(Type type) {
Mapper mapper = cache.get(type);
if (mapper == null) {
mapper = createMapper(type);
}
return mapper;
} | java |
public void setDefaultMapper(Type type, Mapper mapper) {
if (mapper == null) {
throw new IllegalArgumentException("mapper cannot be null");
}
lock.lock();
try {
cache.put(type, mapper);
} finally {
lock.unlock();
}
} | java |
private Mapper createMapper(Type type) {
lock.lock();
try {
Mapper mapper = cache.get(type);
if (mapper != null) {
return mapper;
}
if (type instanceof Class) {
mapper = createMapper((Class<?>) type);
} else if (type instanceof ParameterizedType) {
mapper = ... | java |
private Mapper createMapper(Class<?> clazz) {
Mapper mapper;
if (Enum.class.isAssignableFrom(clazz)) {
mapper = new EnumMapper(clazz);
} else if (Map.class.isAssignableFrom(clazz)) {
mapper = new MapMapper(clazz);
} else if (clazz.isAnnotationPresent(Embeddable.class)) {
mapper = new E... | java |
private void createDefaultMappers() {
BooleanMapper booleanMapper = new BooleanMapper();
CharMapper charMapper = new CharMapper();
ShortMapper shortMapper = new ShortMapper();
IntegerMapper integerMapper = new IntegerMapper();
LongMapper longMapper = new LongMapper();
FloatMapper floatMapper = n... | java |
private Mapper createCustomMapper(Field field, PropertyMapper propertyMapperAnnotation) {
Class<? extends Mapper> mapperClass = propertyMapperAnnotation.value();
Constructor<? extends Mapper> constructor = IntrospectionUtils.getConstructor(mapperClass,
Field.class);
if (constructor != null) {
... | java |
public void putListener(CallbackType callbackType, Method method) {
if (callbacks == null) {
callbacks = new EnumMap<>(CallbackType.class);
}
Method oldMethod = callbacks.put(callbackType, method);
if (oldMethod != null) {
String format = "Class %s has at least two methods, %s and %s, with a... | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.