module _'My.ecore'

{
	class Graph
	{
		property nodes#graph : Node[*] { ordered composes };
		property arrows#graph : Arrow[*] { ordered composes };
	}
	class Arrow extends NameElement
	{
		invariant noteq: source <> target;
		invariant ads: not source.oclIsUndefined() and not target.oclIsUndefined();
		property graph#arrows : Graph[?] { ordered };
		property source#outgoings : Node[1] { ordered };
		property target#incomings : Node[1] { ordered };
	}
	class Node extends NameElement
	{
		invariant x: true;
		property graph#nodes : Graph[?] { ordered };
		property incomings#target : Arrow[*] { ordered };
		property outgoings#source : Arrow[*] { ordered };
	}
	class NameElement
	{
		invariant checkName: checkName;
		attribute name : String[?] { ordered };
		attribute charSequence : String[*] { ordered derived transient unsettable volatile }
		{
			derivation: split(name, '^');
		}
		attribute checkName : Boolean[?] { ordered derived transient unsettable volatile }
		{
			derivation: split(name, '^')->forAll(s : String | isAlpah(s));
		}
		operation isAlpah(string : String[1]) : Boolean[1]
		{
			body:
				let seq : Sequence(String) = Sequence{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'} in charSequence(string.toLower())->forAll(a : String | seq->including(a));
		}
		operation charSequence(string : String[1]) : String[*]
		{
			body:
				let seq : Sequence(Integer) = Sequence{1..string.size()} in seq->collectNested(i : Integer | string.substring(i, i));
		}
		operation index(string : String[1], char : String[1]) : ecore::EInt[1]
		{
			body:
				let seq : Sequence(String) = charSequence(string) in if seq->count(char) > 0 then seq->indexOf(char) else 0 endif;
		}
		operation split(string : String[1], char : String[1]) : String[*]
		{
			body:
				let index : Integer = index(string, char) in if index < 1 then Sequence{string} else let other : Sequence(String) = if index < 2 then Sequence{''} else Sequence{string.substring(1, index - 1)} endif in if index + 1 <= string.size() then other->union(split(string.substring(index + 1, string.size()), char)->asSequence()) else other endif endif;
		}
	}
}

operation split(string : String[1], a : String[1]) : String[*]
		{
			body:
				let index : Integer = index(string, a) in if index = 0 then Sequence{string} else let other : Sequence(String) = if index = 1 then Sequence{''} else Sequence{string.substring(1, index - 1)} endif in if index + 1 <= string.size() then other->union(split(string.substring(index + 1, string.size()), a)->asSequence()) else other endif endif;
		}

operation charSequence(string : String[1]) : String[*]
		{
			body:
				let seq : Sequence(Integer) = Sequence{1..string.size()} in seq->collect(i : Integer | string.substring(i, i));
		}

public Value evaluate(EvaluationVisitor evaluationVisitor, CollectionValue sourceVal, LoopExp iteratorExp) {
		ValueFactory valueFactory = evaluationVisitor.getValueFactory();
		TypeManager typeManager = evaluationVisitor.getTypeManager();
		Type sourceType = iteratorExp.getSource().getType();
		boolean isOrdered = typeManager.isOrdered(sourceType);
		CollectionValue.Accumulator accumulatorValue = createAccumulationValue(valueFactory, isOrdered, false);
		return evaluateIteration(new IterationManager<CollectionValue.Accumulator>(evaluationVisitor,
				iteratorExp, sourceVal, accumulatorValue));
	}

operation isAlpah(string : String[1]) : Boolean[1]
{
	body:
		let seq : Sequence(String) = Sequence{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}
		in charSequence(string.toLower())->forAll(a : String | seq->includes(a));
}
operation charSequence(string : String[1]) : String[*]
{
	body:
		let seq : Sequence(Integer) = Sequence{1 .. string.size()}
		in seq->collect(i : Integer | string.substring(i, i));
}

/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public boolean isAlpah(String string) {
		try {
			return (Boolean)IS_ALPAH_STRING__EINVOCATION_DELEGATE.dynamicInvoke(this, new BasicEList.UnmodifiableEList<Object>(1, new Object[]{string}));
		}
		catch (InvocationTargetException ite) {
			throw new WrappedException(ite);
		}
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@SuppressWarnings("unchecked")
	public EList<String> charSequence(String string) {
		try {
			return (EList<String>)CHAR_SEQUENCE_STRING__EINVOCATION_DELEGATE.dynamicInvoke(this, new BasicEList.UnmodifiableEList<Object>(1, new Object[]{string}));
		}
		catch (InvocationTargetException ite) {
			throw new WrappedException(ite);
		}
	}

public void testGetCharSequence() {
		getFixture().setName("sfiefj(^asdfs");
		EList<String> result = getFixture().getCharSequence();
		System.out.println(result);
		assertTrue(result.size() == 2);
		System.out.println(result.get(0));
		assertFalse(getFixture().isAlpah(result.get(0)));
		System.out.println(result.get(1));
		assertTrue(getFixture().isAlpah(result.get(1)));
	}

assertFalse(getFixture().isAlpah(result.get(0)));

	public boolean isAlpah(String string) {
		try {
			for(String iter : charSequence(string)) // these two lines 
				System.out.println(iter);       // are added.
			return (Boolean)IS_ALPAH_STRING__EINVOCATION_DELEGATE.dynamicInvoke(this, new BasicEList.UnmodifiableEList<Object>(1, new Object[]{string}));
		}
		catch (InvocationTargetException ite) {
			throw new WrappedException(ite);
		}
	}