Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2013 Christophe Pollet
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package net.cpollet.jixture.helper;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

Author(s):
Christophe Pollet
 
 
 
 		if (null == ) {
 			 = new ArrayList<Class>(classNames.size());
 
 			for (String className : classNames) {
 				try {
 				}
 				catch (ClassNotFoundException e) {
 					throw ExceptionUtils.wrapInRuntimeException(e);
 				}
 			}
 		}
 
 		return ;
 	}
 
 	public Class getMappingClassByTableName(String tableName) {
 
 		Class result = .get(tableName);
 
 		if (null == result) {
 			throw new RuntimeException("Mapping for table " + tableName + " not found");
 		}
 
 		return result;
 	}
 
 	private void initMappingsIfNeeded() {
 			return;
 		}
 
 
 		for (Class mapping : getMappingClasses()) {
 			String tableName = getLowercaseTableNameFromMapping(mapping);
 			.put(tableNamemapping);
 
 			createColumnToFieldMapping(mappingtableName);
 		}
	}
	private boolean mappingsAlreadyCreated() {
		return null !=  && null != ;
	}
		Table annotation = (Tablemapping.getAnnotation(Table.class);
		return annotation.name().toLowerCase();
	}
	private void createColumnToFieldMapping(Class mappingString tableName) {
		for (Field field : getFieldsUpToObject(mapping)) {
			if (null != columnName) {
				getOrCreateFieldsByTableName(tableName).put(columnNamenew MappingField(field));
			}
			else {
			}
		}
	}
	public static Iterable<FieldgetFieldsUpToObject(Class<?> startClass) {
		List<FieldcurrentClassFields = new ArrayList<Field>();
		currentClassFields.addAll(Arrays.asList(startClass.getDeclaredFields()));
		Class<?> parentClass = startClass.getSuperclass();
		if (null != parentClass) {
			List<FieldparentClassFields = (List<Field>) getFieldsUpToObject(parentClass);
			currentClassFields.addAll(parentClassFields);
		}
		return currentClassFields;
	}
		Column column = field.getAnnotation(Column.class);
		if (null == column) {
			column = getColumnFromGetter(field);
		}
		if (null == column) {
			return null;
		}
		if (null == column.name() || "".equals(column.name())) {
			return field.getName(); // FIXME this one may be wrong actually...
		}
		return column.name().toLowerCase();
	}
	private Column getColumnFromGetter(Field field) {
		BeanInfo beanInfo = getBeanInfo(field);
		for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) {
			if (isGetterForField(pdfield)) {
				return pd.getReadMethod().getAnnotation(Column.class);
			}
		}
		return null;
	}
	private BeanInfo getBeanInfo(Field field) {
		try {
			return Introspector.getBeanInfo(field.getDeclaringClass());
		}
			throw ExceptionUtils.wrapInRuntimeException(e);
		}
	}
	private boolean isGetterForField(PropertyDescriptor pdField field) {
		return null != pd.getReadMethod() && pd.getName().equals(field.getName());
	}
		}
		return .get(tableName);
	}
	private void createColumnToEmbeddedFieldMapping(String tableNameField field) {
		EmbeddedId embeddedId = field.getAnnotation(EmbeddedId.class);
		if (null != embeddedId) {
			for (Field embeddedField : field.getType().getDeclaredFields()) {
				String embeddedColumnName = getLowercaseColumnNameFromMapping(embeddedField);
				getOrCreateFieldsByTableName(tableName).put(embeddedColumnNamenew MappingField(fieldembeddedField));
			}
		}
	}
	public MappingField getMappingFieldByTableAndColumnNames(String tableNameString columnName) {
		Map<StringMappingFieldmappingFields = getFieldsByTableName(tableName);
		return getFieldByColumnName(tableNamecolumnNamemappingFields);
	}
		Map<StringMappingFieldmappingFields = .get(tableName);
		if (null == mappingFields) {
			throw new RuntimeException("Mapping class not found for table " + tableName);
		}
		return mappingFields;
	}
	private MappingField getFieldByColumnName(String tableNameString columnNameMap<StringMappingFieldmappingFields) {
		MappingField mappingField = mappingFields.get(columnName);
		if (null == mappingField) {
			throw new RuntimeException("Column " + columnName + " not mapped in mapping class "//
getMappingClassByTableName(tableName).getName() + " for " + tableName);
		}
		return mappingField;
	}
	}
	public void afterPropertiesSet() throws Exception {
		Assert.notNull("unitDaoFactory must be set");
	}
	public void setUnitDaoFactory(UnitDaoFactory unitDaoFactory) {
		this. = unitDaoFactory;
	}
New to GrepCode? Check out our FAQ X