org.umlg.runtime.collection.ocl.OclStdLibBagImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of runtime-domain Show documentation
There is a newer version: 2.0.16
package org.umlg.runtime.collection.ocl;

import com.google.common.collect.HashMultiset;
import com.google.common.collect.Multiset;
import org.umlg.runtime.collection.UmlgBag;
import org.umlg.runtime.collection.UmlgCollection;
import org.umlg.runtime.collection.UmlgSequence;
import org.umlg.runtime.collection.UmlgSet;
import org.umlg.runtime.collection.memory.UmlgMemoryBag;
import org.umlg.runtime.collection.memory.UmlgMemorySequence;
import org.umlg.runtime.collection.memory.UmlgMemorySet;

import java.util.*;

public class OclStdLibBagImpl extends OclStdLibCollectionImpl implements UmlgBag {

	private Multiset bag;

	/**
	 * A regular constructor compiles in eclipse but not in maven
	 * @param bag
	 * @return
	 */
	public static  OclStdLibBagImpl get(Collection bag) {
		return new OclStdLibBagImpl(HashMultiset.create(bag));
	}

	public OclStdLibBagImpl(Multiset bag) {
		super(bag);
		this.bag = bag;
	}

	@Override
	public Boolean equals(UmlgBag bag) {
        return this.bag.equals(bag);
	}

    //Important that the result, self and bag must be the union
	@Override
	public UmlgBag union(UmlgBag bag) {
        UmlgBag copy = new UmlgMemoryBag();
        Iterator iter = iterator();
        while (iter.hasNext()) {
            copy.add(iter.next());
        }
        for (E e : bag) {
            add(e);
        }
        iter = copy.iterator();
        while (iter.hasNext()) {
            bag.add(iter.next());
        }
		return this;
	}

	@Override
	public UmlgBag union(UmlgSet set) {
        UmlgBag result = new UmlgMemoryBag(this);
        for (E e : set) {
            result.add(e);
        }
        return result;
	}

	@Override
	public UmlgBag intersection(UmlgBag bag) {
        UmlgBag result = new UmlgMemoryBag();
        for (E e : bag) {
            if (contains(e)) {
                result.add(e);
            }
        }
        return result;
	}

	@Override
	public UmlgSet intersection(UmlgSet set) {
        UmlgSet result = new UmlgMemorySet();
        for (E e : bag) {
            if (contains(e)) {
                result.add(e);
            }
        }
        return result;
	}

    @Override
    public UmlgBag including(E e) {
        UmlgBag result = new UmlgMemoryBag(this);
        if (e != null) {
            result.add(e);
        }
        return result;
    }

    @Override
    public UmlgBag excluding(E e) {
        UmlgBag result = new UmlgMemoryBag(this);
        if (e != null) {
            result.remove(e);
        }
        return result;
    }

	/***************************************************
	 * Iterate goodies
	 ***************************************************/

	@SuppressWarnings("unchecked")
	@Override
	public  UmlgBag flatten() {
		if (needsFlattening()) {
			Multiset result = HashMultiset.create();
			for (E e : this.bag) {
				if (e instanceof UmlgCollection) {
					UmlgCollection collection = (UmlgCollection) e;
					result.addAll(collection. flatten());
				} else {
					result.add((T2) e);
				}
			}
			return new OclStdLibBagImpl(result);
		} else {
			return OclStdLibBagImpl.get((Collection) this.bag);
		}
	}
	
	/***************************************************
	 * Iterate goodies
	 ***************************************************/
	
	@Override
	public UmlgBag select(BooleanExpressionEvaluator v) {
		Multiset result = HashMultiset.create();
		for (E e : this.collection) {
			if (v.evaluate(e)) {
				result.add(e);
			}
		}
		return new OclStdLibBagImpl(result);
	}

	@Override
	public  UmlgBag collectNested(BodyExpressionEvaluator v) {
		Multiset result = HashMultiset.create();
		for (E e : this.bag) {
			R evaluate = v.evaluate(e);
			if (evaluate != null) {
				result.add(evaluate);
			}
		}
		return new OclStdLibBagImpl(result);
	}

	@Override
	public  UmlgBag collect(BodyExpressionEvaluator v) {
		return collectNested(v). flatten();
	}

	private boolean needsFlattening() {
		return !this.bag.isEmpty() && this.bag.iterator().next() instanceof UmlgCollection;
	}

	@Override
	public int count(Object element) {
		return this.bag.count(element);
	}

	@Override
	public int add(E element, int occurrences) {
		return this.bag.add(element, occurrences);
	}

	@Override
	public int remove(Object element, int occurrences) {
		return this.bag.remove(element, occurrences);
	}

	@Override
	public int setCount(E element, int count) {
		return this.bag.setCount(element, count);
	}

	@Override
	public boolean setCount(E element, int oldCount, int newCount) {
		return this.bag.setCount(element, oldCount, newCount);
	}

	@Override
	public Set elementSet() {
		return this.bag.elementSet();
	}

	@Override
	public Set> entrySet() {
		return this.bag.entrySet();
	}

	@Override
	public Iterator iterator() {
		return this.bag.iterator();
	}

	@Override
	public boolean contains(Object element) {
		return this.bag.contains(element);
	}

	@Override
	public boolean containsAll(Collection elements) {
		return this.bag.containsAll(elements);
	}

    @Override
    public boolean inverseAdder(E element) {
        return this.bag.add(element);
    }



	@Override
	public boolean add(E element) {
		return this.bag.add(element);
	}

	@Override
	public boolean remove(Object element) {
		return this.bag.remove(element);
	}

	@Override
	public boolean removeAll(Collection c) {
		return this.bag.removeAll(c);
	}

	@Override
	public boolean retainAll(Collection c) {
		return this.bag.retainAll(c);
	}

	@Override
	public boolean isEmpty() {
		return this.bag.isEmpty();
	}

	@Override
	public Object[] toArray() {
		return this.bag.toArray();
	}

	@Override
	public  T[] toArray(T[] a) {
		return this.bag.toArray(a);
	}

	@Override
	public boolean addAll(Collection c) {
		return this.bag.addAll(c);
	}

	@Override
	public void clear() {
		this.bag.clear();
	}

	@Override
	public String toJson() {
		throw new RuntimeException("Not yet implemented");
	}

	//Predefined Iterator Expressions
	@Override
	public UmlgSequence sortedBy(Comparator comparator) {
		ArrayList list = new ArrayList<>(this.bag);
		Collections.sort(list, comparator);
		UmlgSequence result = new UmlgMemorySequence<>(list);
		return result;
	}

}