//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006, 2007 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.edit.util;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.xmi.XMLResource;
import org.eclipse.epf.library.edit.util.model.ModelFactory;
import org.eclipse.epf.library.edit.util.model.OrderInfo;
import org.eclipse.epf.library.edit.util.model.OrderInfoCollection;
import org.eclipse.epf.library.edit.util.model.util.StringResource;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.util.AssociationHelper;
import org.eclipse.epf.uma.util.UmaUtil;
/**
*
* This class encapsulates all the logics used to retrieve the list of all
* contributed/inherited sections of the given element as well as allows
* manipulate this list.
*
* 1.5: Refactored to work on any VariabilityElement
*
* @author Lokanath Jagga
* @author Phong Nguyen Le
* @since 1.0
*/
public class ContentElementOrderList extends BasicEList {
/**
*
*/
private static final long serialVersionUID = 3257572797487069233L;
public static final String ORDER_INFO_NAME = "content elements"; //$NON-NLS-1$
private static final Map DEFAULT_SAVE_OPTIONS = new HashMap();
public static final int CONTENT_ELEMENTS__FOR_ELEMENT_ONLY = 1;
public static final int CONTENT_ELEMENTS__FOR_ELEMENT_AND_PARENTS = 2;
static {
DEFAULT_SAVE_OPTIONS.put(XMLResource.OPTION_ENCODING, "ASCII"); //$NON-NLS-1$
}
private VariabilityElement editElement;
private boolean mixed = true;
private boolean changed = false;
private EStructuralFeature feature;
private static boolean isContributor(VariabilityElement e) {
return TngUtil.isContributor(e);
}
public ContentElementOrderList(VariabilityElement e, int scope, EStructuralFeature feature) {
this.feature = feature;
editElement = e;
if (scope == CONTENT_ELEMENTS__FOR_ELEMENT_ONLY) {
mixed = false;
} else if (scope == CONTENT_ELEMENTS__FOR_ELEMENT_AND_PARENTS) {
calculateParentsOnly(e);
} else {
mixed = false;
}
}
private void calculateParentsOnly(VariabilityElement e) {
Iterator iter = null;
if (isContributor(e) || isExtended(e)) {
List supers = new ArrayList();
UmaUtil.getAllSupersBoth(supers, e,
VariabilityType.CONTRIBUTES,
VariabilityType.EXTENDS);
supers.add(e);
iter = supers.iterator();
} else {
mixed = false;
}
if (mixed) {
// create a map of GUID / contributor
OrderInfo latestInfo = null;
Map guidMap = new HashMap();
Set elements = new LinkedHashSet();
while (iter.hasNext()) {
VariabilityElement element = (VariabilityElement) iter.next();
List contentElements = new ArrayList();
Object eGet = ((VariabilityElement) element).eGet(feature);
if (eGet instanceof List) {
contentElements.addAll((List) eGet);
}
for (Iterator iterator = contentElements.iterator(); iterator
.hasNext();) {
DescribableElement categorizedElement = (DescribableElement) iterator
.next();
guidMap.put(categorizedElement.getGuid(),
categorizedElement);
elements.add(categorizedElement);
}
OrderInfo orderInfo = TngUtil.getOrderInfo(element,
ORDER_INFO_NAME);
if (orderInfo != null) {
if (latestInfo == null
|| orderInfo.getTimestamp() > latestInfo
.getTimestamp()) {
latestInfo = orderInfo;
}
}
}
if (latestInfo != null) {
// reorder the sections based on the latest order info
int size = latestInfo.getGUIDs().size();
for (int i = 0; i < size; i++) {
Object guid = latestInfo.getGUIDs().get(i);
Object element = guidMap.get(guid);
if (element != null) {
super.add(element);
elements.remove(element);
}
}
}
super.addAll(elements);
}
}
// deprecate the following constructor
public ContentElementOrderList(VariabilityElement e) {
editElement = e;
Iterator iter = null;
if (isContributor(e) || TngUtil.hasContributor(e)) {
VariabilityElement base = TngUtil.getBase(e);
iter = new AbstractTreeIterator(base) {
protected Iterator getChildren(Object object) {
List children = new ArrayList();
for (Iterator iterator = AssociationHelper
.getImmediateVarieties((VariabilityElement) object)
.iterator(); iterator.hasNext();) {
VariabilityElement element = (VariabilityElement) iterator
.next();
if (element.getVariabilityType() == VariabilityType.CONTRIBUTES) {
children.add(element);
}
}
return children.iterator();
}
};
} else if (isExtended(e)) {
System.out
.println("$$$ for " + e.getName() + " = extended is true"); //$NON-NLS-1$ //$NON-NLS-2$
List supers = new ArrayList();
UmaUtil.getAllSupers(supers, e, VariabilityType.EXTENDS);
supers.add(e);
iter = supers.iterator();
} else {
mixed = false;
}
if (mixed) {
// create a map of GUID / contributor
OrderInfo latestInfo = null;
Map guidMap = new HashMap();
List elements = new LinkedList();
while (iter.hasNext()) {
VariabilityElement element = (VariabilityElement) iter.next();
guidMap.put(element.getGuid(), element);
elements.add(element);
OrderInfo orderInfo = TngUtil.getOrderInfo(element,
ORDER_INFO_NAME);
if (orderInfo != null) {
if (latestInfo == null
|| orderInfo.getTimestamp() > latestInfo
.getTimestamp()) {
latestInfo = orderInfo;
}
}
}
if (latestInfo != null) {
// reorder the sections based on the latest order info
//
int size = latestInfo.getGUIDs().size();
for (int i = 0; i < size; i++) {
Object guid = latestInfo.getGUIDs().get(i);
Object element = guidMap.get(guid);
if (element != null) {
super.add(element);
elements.remove(element);
}
}
}
super.addAll(elements);
}
// else {
// // addAll(editElement.getPresentation().getSections());
// mixed = false;
// }
}
private static boolean isExtended(VariabilityElement e) {
return e.getVariabilityBasedOnElement() != null
&& e.getVariabilityType() == VariabilityType.EXTENDS;
}
/**
* Applies recent changes in the list
*
*/
public void apply() {
if (!mixed || !changed)
return;
// save the order info to the orderingGuide of the editElement
//
String str = editElement.getOrderingGuide();
OrderInfoCollection orderInfos = null;
StringResource res = null;
if (str == null || str.length() == 0) {
orderInfos = ModelFactory.eINSTANCE.createOrderInfoCollection();
} else {
res = new StringResource(str);
try {
res.load(null);
if (res.getContents().isEmpty()) {
orderInfos = ModelFactory.eINSTANCE
.createOrderInfoCollection();
} else {
orderInfos = (OrderInfoCollection) res.getContents().get(0);
}
} catch (IOException e) {
e.printStackTrace();
}
}
// find the order infor for sections
//
OrderInfo sectOrderInfo = null;
for (Iterator iter = orderInfos.getOrderInfos().iterator(); iter
.hasNext();) {
OrderInfo orderInfo = (OrderInfo) iter.next();
if (ORDER_INFO_NAME.equalsIgnoreCase(orderInfo.getName())) {
sectOrderInfo = orderInfo;
break;
}
}
if (sectOrderInfo == null) {
sectOrderInfo = ModelFactory.eINSTANCE.createOrderInfo();
sectOrderInfo.setName(ORDER_INFO_NAME);
orderInfos.getOrderInfos().add(sectOrderInfo);
} else {
sectOrderInfo.getGUIDs().clear();
}
int size = size();
for (int i = 0; i < size; i++) {
DescribableElement sect = (DescribableElement) get(i);
sectOrderInfo.getGUIDs().add(sect.getGuid());
}
sectOrderInfo.setTimestamp(System.currentTimeMillis());
if (res == null) {
res = new StringResource(null);
res.getContents().add(orderInfos);
}
try {
res.save(DEFAULT_SAVE_OPTIONS);
str = res.getString();
// System.out.println("SectionList.apply(): new ordering guide");
// System.out.println("------ orderingGuide start ------");
// System.out.println(str);
// System.out.println("------ orderingGuide end ------");
editElement.setOrderingGuide(str);
} catch (IOException e) {
e.printStackTrace();
} catch (RuntimeException e) {
e.printStackTrace();
}
}
public boolean canRemove(VariabilityElement contentElement) {
if (eGet().contains(contentElement)) {
return true;
}
return false;
}
public Object remove(int index) {
if (mixed) {
if (!canRemove((VariabilityElement) get(index)))
return null;
Object removed = super.remove(index);
eGet().remove(removed);
return removed;
} else {
return eGet().remove(index);
}
}
public boolean remove(Object o) {
if (!canRemove((VariabilityElement) o))
return false;
if (mixed) {
if (super.remove(o)) {
eGet().remove(o);
return true;
}
return false;
}
return eGet().remove(o);
}
public boolean removeAll(Collection c) {
if (mixed) {
boolean modified = false;
Iterator e = iterator();
while (e.hasNext()) {
Object o = e.next();
if (c.contains(o) && canRemove((VariabilityElement) o)) {
e.remove();
eGet().remove(o);
modified = true;
}
}
return modified;
} else {
return eGet().removeAll(c);
}
}
public void add(int index, Object element) {
if (mixed) {
super.add(index, element);
eGet().add(element);
changed = true;
} else {
eGet().add(index, element);
}
}
public boolean add(Object o) {
boolean b = eGet().add(o);
if (mixed) {
b = super.add(o);
if (b)
changed = true;
}
return b;
}
public boolean addAll(Collection c) {
boolean b = eGet().addAll(c);
;
if (mixed) {
b = super.addAll(c);
if (b)
changed = true;
}
return b;
}
public boolean addAll(int index, Collection c) {
if (mixed) {
eGet().addAll(c);
;
boolean b = super.addAll(index, c);
if (b)
changed = true;
}
return eGet().addAll(c);
}
public Object set(int index, Object element) {
if (mixed)
throw new UnsupportedOperationException();
return eGet().set(index, element);
}
public void clear() {
if (mixed)
throw new UnsupportedOperationException();
eGet().clear();
}
public void move(int index, Object object) {
if (mixed) {
super.move(index, object);
changed = true;
} else {
((EList) eGet()).move(index, object);
}
}
public Object move(int targetIndex, int sourceIndex) {
if (mixed) {
Object moved = super.move(targetIndex, sourceIndex);
changed = true;
return moved;
} else {
return eGet().move(targetIndex, sourceIndex);
}
}
public Object get(int index) {
if (mixed) {
return super.get(index);
} else {
return eGet().get(index);
}
}
public int size() {
if (mixed) {
return super.size();
} else {
return eGet().size();
}
}
public Iterator iterator() {
if (mixed) {
return super.iterator();
} else {
return eGet().iterator();
}
}
public boolean contains(Object object) {
if (mixed) {
return super.contains(object);
}
return eGet().contains(object);
}
public boolean containsAll(Collection collection) {
if (mixed)
return super.containsAll(collection);
return eGet().containsAll(collection);
}
public Object[] toArray() {
if (mixed) {
return super.toArray();
}
return eGet().toArray();
}
public Object[] toArray(Object[] array) {
if (mixed)
return super.toArray(array);
return eGet().toArray(array);
}
public int indexOf(Object object) {
if (mixed)
return super.indexOf(object);
return eGet().indexOf(object);
}
public int lastIndexOf(Object object) {
if (mixed)
return super.lastIndexOf(object);
return eGet().lastIndexOf(object);
}
public boolean isMixed() {
return mixed;
}
private EList eGet() {
EList list = null;
Object object = editElement.eGet(feature);
if (object instanceof EList) {
list = (EList) object;
}
if (list == null) {
list = new BasicEList();
}
return list;
}
}