/** * 得到所有类型 * @return */ public Iterator getAllLayoutTypes(){ List srcTypes = new LinkedList(types.values()); Iterator itTypes = srcTypes.iterator(); List tmpTypes = new LinkedList(); while(itTypes.hasNext()){ ILayoutType type = (ILayoutType)itTypes.next(); tmpTypes.add(type.copyLayoutType()); }
//层次桶
protected Map layoutTypes = new LinkedMap();
//类型桶
protected Map types = new LinkedMap();
//dao
private ILayoutTypeDAO layoutDao;
//rootType
private ILayoutType root_type;
//数据改变观察者
private ILayoutTypeDataChangeListener dataChangeListener;
//根节点名
public static final String ROOT_NAME = "_root";
public LayoutTypeTool(){
}
/**
* 加载数据
*/
public synchronized void load(){
types = getAllTypes();
Map parserTypes = new LinkedMap(types);
ILayoutType rootType = this.getRootType();
layoutTypes.clear();
parserType(parserTypes,rootType.getTypeId(),layoutTypes);
}
/**
* 根节点检查，如果没有根节点就添加一个
*
*/
private Map getAllTypes(){
Map types = this.layoutDao.loadDataFromDB(null);
boolean findRoot = false;
Iterator itType = new LinkedList(types.values()).iterator();
while(itType.hasNext()){
ILayoutType layoutType = (ILayoutType)itType.next();
if(layoutType.getTypeName().equals(ROOT_NAME)){
findRoot = true;
break;
}
}
if(!findRoot){
//添加根节点
ILayoutType rootType =
this.layoutDao.addRootLayoutTypeToDB(ROOT_NAME);
//将所有没有父节点的一级节点置于根节点下
types = this.layoutDao.loadDataFromDB(null);
itType = new LinkedList(types.values()).iterator();
while(itType.hasNext()){
ILayoutType layoutType = (ILayoutType)itType.next();
if(layoutType.getParentTypeId()==null&&
!layoutType.getTypeName().equals(ROOT_NAME)){
layoutType.setParentTypeId(rootType.getTypeId());
this.layoutDao.updateLayoutTypeToDB(layoutType);
}
}
types = this.layoutDao.loadDataFromDB(null);
}
return types;
}
/**
* 递归收集某类型的所有子类型，入该类型层次桶，并将桶返回
*
* @param types
* @param parseTypeId
* @return
*/
private void parserType(Map types,Object parseTypeId,Map layoutMap){
Iterator itTypes = new LinkedList(types.values()).iterator();
while(itTypes.hasNext()){
ILayoutType type = (ILayoutType)itTypes.next();
if(type.getParentTypeId()!=null
&&type.getParentTypeId().equals(parseTypeId)){
Object layoutTypeId = type.getTypeId();
layoutMap.put(layoutTypeId,null);
types.remove(layoutTypeId);
}
}
Iterator itChildrenTypeId = layoutMap.keySet().iterator();
while(itChildrenTypeId.hasNext()){
Object childTypeId = itChildrenTypeId.next();
Map childLayoutMap = new LinkedMap();
layoutMap.put(childTypeId,childLayoutMap);
parserType(types,childTypeId,childLayoutMap);
}
}
// /**
// * 递归收集某类型的所有子类型，入该类型层次桶，并将桶返回
// *
// * @param types
// * @param parseTypeId
// * @return
// */
// private Map parserType(List types,Object parseTypeId){
// //提取当前层的子集
// Map oneLayoutTypes = new LinkedMap();
// //递归收集所有子类型入层次桶
// for(int i=0;types!=null&&i<types.size();){
// ILayoutType type = (ILayoutType)types.get(i);
// //遍历类型集合，如果是解析类型的子类型则递归解析子类型，并将子类型入层次桶
// if(type.getParentTypeId()!=null
// &&type.getParentTypeId().equals(parseTypeId)){
// //移出集合
// Object layoutTypeId = type.getTypeId();
// types.remove(i);
// //递归解析子类型
// Map childCarTypes = parserType(types,layoutTypeId);
// //将解析过的子类型入该类型层次桶
// oneLayoutTypes.put(layoutTypeId,childCarTypes);
// //找到子类型则重新遍历过
// i=0;
// }else{
// //遍历下一个
// i++;
// }
// }
// return oneLayoutTypes;
// }
/**
* 添加一个类型
* @param type
* @return
*/
public synchronized Object addLayoutType(ILayoutType add_type){
if(add_type==null) return null;
Object typeId = null;
//添加类型到数据库
ILayoutType type = layoutDao.addLayoutTypeToDB(add_type);
if(type!=null){
Object parentId = type.getParentTypeId();
//进层次桶
typeId = type.getTypeId();
Map parentLayout = this.getAnyLayoutMap(parentId);
parentLayout.put(typeId,new LinkedMap());
//进类型桶
types.put(typeId,type);
//通知观察者
if(this.dataChangeListener!=null){
this.setChanged();
this.notifyObservers(ILayoutTypeDataChangeListener.ADD_DATA);
}
}
return typeId;
}
* 更改一个类型
* @param type
* @return
*/
public synchronized boolean updateLayoutType(ILayoutType update_type){
if(update_type==null) return false;
//得到原类型
ILayoutType srcUpdateType = this.getLayoutType(update_type.getTypeId());
//更新数据库
boolean updateType = layoutDao.updateLayoutTypeToDB(update_type);
if(updateType){
//如果层次关系改变
if(srcUpdateType.getParentTypeId()!=null&&
update_type.getParentTypeId()!=null&&srcUpdateType.
getParentTypeId().equals(update_type.getParentTypeId())){
//从原桶移出
Map srcParentMap =
this.getAnyLayoutMap(srcUpdateType.getParentTypeId());
Map updateMap = (Map)srcParentMap.remove(update_type.getTypeId());
//添加到新桶
Map targetParentMap =
this.getAnyLayoutMap(update_type.getParentTypeId());
targetParentMap.put(update_type.getTypeId(),updateMap);
}
//进类型桶
types.put(update_type.getTypeId(),update_type);
//通知观察者
if(this.dataChangeListener!=null){
this.setChanged();
this.notifyObservers(ILayoutTypeDataChangeListener.UPDATE_DATA);
}
}
return updateType;
}
/**
* 删除一个类型
* @param typeId
* @return
*/
public synchronized boolean deleteLayoutType(Object typeId) throws HasChildTypeException{
Map childType = this.getAnyLayoutMap(typeId);
if(childType.size()>0) throw new HasChildTypeException(
"该类型有子类型，请将子类型删除再对删除该类型，类型id="+typeId);
boolean deleteOk = layoutDao.deleteLyoutTypeToDB(typeId);
if(deleteOk){
ILayoutType type = (ILayoutType)this.types.remove(typeId);
//从层次桶中移除
Map parentMap = this.getAnyLayoutMap(type.getParentTypeId());
parentMap.remove(typeId);
//通知观察者
if(this.dataChangeListener!=null){
this.setChanged();
this.notifyObservers(ILayoutTypeDataChangeListener.DELETE_DATA);
}
}
return deleteOk;
}
/**
* 删除一棵类型树：类型及其底下的所有子类型
* @param typeId
* @return
*/
public synchronized boolean deleteLayoutTypeTree(Object typeId){
Map allLayoutChildTypeIds = this.getAllLayoutChildTypeIds(typeId);
boolean isDelete =
this.layoutDao.deleteLayoutTypeToDB(allLayoutChildTypeIds.keySet());
if(isDelete){
this.load();
}
return isDelete;
}
/**
*
* @param typeId
* @return
*/
private Map getAllLayoutChildTypeIds(Object typeId){
Map allLayoutChildTypeIds = new LinkedMap();
Map childTypes = this.getAnyLayoutMap(typeId);
Iterator itChildTypes = childTypes.keySet().iterator();
while(itChildTypes.hasNext()){
Object childTypeId = itChildTypes.next();
Map childLayoutTypeIds = this.getAllLayoutChildTypeIds(childTypeId);
allLayoutChildTypeIds.putAll(childLayoutTypeIds);
}
allLayoutChildTypeIds.put(typeId,null);
return allLayoutChildTypeIds;
}
/**
* 根据id得到某一类型
* @param typeId
* @return
*/
public ILayoutType getLayoutType(Object typeId){
ILayoutType type = (ILayoutType)types.get(typeId);
if(type==null) return null;
return type.copyLayoutType();
}
/**
* 根据类型名得到某一类型
* @param typeName
* @return
*/
public ILayoutType getLayoutType(String typeName){
return null;
}
* 得到所有类型
* @return
*/
public Iterator getAllLayoutTypes(){
List srcTypes = new LinkedList(types.values());
Iterator itTypes = srcTypes.iterator();
List tmpTypes = new LinkedList();
while(itTypes.hasNext()){
ILayoutType type = (ILayoutType)itTypes.next();
tmpTypes.add(type.copyLayoutType());
}
srcTypes.clear();
return tmpTypes.iterator();
}
/**
* 得到某类型的递归类型
* @param typeId
* @return
*/
public ILayoutType[] getLayoutTypePath(Object typeId){
ILayoutType[] types = null;
try{
Object[] typePath = this.getLayoutPath(typeId);
types = new ILayoutType[typePath.length];
for(int i=0;i<types.length;i++){
types[i] = this.getLayoutType(typePath[i]);
}
}catch(Exception e){
e.printStackTrace();
}
return types;
}
/**
* 得到某类型的递归id路径
* @param typeId
* @return
*/
private Object[] getLayoutPath(Object typeId) throws Exception{
if(!types.containsKey(typeId))
throw new Exception("所有层车型分类中找不到该车型,车型标识是==" + typeId);
//得到类型对象
int layout = 0;
Object [] typeIds = new Object[10];
typeIds[layout++] = typeId;
//得到所有父层类型的id
ILayoutType type = (ILayoutType)types.get(typeId);
while(type.getParentTypeId()!=null){
Object id = type.getParentTypeId();
type = (ILayoutType)types.get(id);
typeIds[layout++] = type.getTypeId();
}
Object[] path = new Object[layout-1];
for(int i=layout-2,j=0;i>=0;i--,j++){
path[j] = typeIds[i];
}
return path;
}
/**
* 得到根层次桶
* @return
*/
public Map getRootLayoutMap(){
return this.layoutTypes;
}
/**
* 得到任意类型的层次桶
* @param typeId
* @return
*/
public Map getAnyLayoutMap(Object typeId){
Map layoutMap = new LinkedMap();
ILayoutType[] types = this.getLayoutTypePath(typeId);
try{
layoutMap = this.getAnyLayoutMap(types);
}catch(Exception e){
e.printStackTrace();
}
return layoutMap;
}
/**
* 根据类型标识路径得到该层的分层桶
*
* @param carTypeIds
* @return
* @throws Exception
*/
private synchronized Map getAnyLayoutMap(ILayoutType[] types) throws Exception{
Map layoutMap = this.layoutTypes;
int j=0;
for(int i=0;i<types.length;i++){
ILayoutType type = types[i];
Object typeId = type.getTypeId();
if(!layoutMap.containsKey(typeId)){
throw new Exception(
"第"+(j++)+"层找不到该类型,类型标识是=="+typeId);
}
layoutMap = (Map)layoutMap.get(typeId);
}
return layoutMap;
}
/**
* 得到任意类型的子类型
* @param typeId
* @return
*/
public Iterator getAnyLayoutTypes(Object typeId){
List layoutTypes = new LinkedList();
Map typeLayoutMap = this.getAnyLayoutMap(typeId);
Iterator itChildrenTypeIds = typeLayoutMap.keySet().iterator();
while(itChildrenTypeIds.hasNext()){
Object type = this.getLayoutType(itChildrenTypeIds.next());
if(type!=null)
layoutTypes.add(type);
}
return layoutTypes.iterator();
}
/**
* 返回根类型
* 根类型约定：ILayoutType的parentTypeId为null的认为是根类型
* @return
*/
public ILayoutType getRootType(){
if(root_type==null){
Iterator itTypes = new LinkedList(types.values()).iterator();
while(itTypes.hasNext()){
ILayoutType type = (ILayoutType)itTypes.next();
if(type.getParentTypeId()==null){
root_type = type;
break;
}
}
}
return root_type;
} public ILayoutTypeDAO getLayoutDao() {
return layoutDao;
} public void setLayoutDao(ILayoutTypeDAO layoutDao) {
this.layoutDao = layoutDao;
this.load();
} public ILayoutTypeDataChangeListener getDataChangeListener() {
return dataChangeListener;
} public void setDataChangeListener(ILayoutTypeDataChangeListener dataChangeListener) {
this.dataChangeListener = dataChangeListener;
}
}