init repo

definition.go

@@ -0,0 +1,81 @@
+package workflow
+
+import (
+	"fmt"
+)
+
+type definition struct {
+	places        map[Place]Place
+	initialPlaces []Place
+	transitions   map[string]Transition
+}
+
+func NewDefinition(places []Place, initialPlace []Place, transitions []Transition) (definition, error) {
+	definition := &definition{
+		places:      map[Place]Place{},
+		transitions: map[string]Transition{},
+	}
+	definition.addPlaces(places)
+	if err := definition.addTransitions(transitions); err != nil {
+		return *definition, err
+	}
+	if err := definition.setInitialPlaces(initialPlace); err != nil {
+		return *definition, err
+	}
+	definition.initialPlaces = initialPlace
+	return *definition, nil
+}
+
+func MustNewDefinition(places []Place, initialPlaces []Place, transitions []Transition) definition {
+	definition, err := NewDefinition(places, initialPlaces, transitions)
+	if err != nil {
+		panic(err)
+	}
+	return definition
+}
+
+func (definition *definition) setInitialPlaces(places []Place) error {
+	for _, place := range places {
+		if _, ok := definition.places[place]; !ok {
+			return fmt.Errorf("place %s cannot be the initial place as it does not exist", place)
+		}
+	}
+	return nil
+}
+
+func (definition *definition) addPlaces(places []Place) {
+	for _, place := range places {
+		definition.addPlace(place)
+	}
+}
+
+func (definition *definition) addPlace(place Place) {
+	if _, ok := definition.places[place]; !ok {
+		definition.places[place] = place
+	}
+}
+
+func (definition *definition) addTransitions(transitions []Transition) error {
+	for _, transition := range transitions {
+		if err := definition.addTransition(transition); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (definition *definition) addTransition(transition Transition) error {
+	transitionName := transition.Name
+	for _, place := range transition.Froms {
+		if _, ok := definition.places[place]; !ok {
+			return fmt.Errorf("place %s referenced in transition %s does not exist", place, transitionName)
+		}
+	}
+	for _, place := range transition.Tos {
+		if _, ok := definition.places[place]; !ok {
+			return fmt.Errorf("place %s referenced in transition %s does not exist", place, transitionName)
+		}
+	}
+	definition.transitions[transitionName] = transition
+	return nil
+}

marking.go

@@ -1,15 +1,45 @@
 package workflow
 
+import (
+	"fmt"
+)
+
 type MarkingStorer interface {
-	GetMarking() *Marking
+	GetMarking(subject interface{}) (*Marking, error)
+	SetMarking(subject interface{}, marking Marking) error
+}
+
+type MethodMarkingStorer struct {
+}
+
+func (m *MethodMarkingStorer) GetMarking(subject interface{}) (*Marking, error) {
+	if v, ok := subject.(markedSubject); ok {
+		marking, err := v.GetMarking()
+		return &marking, err
+	}
+	return nil, fmt.Errorf("marking not found")
+}
+
+func (m *MethodMarkingStorer) SetMarking(subject interface{}, marking Marking) error {
+	if v, ok := subject.(markedSubject); ok {
+		return v.SetMarking(marking)
+	}
+	return fmt.Errorf("marking not found")
+}
+
+type markedSubject interface {
+	GetMarking() (Marking, error)
+	SetMarking(marking Marking) error
 }
 
 type Marking struct {
-	places []Place
+	places map[Place]Place
 }
 
 func NewMarking(representation ...Place) *Marking {
-	marking := new(Marking)
+	marking := &Marking{
+		places: map[Place]Place{},
+	}
 	for _, place := range representation {
 		marking.Mark(place)
 	}
@@ -18,30 +48,26 @@ func NewMarking(representation ...Place) *Marking {
 }
 
 func (m *Marking) Mark(place Place) {
-	m.places = append(m.places, place)
+	if _, ok := m.places[place]; !ok {
+		m.places[place] = place
+	}
 }
 
 func (m *Marking) Unmark(p Place) {
-	var newPlaces []Place
-	for _, place := range m.places {
-		if place != p {
-			newPlaces = append(newPlaces, place)
-		}
+	if _, ok := m.places[p]; ok {
+		delete(m.places, p)
 	}
-
-	m.places = newPlaces
 }
 
 func (m *Marking) Has(place Place) bool {
-	for _, currentPlace := range m.places {
-		if currentPlace == place {
-			return true
-		}
-	}
-
-	return false
+	_, has := m.places[place]
+	return has
 }
 
 func (m *Marking) GetPlaces() []Place {
-	return m.places
+	var places []Place
+	for _, place := range m.places {
+		places = append(places, place)
+	}
+	return places
 }