Ad/2010-08-01 Concrete Syntax for a uml action Language for Foundational uml (Alf) Second Revised Submission
Alf Standard Library Collection Classes Implementation
Download 1.74 Mb.
|
- Navigate this page:
- CollectionClasses::Impl
- CollectionClasses::Impl::CollectionImpl
- CollectionClasses::Impl::OrderedCollectionImpl
- CollectionClasses::Impl::Set
- CollectionClasses::Impl::OrderedSet
- CollectionClasses::Impl::Bag
- CollectionClasses::Impl::List
- CollectionClasses::Impl::Queue
- CollectionClasses::Impl::Deque
- CollectionClasses::Impl::Map
Alf Standard Library Collection Classes ImplementationThis example provides a sample implementation for the Alf Standard Library CollectionClasses package in Alf itself. As discussed in Subclause 11.6, implementations for these classes are supplied in the nested CollectionClasses::Impl package. Annex B.4.1 presents the Alf representation of the CollectionClasses::Impl ipackage, with the following subclauses giving Alf units for each of the classes contained in this package. Note that this is not intended to be an efficient, production implementation of the collection class package. Rather, it is intended to provide a concrete example of the use of the Impl mechanism for the collection classes and to demonstrate that all the behavior specified for the collection classes can be implemented in Alf using other features.
The CollectionClasses::Impl package is required to contain the classes shown in Figure 11 -78. The Alf implementation given for the package below also includes two additional classes that are used to factor out common behavior from the collection classes (other than Map). The package is also marked as a model library, so that it does not automatically import the Alf standard library itself (see Subclause 10.1). namespace Alf::Library::Collections::CollectionClasses; @ModelLibrary package Impl { private class CollectionImpl private class OrderedCollectionImpl public class Set specializes CollectionImpl public class Bag specializes CollectionImpl public class OrderedSet specializes OrderedCollectionImpl public class List specializes OrderedCollectionImpl public class Queue specializes CollectionImpl public class Deque specializes CollectionImpl public class Map }
The abstract CollectionImpl class provides implementations for the operations (other than toSequence) common to all collection classes other than Map. The actual collection content is expected to be supplied by the concrete subclasses of CollectionImpl. The CollectionImpl operation method use abstract methods setContent and toSequence, to be defined in the subclasses, to set and get this content. Note that, since the Impl package is stereotyped as a model library, the usual importation of standard library packages is suppressed. Therefore, the CollectionFunctions package must be explicitly imported in order to make the collection functions usable without qualification. The collection functions are imported privately, as required by the rules of Subclause 11.6 for the implementation of collection classes. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /**
The base concrete implementation for all the standard library collection classes. */ abstract class CollectionImpl @Create protected CollectionImpl(in seq: T[0..*] sequence) { this.setContent(seq); }
result = this.excludes(element); this.setContent(this.toSequence()->including(element)); return result; }
preSize = this.size(); this.setContent(this.toSequence()->union(seq)); return this.size() > preSize; }
this.setContent(null); }
return this.toSequence()->count(element); }
return this.toSequence()->equals(seq); }
return this.toSequence()->excludes(element); }
return this.toSequence()->excludesAll(element); }
return this.toSequence()->includes(element); }
return this.toSequence()->includesAll(element); }
return this.toSequence()->isEmpty(); }
return this.toSequence()->notEmpty(); }
result = this.count(element); this.setContent(this.toSequence()->excluding(element)); return result; }
preSize = this.size(); this.setContent(this.toSequence()->difference(seq)); return this.size() < preSize; }
result = self.includes(element); this.setContent(this.toSequence()->excludingOne(element)); return result; }
result = this.count(element); this.setContent(this.toSequence()->replacing(element, newElement)); return result; }
result = this.includes(element); this.setContent(this.toSequence()->replacingOne(element, newElement)); return result; }
preSize = this.size(); this.setContent(this.toSequence()->intersection(seq)); return this.size() < preSize(); }
return this.toSequence()->size(); } }
The class OrderedCollectionImpl extends CollectionImpl with implementation of additional operations found in the ordered collection classes (i.e., OrderedSet and List). namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The base concrete implementation for the standard library ordered collection classes */ abstract class OrderedCollectionImpl @Create protected OrderedCollectionImpl(in seq: T[0..*] sequence) { super(seq); }
preSize = this.size(); this.setContent(this.toSequence()->includeAllAt(index, seq)); return this.size() > preSize; } public addAt (in index: Integer, in element: T): Boolean { return addAllAt(index, element); } public at (in index: Integer): T[0..1] { return this.toSequence()->at(index); } public first (): T[0..1] { return this.at(1); } public indexOf (in element: T) : Integer[0..1] { return this.toSequence()->indexof(element); } public last (): T[0..1] { return this.at(this.size()); } public removeAt (in index: Integer): T[0..1] { result = this.at(index); this.setContent(this.toSequence()->excludeAt(index)); return result; } public replaceAt (in index: Integer, in element: T): T[0..1] { result = this.at(index); this.setContent(this.toSequence()->replacingAt(index, element)); return result; } }
The Set class given below implements the abstract CollectionClasses::Set class. It does this by defining a content attribute of the appropriate type with unbounded multiplicity. By default, the attribute is unique and unordered—that is, a set. Operation methods are provided by specializing the CollectionImpl class. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template Set class. */ class Set private content: T[0..*]; @Create public Set (in seq: T[0..*] sequence): Set super.CollectionImpl(seq); }
super.CollectionImpl }
this.content = seq; }
return super.CollectionImpl } public equals (in seq: T[0..*] sequence): Boolean { set = seq->toOrderedSet(); return this.size() == set->size() && this.includesAll(set); } public toSequence (): T[0..*] sequence { return this.content; } }
The OrderedSet class given below implements the abstract CollectionClasses::OrderedSet class. It does this by defining a content attribute of the appropriate type with unbounded multiplicity. The attribute is specifically defined to be ordered and is unqiue by default—that is, it is an ordered set. Operation methods are provided by specializing the OrderedCollectionImpl class. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template OrderedSet class. */ class OrderedSet specializes OrderedCollectionImpl private content: T[0..*] ordered; @Create public OrderedSet (in seq: T[0..*] sequence): OrderedSet super.OrderedCollectionImpl(seq->toOrderedSet()); }
super.OrderedCollectionImpl }
this.content = seq; }
return super.OrdredCollcetionImpl }
return super.OrderedCollectionImpl } public addAllAt (in index: Integer, in seq: T[0..*] sequence): Boolean { return super.OrderedCollectionImpl } public replaceAt (in index: Integer, in element: T): T[0..1] { result = this.at(index); if (result->notEmpty()) { this.remove(result); this.addAt(index, element); } return result; } public subOrderedSet (in lower: Integer, in upper: Integer): OrderedSet return new OrderedSet(this.toSequence()->subsequence(lower, upper)); } public toSequence(): T[0..*] sequence { return this.content; } }
The Bag class given below implements the abstract CollectionClasses::Set class. It does this by defining a content attribute of the appropriate type with unbounded multiplicity. The attribute is specifically defined to be nonunique and is ordered by default—that is, it is a bag. Operation methods are provided by specializing the CollectionImpl class. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template Bag class. */ class Bag private content: T[0..*] nonunique; @Create public Bag (in seq: T[0..*] sequence): Bag super.OrderedCollectionImpl(seq); }
super.CollectionImpl } private setContent(in seq: T[0..*] sequence) { this.content = seq; }
return this.size() == seq->size() && this.includesAll(seq); } public toSequence(): T[0..*] sequence { return this.content; } }
The List class given below implements the abstract CollectionClasses::List class. It does this by defining a content attribute of the appropriate type with unbounded multiplicity defined as a sequence—that is, a nonunique, ordered list. Operation methods are provided by specializing the OrderedCollectionImpl class. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template List class. */ class List specializes OrderedCollectionImpl private content: T[0..*] sequence; @Create public List (in seq: T[0..*] sequence): List super.OrderedCollectionImpl(seq); }
super.OrderedCollectionImpl }
this.content = seq; } public subList (in lower: Integer, in upper: Integer): OrderedSet return new List(this.toSequence()->subsequence(lower, upper)); } public toSequence(): T[0..*] sequence { return this.content; } }
The List class given below implements the abstract CollectionClasses::List class. It does this by defining a content attribute of the appropriate type with unbounded multiplicity defined as a sequence—that is, a nonunique, ordered list. Operation methods are provided by specializing the CollectionImpl class. Even though a queue is effectively ordered, it does not provide all the operations defined for other ordered classes and, therefore, does not specialize the OrderedCollectionImpl class. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template Queue class. */ class Queue private content: T[0..*] sequence; @Create public Queue (in seq: T[0..*] sequence): Queue super.CollectionImpl(seq); }
super.CollectionImpl }
this.content = seq; } public addLast (in element : T): Boolean { return this.add(element); } public first(): T[0..1] { return this.toSequence()->first(); } public removeFirst (): T[0..1] { result = this.toSequence()->first(); this.setContent(this.toSequence->subsequence(2,this.size())); return result; } public removeFirstOne (in element: T): T[0..*] { return this.removeOne(element); }
return this.content; } }
The Deque class given below implements the abstract CollectionClasses::Deque class. It does this by extending the Queue implementation class with the additional operations defined for a Deque. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template Deque class. */ class Deque @Create public Deque (in seq: T[0..*] sequence): Deque super(seq); }
super.destroy(); }
this.setContent(this.toSequence()->includeAt(1, element)); return true; } public last (): T[0..1] { return this.toSequence()->last(); } public removeLast (): T[0..1] { result = this.last(); this.setContent(this.toSequence()->subsequence(1,this.size()-1)); return result; } public removeLastOne (in element: T): T[0..1] { result = null; i = this.size(); while (i > 0 && result == null) { e = this.toSequence()->at(i); if (e == element) { result = e; this.setContent(this.toSequence()->excludeAt(i)); } i = i – 1; } return result; } public toSequence (): T[0..*] sequence { return this.content; } }
The Map class given below implements the abstract CollectionClasses::List Map. It does this by storing a set of entries in an attribute. Lookup of entries is implemented in the private indexOf operation. namespace Alf::Library::Collections::CollectionClasses::Impl; private import Alf::Library::FunctionBehaviors::Collections::CollectionFunctions::*; /** The concrete implementation of the standard library template Map class. */ class Map private entries: Entry[0..*]; @Create public Map (in entries: Entry[0..*]): Map this.putAll(entries); }
}
return new Set }
this.entries = null; }
return this.entries->excludesAll(entries); }
return this.entries->select e (e.key == key)[1].value; }
return this.entries->includesAll(entries); }
return this.entries.key->includes(key); }
return this.entries.value->includes(value); }
return this.entries->isEmpty(); }
return new Set }
return this.entries->notEmpty(); }
result = this.remove(key); this.entries->add(new Entry(key,value)); return result; }
entries->iterate e (this.put(e.key, e.value)); }
result = this.get(key); this.entries = this.entries->reject e (e.key == key); return result; }
this.entries = this.entries->reject e (keys->includes(e.key)); }
this.entries->size(); }
return this.entries; }
return new Bag } } Directory: spec spec -> Illinois state board of education spec -> Volume Ⅴ (2015) On The 2015 China Victory Day Parade spec -> General information spec -> Topeka capital-journal spec -> P-8153 Frederick Tilp II (upper right) with plumbers who worked for him spec -> Catalog of My Wine Library Thomas Pinney Claremont, California 2004 note spec -> Unique 00225 Mobile Barrier (2015 Specifications: 12-04-14) spec -> Annual Conference " Initium Novum" spec -> Petroleum Development Oman L. L. C. Document Title: Specification for hse cases Download 1.74 Mb. Share with your friends:
|