public Library(TypesTable tt, StandardTypeName naming) { RootNamespace = new Namespace(""); this.TypeTable = tt; LazyOperation = new Dictionary <Type, Action <Classifier> >(); TypeName = naming; }
public void CreateStandardLibrary(TypesTable tt) { lib = tt.Library; Namespace ns = lib.RootNamespace; // add default template / generic operation lib.DefaultLazyOperation = (c) => { // oclAsSet is problem on Set type (infinity recursion) if (c is CollectionType == false) { CollectionType set = lib.CreateCollection(CollectionKind.Set, c, true, tt.defferedCollectionList); AddOperation(c, Library.OclAsSet, set); } }; Classifier oclAny = new Classifier(tt, ns, lib.TypeName.Any); InsertClassifier(oclAny); Classifier real = new Classifier(tt, ns, lib.TypeName.Real, oclAny); InsertClassifier(real); Classifier integer = new Classifier(tt, ns, lib.TypeName.Integer, real); InsertClassifier(integer); Classifier unlimited = new Classifier(tt, ns, lib.TypeName.UnlimitedNatural, integer); InsertClassifier(unlimited); Classifier str = new Classifier(tt, ns, lib.TypeName.String, oclAny); InsertClassifier(str); Classifier boolean = new Classifier(tt, ns, lib.TypeName.Boolean, oclAny); InsertClassifier(boolean); Classifier message = new Classifier(tt, ns, lib.TypeName.Message, oclAny); InsertClassifier(message); Classifier type = new Classifier(tt, ns, lib.TypeName.Type, oclAny); InsertClassifier(type); Classifier voidT = new VoidType(tt, lib.TypeName.Void); InsertClassifier(voidT); Classifier invalid = new InvalidType(tt, lib.TypeName.Invalid); InsertClassifier(invalid); //OCLAny AddOperation(oclAny, "=", boolean, oclAny); AddOperation(oclAny, "<>", boolean, oclAny); AddOperation(oclAny, "oclIsUndefined", boolean); AddOperation(oclAny, "oclIsInvalid", boolean); //AddOperation(oclAny, "oclAsType", boolean); { Operation oclAsTypeOp = new Operation(@"oclAsType", true, tt.Library.Any, new Parameter[] { new Parameter("type", tt.Library.Type) }); oclAsTypeOp.ReturnTypeDependsOnArguments = true; oclAny.Operations.Add(oclAsTypeOp); } AddOperation(oclAny, "oclIsNew", boolean); //par dalsi operaci chybi //Real AddOperation(real, "+", real, real); AddOperation(real, "-", real, real); AddOperation(real, "*", real, real); AddOperation(real, "/", real, real); AddOperation(real, "-", real); AddOperation(real, "abs", real); AddOperation(real, "floor", real); AddOperation(real, "round", real); AddOperation(real, "max", real, real); AddOperation(real, "min", real, real); AddOperation(real, "<", boolean, real); AddOperation(real, ">", boolean, real); AddOperation(real, "<=", boolean, real); AddOperation(real, ">=", boolean, real); AddOperation(real, "toString", str); //integer AddOperation(integer, "+", integer, integer); AddOperation(integer, "-", integer, integer); AddOperation(integer, "*", integer, integer); AddOperation(integer, "/", integer, real); AddOperation(integer, "-", integer); AddOperation(integer, "abs", integer); AddOperation(integer, "div", integer, integer); AddOperation(integer, "mod", integer, integer); AddOperation(integer, "min", integer, integer); AddOperation(integer, "max", integer, integer); AddOperation(integer, "toString", str); //string AddOperation(str, "+", str, str); AddOperation(str, "size", integer); AddOperation(str, "concat", str, str); AddOperation(str, "substring", str, integer, integer); AddOperation(str, "toInteger", integer); AddOperation(str, "toReal", real); AddOperation(str, "toBoolean", boolean); AddOperation(str, "toUpperCase", str); AddOperation(str, "toLowerCase", str); AddOperation(str, "indexOf", integer, str); AddOperation(str, "equalsIgnoreCase", str, boolean); AddOperation(str, "at", str, integer); AddOperation(str, "<", str, boolean); AddOperation(str, ">", str, boolean); AddOperation(str, "<=", str, boolean); AddOperation(str, ">=", str, boolean); // string - non standard (known in XPath) AddOperation(str, "substring-before", str, str); AddOperation(str, "substring-after", str, str); AddOperation(str, "matches", str, str); AddOperation(str, "starts-with", str, str); AddOperation(str, "ends-with", str, str); //boolean AddOperation(boolean, "or", boolean, boolean); AddOperation(boolean, "xor", boolean, boolean); AddOperation(boolean, "and", boolean, boolean); AddOperation(boolean, "not", boolean); AddOperation(boolean, "implies", boolean, boolean); AddOperation(boolean, "toString", str); #region lazy operations lib.LazyOperation.Add(typeof(Classifier), (c) => { }); lib.LazyOperation.Add(typeof(CollectionType), (c) => { CollectionType coll = c as CollectionType; Classifier t = coll.ElementType; AddOperation(coll, "=", boolean, coll); AddOperation(coll, "<>", boolean, coll); AddOperation(coll, "size", integer); AddOperation(coll, "includes", boolean, coll.ElementType); AddOperation(coll, "excludes", boolean, coll.ElementType); AddOperation(coll, "count", integer, coll.ElementType); AddOperation(coll, "includesAll", boolean, coll); AddOperation(coll, "excludesAll", boolean, coll); AddOperation(coll, "isEmpty", boolean); AddOperation(coll, "notEmpty", boolean); /* TODO: musi splnovat nektere podminky (zatim nekontrolujeme) */ AddOperation(coll, "sum", t); AddOperation(coll, "max", t); AddOperation(coll, "min", t); //Missing: product, asSet, asOrdredSet,as sequence,asBag, flatten }); //Added by J.M. 2.3.2012, should not be under CollectionType //AddOperation(coll, "at", coll.ElementType, integer); //AddOperation(coll, "first", coll.ElementType); //AddOperation(coll, "last", coll.ElementType); lib.LazyOperation.Add(typeof(SetType), (c) => { CollectionType coll = c as CollectionType; Classifier t = coll.ElementType; AddOperation(coll, "union", coll, coll); //union with bag missing AddOperation(coll, "=", boolean, coll); AddOperation(coll, "intersection", coll, coll); //intersection with bag missing AddOperation(coll, "-", coll, coll); AddOperation(coll, "including", coll, t); AddOperation(coll, "excluding", coll, t); AddOperation(coll, "symmetricDifference", coll, coll); AddOperation(coll, "count", integer, t); //flatten missing AddOperation(coll, "asSet", coll); //asOrderedSet(),asSequence(),asBag() missing }); lib.LazyOperation.Add(typeof(SequenceType), (c) => { CollectionType coll = c as CollectionType; Classifier t = coll.ElementType; AddOperation(coll, "count", integer, t); AddOperation(coll, "=", boolean, coll); SetType set = (SetType)lib.CreateCollection(CollectionKind.Set, t, true, tt.defferedCollectionList); AddOperation(coll, "union", coll, coll); //flatten missing AddOperation(coll, "append", coll, t); AddOperation(coll, "prepend", coll, t); AddOperation(coll, "insertAt", coll, integer, t); AddOperation(coll, "subSequence", coll, integer, integer); AddOperation(coll, "at", coll.ElementType, integer); AddOperation(coll, "indexOf", integer, t); AddOperation(coll, "first", coll.ElementType); AddOperation(coll, "last", coll.ElementType); AddOperation(coll, "including", coll, t); AddOperation(coll, "excluding", coll, t); AddOperation(coll, "reverse", coll, t); AddOperation(coll, "asSequence", coll, t); AddOperation(coll, "asSet", set); //asOrderedSet(),asBag(),asSet() missing }); lib.LazyOperation.Add(typeof(BagType), (c) => { CollectionType coll = c as CollectionType; Classifier t = coll.ElementType; SetType set = (SetType)lib.CreateCollection(CollectionKind.Set, t, true, tt.defferedCollectionList); AddOperation(coll, "asSet", set); //asOrderedSet(),asBag(),asSet() missing }); #endregion // after lazy operations are defined can we use collection types CollectionType strSeq = lib.CreateCollection(CollectionKind.Sequence, str, true, tt.defferedCollectionList); tt.RegisterType(strSeq); AddOperation(str, "characters", strSeq); AddOperation(str, "tokenize", strSeq, str); tt.PerformDeferredInitializations(); }