From 9833a542bb75c2008c71809e4fdfebc41e67fb46 Mon Sep 17 00:00:00 2001 From: lresende Date: Tue, 10 Nov 2009 19:18:51 +0000 Subject: Move the SDO folder as new trunk for SDO sub project git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@834610 13f79535-47bb-0310-9956-ffa450edef68 --- .../apache/tuscany/sdo/util/VirtualSequence.java | 780 +++++++++++++++++++++ 1 file changed, 780 insertions(+) create mode 100644 sdo-java/trunk/impl/src/main/java/org/apache/tuscany/sdo/util/VirtualSequence.java (limited to 'sdo-java/trunk/impl/src/main/java/org/apache/tuscany/sdo/util/VirtualSequence.java') diff --git a/sdo-java/trunk/impl/src/main/java/org/apache/tuscany/sdo/util/VirtualSequence.java b/sdo-java/trunk/impl/src/main/java/org/apache/tuscany/sdo/util/VirtualSequence.java new file mode 100644 index 0000000000..a5982ceb35 --- /dev/null +++ b/sdo-java/trunk/impl/src/main/java/org/apache/tuscany/sdo/util/VirtualSequence.java @@ -0,0 +1,780 @@ +/** + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 org.apache.tuscany.sdo.util; + +import java.util.Iterator; +import java.util.List; + +import org.apache.tuscany.sdo.impl.ClassImpl; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EStructuralFeature; +import org.eclipse.emf.ecore.util.FeatureMapUtil; + +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.Sequence; + +/** + * SDO Sequance implementation which delegates to a Collection of DataObject properties. + */ +public class VirtualSequence implements Sequence +{ + private final DataObject dataObject; + protected final List delegateProperties; // size > 1 + + public VirtualSequence(DataObject object) + { + dataObject = object; + delegateProperties = ((ClassImpl)dataObject.getType()).getVirtualSequenceProperties(); + } + + static protected boolean isSequenceProperty(Object property) + { + return FeatureMapUtil.isFeatureMap((EStructuralFeature)property); + } + + public int size() + { + int size = 0; + for (Iterator iterator = delegateProperties.iterator() ; iterator.hasNext() ;) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + size += ((Sequence)dataObject.get(property)).size(); + else if (property.isMany()) + size += dataObject.getList(property).size(); + else + ++size; + } + return size; + } + + public Property getProperty(int index) + { + for (Iterator iterator = delegateProperties.iterator() ; iterator.hasNext() ;) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + { + Sequence sequence = (Sequence)dataObject.get(property); + int size = sequence.size(); + if (index < size) + return sequence.getProperty(index); + index -= size; + } + else if (property.isMany()) + { + int size = dataObject.getList(property).size(); + if (index < size) + return property; + index -= size; + } + else if (index == 0) + return property; + else + --index; + } + throw new IndexOutOfBoundsException(); + } + + public Object getValue(int index) + { + for (Iterator iterator = delegateProperties.iterator() ; iterator.hasNext() ;) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + { + Sequence sequence = (Sequence)dataObject.get(property); + int size = sequence.size(); + if (index < size) + return sequence.getValue(index); + index -= size; + } + else if (property.isMany()) + { + List values = dataObject.getList(property); + int size = values.size(); + if (index < size) + return values.get(index); + index -= size; + } + else if (index == 0) + return dataObject.get(property); + else + --index; + } + throw new IndexOutOfBoundsException(); + } + + public Object setValue(int index, Object value) + { + for (Iterator iterator = delegateProperties.iterator() ; iterator.hasNext() ;) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + { + Sequence sequence = (Sequence)dataObject.get(property); + int size = sequence.size(); + if (index < size) + return sequence.setValue(index, value); + index -= size; + } + else if (property.isMany()) + { + List values = dataObject.getList(property); + int size = values.size(); + if (index < size) + return values.set(index, value); + index -= size; + } + else if (index == 0) + { + Object old = dataObject.get(property); + dataObject.set(property, value); + return old; + } + else + --index; + } + throw new IndexOutOfBoundsException(); + } + + boolean validate(EStructuralFeature feature, Object property) + { + return FeatureMapUtil.getValidator((EClass)dataObject.getType(), feature).isValid((EStructuralFeature)property); + } + + boolean append(Property delegateProperty, Property property, Object value) + { + return ((Sequence)dataObject.get(delegateProperty)).add(property, value); + } + + boolean append(Property property, Object value) + { + return dataObject.getList(property).add(value); + } + + boolean set(Property property, Object value) + { + if (property.isMany()) + return append(property, value); + dataObject.set(property, value); + return true; + } + + public final boolean add(Property p, Object value) + { + Property property; + int size = delegateProperties.size(), index = size; + do + { + property = (Property)delegateProperties.get(--index); + if (!dataObject.isSet(property)) + continue; + EStructuralFeature feature = (EStructuralFeature)property; + if (FeatureMapUtil.isFeatureMap(feature)) + { + if (validate(feature, p)) + return append(property, p, value); + } + else if (property == p && property.isMany()) + return append(property, value); + if (size == ++index) + return false; + property = (Property)delegateProperties.get(index); + break; + } + while (index != 0); + for (;;) + { + EStructuralFeature feature = (EStructuralFeature)property; + if (FeatureMapUtil.isFeatureMap(feature)) + { + if (validate(feature, p)) + return append(property, p, value); + } + else if (property == p) + return set(p, value); + if (size == ++index) + return false; + property = (Property)delegateProperties.get(index); + } + } + + protected final Property property(String name) + { + return dataObject.getType().getProperty(name); + } + + public boolean add(String propertyName, Object value) + { + return add(property(propertyName), value); + } + + protected final Property property(int index) + { + return (Property)dataObject.getType().getProperties().get(index); + } + + public boolean add(int propertyIndex, Object value) + { + return add(property(propertyIndex), value); + } + + void insert(Property property, Property p, Object value) + { + ((Sequence)dataObject.get(property)).add(0, p, value); + } + + void insert(Property property, Object value) + { + dataObject.getList(property).add(0, value); + } + + protected final int insert(Iterator iterator, Property p, Object value) + { + while (iterator.hasNext()) + { + Property property = (Property)iterator.next(); + EStructuralFeature feature = (EStructuralFeature)property; + if (dataObject.isSet(property)) + { + if (FeatureMapUtil.isFeatureMap(feature)) + { + if (!validate(feature, p)) + return 2; + insert(property, p, value); + return 0; + } + if (property != p || !property.isMany()) + return 2; + insert(property, value); + return 0; + } + if (FeatureMapUtil.isFeatureMap(feature)) + { + if (validate(feature, p)) + { + append(property, p, value); + return 0; + } + } + else if (property == p) + { + set(property, value); + return 0; + } + } // iterator.hasNext() + return 1; + } + + public final void add(int index, Property p, Object value) + { + Iterator iterator = delegateProperties.iterator(); + if (index == 0) + switch (insert(iterator, p, value)) + { + case 0: + return; + case 1: + throw new IndexOutOfBoundsException(); + default: // 2 + throw new IllegalArgumentException(); + } + while (iterator.hasNext()) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + { + Sequence sequence = (Sequence)dataObject.get(property); + int size = sequence.size(); + if (index < size) + { + sequence.add(index, p, value); + return; + } + index -= size; + if (index != 0) + continue; + if (insert(iterator, p, value) != 0) + /*assert */sequence.add(p, value); + return; + } // sequence(property) + else if (property.isMany()) + { + List values = dataObject.getList(property); + int size = values.size(); + if (index < size) + { + values.add(index, value); + return; + } + index -= size; + if (index == 0 && property == p) + { + values.add(value); + return; + } + } + else if (index == 0) + throw new IllegalArgumentException(); + else + --index; + } + throw new IndexOutOfBoundsException(); + } + + public void add(int index, String propertyName, Object value) + { + add(index, property(propertyName), value); + } + + public void add(int index, int propertyIndex, Object value) + { + add(index, property(propertyIndex), value); + } + + public final void addText(String text) + { + throw new IllegalArgumentException(); + } + + /** + * @deprecated + */ + public void add(String text) + { + addText(text); + } + + public final void addText(int index, String text) + { + throw new IllegalArgumentException(); + } + + /** + * @deprecated + */ + public void add(int index, String text) + { + addText(index, text); + } + + public void remove(int index) + { + for (Iterator iterator = delegateProperties.iterator() ; iterator.hasNext() ;) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + { + Sequence sequence = (Sequence)dataObject.get(property); + int size = sequence.size(); + if (index < size) + { + sequence.remove(index); + return; + } + index -= size; + } + else if (property.isMany()) + { + List values = dataObject.getList(property); + int size = values.size(); + if (index < size) + { + values.remove(index); + return; + } + index -= size; + } + else if (index == 0) + { + dataObject.unset(property); + return; + } + else + --index; + } + throw new IndexOutOfBoundsException(); + } + + static private Object remove(Sequence sequence, int index) + { + Object value = sequence.getValue(index); + sequence.remove(index); + return value; + } + + static void move(Sequence fromSequence, int fromIndex, Sequence toSequence, int toIndex, Property property) + { + toSequence.add(toIndex, property, remove(fromSequence, fromIndex)); // removes containment + } + + static protected void move(Sequence fromSequence, int fromIndex, Sequence toSequence, int toIndex) + { + move(fromSequence, fromIndex, toSequence, toIndex, fromSequence.getProperty(fromIndex)); + } + + static protected void add(Object value,List list,int index, int size) + { + if (++index == size) + /*assert */list.add(value); + else + list.add(index, value); // removes containment + } + + static protected void add(Property property, Object value, Sequence toSequence, int toIndex, int size) + { + if (++toIndex == size) + toSequence.add(property, value); // removes containment + else + toSequence.add(toIndex, property, value); // removes containment + } + + public void move(int toIndex, int fromIndex) + { + for (Iterator iterator = delegateProperties.iterator(); iterator.hasNext() ;) + { + Property property = (Property)iterator.next(); + if (dataObject.isSet(property)) + if (isSequenceProperty(property)) + { + Sequence sequence = (Sequence)dataObject.get(property); + int size = sequence.size(); + if (toIndex < size) + { + if (fromIndex < size) + { + sequence.move(toIndex, fromIndex); + return; + } + while (iterator.hasNext()) + { + property = (Property)iterator.next(); + if (!dataObject.isSet(property)) + continue; + fromIndex -= size; + if (isSequenceProperty(property)) + { + Sequence fromSequence = (Sequence)dataObject.get(property); + size = fromSequence.size(); + if (fromIndex >= size) + continue; + move(fromSequence, fromIndex, sequence, toIndex); + return; + } + if (property.isMany()) + { + List list = dataObject.getList(property); + size = list.size(); + if (fromIndex >= size) + continue; + sequence.add(toIndex, property, list.remove(fromIndex)); // removes containment + return; + } + if (fromIndex == 0) + { + sequence.add(toIndex, property, dataObject.get(property)); // removes containment + dataObject.unset(property); + return; + } + size = 1; + } // iterator.hasNext() + break; + } // toIndex < size + if (fromIndex < size) + { + while (iterator.hasNext()) + { + property = (Property)iterator.next(); + if (!dataObject.isSet(property)) + continue; + toIndex -= size; + if (isSequenceProperty(property)) + { + Sequence toSequence = (Sequence)dataObject.get(property); + size = toSequence.size(); + if (toIndex >= size) + continue; + if (++toIndex == size) + toSequence.add(sequence.getProperty(fromIndex), remove(sequence, fromIndex)); // Java pushes stack from left to right + // removes containment + else + move(sequence, fromIndex, toSequence, toIndex); + return; + } + if (property.isMany()) + { + List list = dataObject.getList(property); + size = list.size(); + if (toIndex >= size) + continue; + if (sequence.getProperty(fromIndex) != property) + throw new IllegalArgumentException(); + add(remove(sequence, fromIndex), list, toIndex, size); + return; + } + if (toIndex == 0) + { + while (iterator.hasNext()) + { + Property p = sequence.getProperty(fromIndex); + property = (Property)iterator.next(); + EStructuralFeature feature = (EStructuralFeature)property; + if (dataObject.isSet(property)) + { + if (FeatureMapUtil.isFeatureMap(feature)) + { + /*if (!validate(feature, p)) + throw new IllegalArgumentException(); */ + move(sequence, fromIndex, (Sequence)dataObject.get(property), 0, p); + return; + } + if (property != p || !property.isMany()) + throw new IllegalArgumentException(); + insert(property, remove(sequence, fromIndex)); // removes containment + return; + } + if (FeatureMapUtil.isFeatureMap(feature)) + { + if (validate(feature, p)) + { + append(property, p, remove(sequence, fromIndex)); // removes containment + return; + } + } + else if (property == p) + { + set(property, remove(sequence, fromIndex)); + return; + } + } // iterator.hasNext() + break; + } + size = 1; + } // iterator.hasNext() + break; + } // fromIndex < size + toIndex -= size; + fromIndex -= size; + } // sequence(property) + else if (property.isMany()) + { + List list = dataObject.getList(property); + int size = list.size(); + if (toIndex < size) + { + if (fromIndex < size) + { + ((EList)list).move(toIndex, fromIndex); + return; + } + while (iterator.hasNext()) + { + Property p = (Property)iterator.next(); + if (!dataObject.isSet(p)) + continue; + fromIndex -= size; + if (isSequenceProperty(p)) + { + Sequence fromSequence = (Sequence)dataObject.get(p); + size = fromSequence.size(); + if (fromIndex >= size) + continue; + if (fromSequence.getProperty(fromIndex) != property) + throw new IllegalArgumentException(); + list.add(toIndex, remove(fromSequence, fromIndex)); // removes containment + return; + } + if (p.isMany()) + { + List l = dataObject.getList(p); + size = l.size(); + if (fromIndex >= size) + continue; + /*if (p != property) + throw new IllegalArgumentException(); */ + list.add(toIndex, l.remove(fromIndex)); // removes containment + return; + } + if (fromIndex == 0) + { + /*if (p != property) + throw new IllegalArgumentException(); */ + list.add(toIndex, dataObject.get(p)); // removes containment + dataObject.unset(p); + return; + } + size = 1; + } // iterator.hasNext() + break; + } // toIndex < size + if (fromIndex < size) + { + while (iterator.hasNext()) + { + Property p = (Property)iterator.next(); + if (!dataObject.isSet(p)) + continue; + toIndex -= size; + if (isSequenceProperty(p)) + { + Sequence toSequence = (Sequence)dataObject.get(p); + size = toSequence.size(); + if (toIndex >= size) + continue; + add(property, list.remove(fromIndex), toSequence, toIndex, size); + return; + } + if (p.isMany()) + { + List l = dataObject.getList(p); + size = l.size(); + if (toIndex >= size) + continue; + /*if (property != p) + throw new IllegalArgumentException(); */ + add(list.remove(fromIndex), l, toIndex, size); + return; + } + if (toIndex == 0) + { + while (iterator.hasNext()) + { + p = (Property)iterator.next(); + EStructuralFeature feature = (EStructuralFeature)p; + if (dataObject.isSet(p)) + { + if (FeatureMapUtil.isFeatureMap(feature)) + { + /*if (!validate(feature, property)) + throw new IllegalArgumentException(); */ + insert(p, property, list.remove(fromIndex)); + return; + } + if (/*p != property || */!p.isMany()) + throw new IllegalArgumentException(); + insert(p, list.remove(fromIndex)); // removes containment + return; + } + if (FeatureMapUtil.isFeatureMap(feature)) + { + if (!validate(feature, property)) + continue; + append(p, property, list.remove(fromIndex)); // removes containment + return; + } + else if (p == property) + { + set(p, list.remove(fromIndex)); + return; + } + } // iterator.hasNext() + break; + } // toIndex == 0 + size = 1; + } // iterator.hasNext() + break; + } // fromIndex < size + toIndex -= size; + fromIndex -= size; + } // property.isMany() + else if (toIndex == 0) + throw new IllegalArgumentException(); + else if (fromIndex == 0) + { + for (int size = 1; iterator.hasNext() ;) + { + Property p = (Property)iterator.next(); + if (!dataObject.isSet(p)) + continue; + toIndex -= size; + if (isSequenceProperty(p)) + { + Sequence toSequence = (Sequence)dataObject.get(p); + size = toSequence.size(); + if (toIndex >= size) + continue; + add(property, dataObject.get(property), toSequence, toIndex, size); + dataObject.unset(property); + return; + } + if (p.isMany()) + { + List l = dataObject.getList(p); + size = l.size(); + if (toIndex >= size) + continue; + /*if (property != p) + throw new IllegalArgumentException(); */ + add(dataObject.get(property), l, toIndex, size); + dataObject.unset(property); + return; + } + if (toIndex == 0) + { + while (iterator.hasNext()) + { + p = (Property)iterator.next(); + EStructuralFeature feature = (EStructuralFeature)p; + if (dataObject.isSet(p)) + if (FeatureMapUtil.isFeatureMap(feature)) + /*if (!validate(feature, property)) + throw new IllegalArgumentException(); */ + insert(p, property, dataObject.get(property)); + else if (/*p == property && */p.isMany()) + insert(p, dataObject.get(property)); // removes containment + else + throw new IllegalArgumentException(); + else if (FeatureMapUtil.isFeatureMap(feature)) + { + if (!validate(feature, property)) + continue; + append(p, property, dataObject.get(property)); // removes containment + } + else if (p == property) + set(p, dataObject.get(property)); + else + continue; + dataObject.unset(property); + return; + } // iterator.hasNext() + break; + } // toIndex == 0 + size = 1; + } // iterator.hasNext() + break; + } // fromIndex == 0 + else + { + --toIndex; + --fromIndex; + } + } + throw new IndexOutOfBoundsException(); + } +} -- cgit v1.2.3