pnml

type Add ¶

type Add []Expression

Add is the type of add expressions.

func (p Add) AddEnv(env Env) Env

func (p Add) Eval(net *Net, venv VEnv) []Atom

func (p Add) String() string

func (p Add) Unify(net *Net, v *Value, venv VEnv) (int, error)

type All ¶

type All string

All is the type of all expressions.

func (p All) AddEnv(env Env) Env

func (p All) Eval(net *Net, venv VEnv) []Atom

func (p All) String() string

func (p All) Unify(net *Net, v *Value, venv VEnv) (int, error)

type Arc ¶

type Arc struct {
	Source  string `xml:"source,attr"`
	Target  string `xml:"target,attr"`
	XML     RawXML `xml:"hlinscription>structure"`
	Pattern Expression
}

Arc is the type of edges element in a PNML net.

type Atom ¶

type Atom struct {
	*Value
	Mult int
}

Atom is a pair of a multiplicity and a colored value.

type Constant ¶

type Constant string

Constant is the type of constant expressions.

func (p Constant) AddEnv(env Env) Env

func (p Constant) Eval(net *Net, venv VEnv) []Atom

func (p Constant) String() string

func (p Constant) Unify(net *Net, v *Value, venv VEnv) (int, error)

type Declaration ¶

type Declaration struct {
	Sorts      []*TypeDecl      `xml:"namedsort"`
	Vars       []*VarDecl       `xml:"variabledecl"`
	Partitions []*PartitionDecl `xml:"partition"`
}

Declaration is the type of a PNML net declaration. It contains declarations for types and variables used in the net. We also added partitions (and partitionelement) from model VehicularWifi

type Decoder ¶

type Decoder struct {
	*xml.Decoder
}

A Decoder represents an XML parser reading a particular input stream that should be a valid PNML file. It embeds an xml.Decoder for parsing a PNML stream passed as an io.Reader. Like with xml.Decoder, the parser assumes that its input is encoded in UTF-8.

func NewDecoder(r io.Reader) *Decoder

func (d *Decoder) Build(net *Net) error

type Dot ¶

type Dot struct{}

Dot is the type of dot constants.

func (p Dot) AddEnv(env Env) Env

func (p Dot) Eval(net *Net, venv VEnv) []Atom

func (p Dot) String() string

func (p Dot) Unify(net *Net, v *Value, venv VEnv) (int, error)

type Env ¶

type Env []string

Env is an environment, that is a sorted list of variable (names) occuring in an Expressions.

func (p Env) Extra(p2 Env) Env

func (p Env) String() string

type Expression ¶

type Expression interface {
	String() string
	AddEnv(Env) Env
	Eval(*Net, VEnv) []Atom
	Unify(*Net, *Value, VEnv) (int, error)
}

Expression is the interface that wraps the type of PNML expression (we only consider symmetric nets).

We assume that Add-expressions (like a + b) are always top-level and that <subtract> expressions cannot occur in the condition of an input arc.

AddEnv is used to accumulate the free variables in the Expression to an existing environment. It can be used to add the free variables of an expression to an alreay existing environment. It creates a (sorted) slice containing the names of all the variables.

Eval returns the set of constant values that match a ground Expression (an expression without free variables, such as the ones used to define the initial marking), together with their multiplicities.

Unify reports if a pattern expression matches a given *Value. For this we can use the VEnv to check that we respect previously unified variables. We can also update the VEnv by adding new associations. A return value of 0 means no match; otherwise it is the number of "copies" of the value that we need to match. Unify can change the values in the VEnv even if it fails. Unification can fail, for instance if there is an <All> expression in one of the input arc.

func SplitAdds(e Expression) []Expression

type FIRConstant ¶

type FIRConstant struct {
	// contains filtered or unexported fields
}

FIRConstant is the type of finite int range constant expressions.

func (p FIRConstant) AddEnv(env Env) Env

func (p FIRConstant) Eval(net *Net, venv VEnv) []Atom

func (p FIRConstant) String() string

func (p FIRConstant) Unify(net *Net, v *Value, venv VEnv) (int, error)

type FIRangeConstant ¶

type FIRangeConstant struct {
	Value int      `xml:"value,attr"`
	Range IntRange `xml:"finiteintrange"`
}

FIRangeConstant is used in PNML expressions.

type Fec ¶

type Fec struct {
	ID string `xml:"id,attr"`
}

Fec is the type of PNML enumeration constants.

type Hue ¶

type Hue []Atom

Hue is a slice of Atoms meant to represent the possible value in a colored place

func (pm Hue) Sum() int

type IntRange ¶

type IntRange struct {
	Start int `xml:"start,attr"`
	End   int `xml:"end,attr"`
}

IntRange is the type of PNML int ranges

type Marking ¶

type Marking []Hue

Marking is an association between places and Hues.

func (m0 Marking) Clone() Marking

type Net ¶

type Net struct {
	Name        string      `xml:"name>text"`
	Page        Page        `xml:"page"`
	Declaration Declaration `xml:"declaration>structure>declarations"`
	// TypeEnvt is an association between a variable name and its type name, found in declaration
	TypeEnvt map[string]string

	// Unique associates a Unique representant for each Value
	Unique map[Value]*Value
	// World associates a type (name) with a list of all its possible values
	World map[string][]*Value
	// contains filtered or unexported fields
}

Net is the type of the net element in a PNML file.

func (e *Net) Next(i int, val *Value) *Value

func (net *Net) PrintHue(pm Hue) string

func (net *Net) PrintValue(val *Value) string

func (net Net) String() string

type NumberConstant ¶

type NumberConstant struct {
	Value int `xml:"value,attr"`
}

NumberConstant is used in PNML expressions.

type Numberof ¶

type Numberof struct {
	Expression
	Mult int
}

Numberof is the type of numberof expressions in PNML. This is used to add a multiplicity Mult to an Expression in a multiset.

func (p Numberof) AddEnv(env Env) Env

func (p Numberof) Eval(net *Net, venv VEnv) []Atom

func (p Numberof) String() string

func (p Numberof) Unify(net *Net, v *Value, venv VEnv) (int, error)

type OP ¶

type OP int

OP is the type of operations in a PNML expression

const (
	NIL OP = iota
	EQ
	INEQ
	LESSTHAN
	LESSTHANEQ
	GREATTHAN
	GREATTHANEQ
	OR
	AND
)

func (p OP) String() string

type Operation ¶

type Operation struct {
	Op   OP
	Elem []Expression
}

Operation is the type of expressions that apply an operation to a slice of expressions.

func (p Operation) AddEnv(env Env) Env

func (p Operation) Eval(net *Net, venv VEnv) []Atom

func (p Operation) OK(net *Net, venv VEnv) bool

func (p Operation) String() string

func (p Operation) Unify(net *Net, v *Value, venv VEnv) (int, error)

type Page ¶

type Page struct {
	Places []*Place      `xml:"place"`
	Trans  []*Transition `xml:"transition"`
	Arcs   []*Arc        `xml:"arc"`
}

Page is the type of the page element in a PNML file.

type Partition ¶

type Partition struct {
	ID   string `xml:"id,attr"`
	Elem []Type `xml:"useroperator,omitempty"`
}

Partition list a subset of values of a given (enumeration) type.

type PartitionDecl ¶

type PartitionDecl struct {
	ID         string `xml:"id,attr"`
	Type       `xml:"usersort,omitempty"`
	Partitions []Partition `xml:"partitionelement,omitempty"`
}

PartitionDecl is the type of PNML partition declarations.

type Place ¶

type Place struct {
	ID             string `xml:"id,attr"`
	Type           Type   `xml:"type>structure>usersort"`
	XML            RawXML `xml:"hlinitialMarking>structure"`
	InitialMarking Expression
}

Place is the type of a PNML place. It can contain a type and an (optional) initial marking.

type RawXML ¶

type RawXML struct {
	InnerXML []byte `xml:",innerxml"`
}

RawXML is the type of PNML initial marking expressions, patterns and conditions.

type Subtract ¶

type Subtract []Expression

Subtract is the type of subtract expressions. It is an array of two expressions denoting the left and right elements of a subtract operation.

func (p Subtract) AddEnv(env Env) Env

func (p Subtract) Eval(net *Net, venv VEnv) []Atom

func (p Subtract) String() string

func (p Subtract) Unify(net *Net, v *Value, venv VEnv) (int, error)

type Successor ¶

type Successor struct {
	Var
	Incr int
}

Successor is the type of successor and predecessor operations.

func (p Successor) AddEnv(env Env) Env

func (p Successor) Eval(net *Net, venv VEnv) []Atom

func (p Successor) String() string

func (p Successor) Unify(net *Net, v *Value, venv VEnv) (int, error)

type TYP ¶

type TYP int

TYP describes the possible kind of PNML types in PNML.

const (
	DOT TYP = iota
	CENUM
	FENUM
	FINTRANGE
	PROD
	NUMERIC
)

func (i TYP) String() string

type Transition ¶

type Transition struct {
	ID        string `xml:"id,attr"`
	XML       RawXML `xml:"condition>structure"`
	Condition Operation
}

Transition is the type of a PNML transition. It can contain a type and an (optional) initial marking.

type Tuple ¶

type Tuple []Expression

Tuple is the type of tuple expressions.

func (p Tuple) AddEnv(env Env) Env

func (p Tuple) Eval(net *Net, venv VEnv) []Atom

func (p Tuple) String() string

func (p Tuple) Unify(net *Net, v *Value, venv VEnv) (int, error)

type Type ¶

type Type struct {
	ID string `xml:"declaration,attr"`
}

Type is the type of a type declaration.

type TypeDecl ¶

type TypeDecl struct {
	Sort    TYP
	Elem    []string
	ID      string    `xml:"id,attr"`
	CEnum   []Fec     `xml:"cyclicenumeration>feconstant,omitempty"`
	FEnum   []Fec     `xml:"finiteenumeration>feconstant,omitempty"`
	FIntRan *IntRange `xml:"finiteintrange,omitempty"`
	Product []Type    `xml:"productsort>usersort,omitempty"`
	Dot     *struct{} `xml:"dot,omitempty"`
}

TypeDecl is the type of PNML type declarations. We use a pointer field for Dot in order to discriminate to differentiate between default value and field initialized. Same with finite int range.

func (typ TypeDecl) String() string

type VEnv ¶

type VEnv map[string]*Value

VEnv is the type of association lists between environment variables and values.

func NewVEnv(env Env) VEnv

func (venv VEnv) Clone() VEnv

func (venv VEnv) Copy(venv2 VEnv)

func (venv VEnv) Reset(env Env)

func (venv VEnv) ResetAll()

type Value ¶

type Value struct {
	Head int
	Tail *Value
}

Value provides a more efficient representation for values

{0 nil} is a Dot {i nil} is Constant(name) where i uniquely identifies name {i {j {...}}} is for tuples we encode a range value, x, using a constant named _intx

type Var ¶

type Var string

Var is the type of variables.

func (p Var) AddEnv(env Env) Env

func (p Var) Eval(net *Net, venv VEnv) []Atom

func (p Var) String() string

func (p Var) Unify(net *Net, v *Value, venv VEnv) (int, error)

type VarDecl ¶

type VarDecl struct {
	ID   string `xml:"id,attr"`
	Type Type   `xml:"usersort"`
}

VarDecl is the type of PNML variable declarations.

type Variable ¶

type Variable struct {
	RefVariable string `xml:"refvariable,attr"`
}

Variable is used in PNML expressions.