func createNodeTypeFromXml(xmlnt backend.XmlNodeType, filename string, context mod.ModelContextIf) *nodeType { nt := NodeTypeNew(xmlnt.TypeName, filename) for _, xmlp := range xmlnt.InPort { pType, ok := freesp.GetSignalTypeByName(xmlp.PType) if !ok { log.Fatalf("createNodeTypeFromXml error: FIXME: signal type '%s' not found\n", xmlp.PType) } pt := PortTypeNew(xmlp.PName, pType.TypeName(), gr.InPort) //for _, xmlmp := range xmlp.Entry { // pt.position[freesp.ModeFromString[xmlmp.Mode]] = image.Point{xmlmp.X, xmlmp.Y} //} nt.inPorts.Append(pt) //nt.addInPort(xmlp.PName, pType) } for _, xmlp := range xmlnt.OutPort { pType, ok := freesp.GetSignalTypeByName(xmlp.PType) if !ok { log.Fatalf("createNodeTypeFromXml error: FIXME: signal type '%s' not found\n", xmlp.PType) } pt := PortTypeNew(xmlp.PName, pType.TypeName(), gr.OutPort) //for _, xmlmp := range xmlp.Entry { // pt.position[freesp.ModeFromString[xmlmp.Mode]] = image.Point{xmlmp.X, xmlmp.Y} //} nt.outPorts.Append(pt) //nt.addOutPort(xmlp.PName, pType) } for _, i := range xmlnt.Implementation { var iType bh.ImplementationType if len(i.SignalGraph) == 1 { iType = bh.NodeTypeGraph } else { iType = bh.NodeTypeElement } impl := ImplementationNew(i.Name, iType, context) nt.implementation.Append(impl) switch iType { case bh.NodeTypeElement: impl.elementName = i.Name default: var err error var resolvePort = func(name string, dir gr.PortDirection) *portType { return nt.doResolvePort(name, dir) } impl.graph, err = createSignalGraphTypeFromXml(&i.SignalGraph[0], xmlnt.TypeName, context, resolvePort) if err != nil { log.Fatal(err) } } } return nt }
func PortTypeNew(name string, pTypeName string, dir gr.PortDirection) *portType { st, ok := freesp.GetSignalTypeByName(pTypeName) if !ok { log.Fatalf("NamedPortTypeNew error: FIXME: signal type '%s' not defined\n", pTypeName) } return &portType{st, name, dir} }
func createNodeTypeFromXmlNode(n backend.XmlNode, ntName string) *nodeType { nt := NodeTypeNew(ntName, "") for _, p := range n.InPort { pType, ok := freesp.GetSignalTypeByName(p.PType) if !ok { log.Fatalf("createNodeTypeFromXmlNode error: FIXME signal type '%s' not found\n", p.PType) } nt.addInPort(p.PName, pType) } for _, p := range n.OutPort { pType, ok := freesp.GetSignalTypeByName(p.PType) if !ok { log.Fatalf("createNodeTypeFromXmlNode error: FIXME signal type '%s' not found\n", p.PType) } nt.addOutPort(p.PName, pType) } freesp.RegisterNodeType(nt) return nt }
func OutputNodeNew(name string, stypeName string, context bh.SignalGraphTypeIf) (ret *node, err error) { st, ok := freesp.GetSignalTypeByName(stypeName) if !ok { err = fmt.Errorf("InputNodeNew error: signaltype %s not defined", stypeName) return } ntName := createOutputNodeTypeName(stypeName) nt, ok := freesp.GetNodeTypeByName(ntName) if !ok { nt = NodeTypeNew(ntName, "") nt.(*nodeType).addInPort("", st) freesp.RegisterNodeType(nt) } return NodeNew(name, nt, context) }
func SignalTypeNew(name, ctype, msgid string, scope bh.Scope, mode bh.Mode, definedAt string) (t *signalType, err error) { newT := &signalType{name, ctype, msgid, scope, mode, definedAt} sType, ok := freesp.GetSignalTypeByName(name) if ok { if !signalTypeCpmpatible(newT, sType) { err = fmt.Errorf(`SignalTypeNew error: adding existing signal type %s, which is incompatible`, name) return } log.Printf(`SignalTypeNew: warning: adding existing signal type definition %s (taking the existing)`, name) t = sType.(*signalType) } else { t = newT freesp.RegisterSignalType(t) } return }
func TestSignalType(t *testing.T) { case1 := []struct { remove, name, ctype, msgid string scope bh.Scope mode bh.Mode isLegal bool }{ /* * If 'remove' is not empty, the signal shall be removed * (all other fields are irrelevant). * If 'remove' is empty, try to register the signal given by * all the other definitions. * * 'isLegal' is the expected behaviour: true: testcase shall * be successful, false: testcase shall fail * * Compatible duplicates are allowed (all fields identical!), * but duplicates are registered only once. * * TreeElementIf interface not tested. */ {"", "s1", "", "", 0, 0, true}, {"", "s1", "", "", 0, 0, true}, // compatible duplicate {"", "s1", "int", "", 0, 0, false}, // incompatible duplicate {"", "s2", "int", "ch1", 0, 0, true}, // new {"", "s2", "int", "ch1", 0, 1, false}, // incompatible duplicate {"", "s2", "int", "ch1", 1, 0, false}, // incompatible duplicate {"", "s2", "int", "ch1", 0, 0, true}, // compatible duplicate {"s1", "", "", "", 0, 0, true}, // remove {"s1", "", "", "", 0, 0, false}, // remove duplicate {"s3", "", "", "", 0, 0, false}, // remove non-existing {"", "s1", "int", "", 0, 0, true}, // new (after removal) } freesp.Init() for i, c := range case1 { if len(c.remove) > 0 { s, success := freesp.GetSignalTypeByName(c.remove) if success != c.isLegal { t.Errorf("TestSignalType testcase %d failed, could not find %s\n", i, c.remove) } else if success { SignalTypeDestroy(s) } } else { s, err := SignalTypeNew(c.name, c.ctype, c.msgid, c.scope, c.mode) success := (err == nil) if success != c.isLegal { t.Errorf("TestSignalType testcase %d failed, err=%v.\n", i, err) } else if success { if s.TypeName() != c.name { t.Errorf("TestSignalType testcase %d failed, TypeName().\n", i) } if s.CType() != c.ctype { t.Errorf("TestSignalType testcase %d failed, CType().\n", i) } if s.ChannelId() != c.msgid { t.Errorf("TestSignalType testcase %d failed, ChannelId().\n", i) } if s.Scope() != c.scope { t.Errorf("TestSignalType testcase %d failed, Scope().\n", i) } if s.Mode() != c.mode { t.Errorf("TestSignalType testcase %d failed, Mode().\n", i) } } } } }
func (j *NewElementJob) CreateObject(fts *models.FilesTreeStore) (ret tr.TreeElementIf, err error) { var parentObject tr.TreeElementIf parentObject, err = fts.GetObjectById(j.parentId) if err != nil { log.Fatal("NewElementJob.CreateObject error: referenced parentObject run away...") } switch j.elemType { case eNode, eInputNode, eOutputNode: var context bh.SignalGraphTypeIf switch parentObject.(type) { case bh.NodeIf: context = parentObject.(bh.NodeIf).Context() j.parentId = getParentId(j.parentId) case bh.SignalGraphIf: context = parentObject.(bh.SignalGraphIf).ItsType() case bh.SignalGraphTypeIf: context = parentObject.(bh.SignalGraphTypeIf) case bh.ImplementationIf: if parentObject.(bh.ImplementationIf).ImplementationType() == bh.NodeTypeGraph { context = parentObject.(bh.ImplementationIf).Graph() } else { log.Fatal("NewElementJob.CreateObject(eNode) error: parent implementation is no graph...") } default: log.Fatal("NewElementJob.CreateObject(eNode) error: referenced parentObject wrong type...") } if j.elemType == eNode { ntype, ok := freesp.GetNodeTypeByName(j.input[iNodeTypeSelect]) if !ok { log.Fatal("NewElementJob.CreateObject(eNode) error: referenced parentObject type wrong...") } ret, err = behaviour.NodeNew(j.input[iNodeName], ntype, context) } else if j.elemType == eInputNode { ret, err = behaviour.InputNodeNew(j.input[iInputNodeName], j.input[iInputTypeSelect], context) } else { ret, err = behaviour.OutputNodeNew(j.input[iOutputNodeName], j.input[iOutputTypeSelect], context) } if len(j.extra) > 0 { coords := strings.Split(j.extra, "|") var x, y int fmt.Sscanf(coords[0], "%d", &x) fmt.Sscanf(coords[1], "%d", &y) //pos := image.Point{x, y} //log.Printf("NewElementJob.CreateObject(eNode) setting position %s: %v\n", j.extra, pos) //ret.(bh.NodeIf).SetPosition(pos) // TODO: SetModePosition... } case eNodeType: var context string switch parentObject.(type) { case bh.NodeTypeIf: context = parentObject.(bh.NodeTypeIf).DefinedAt() j.parentId = getParentId(j.parentId) case bh.SignalTypeIf: j.parentId = getParentId(j.parentId) parentObject, err = fts.GetObjectById(j.parentId) context = parentObject.(bh.LibraryIf).Filename() case bh.LibraryIf: context = parentObject.(bh.LibraryIf).Filename() default: log.Fatal("NewElementJob.CreateObject(eNodeType) error: referenced parentObject wrong type...") } ret = behaviour.NodeTypeNew(j.input[iTypeName], context) case eConnection: switch parentObject.(type) { case bh.PortIf: case bh.SignalGraphTypeIf: fromTo := strings.Split(j.extra, "/") var n bh.NodeIf for _, n = range parentObject.(bh.SignalGraphTypeIf).Nodes() { if n.Name() == fromTo[0] { for _, parentObject = range n.OutPorts() { if parentObject.(bh.PortIf).Name() == fromTo[1] { break } } break } } if parentObject == nil { log.Fatalf("NewElementJob.CreateObject(eNodeType) error: no valid FROM port for edge job %v\n", j) } _ = parentObject.(bh.PortIf) case bh.ImplementationIf: fromTo := strings.Split(j.extra, "/") var n bh.NodeIf for _, n = range parentObject.(bh.ImplementationIf).Graph().Nodes() { if n.Name() == fromTo[0] { for _, parentObject = range n.OutPorts() { if parentObject.(bh.PortIf).Name() == fromTo[1] { break } } break } } if parentObject == nil { log.Fatalf("NewElementJob.CreateObject(eNodeType) error: no valid FROM port for edge job %v\n", j) } _ = parentObject.(bh.PortIf) default: log.Fatalf("NewElementJob.CreateObject(eConnection) error: referenced parentObject wrong type %T\n", parentObject) } ports := getMatchingPorts(fts, parentObject) for _, p := range ports { s := fmt.Sprintf("%s/%s", p.Node().Name(), p.Name()) if j.input[iPortSelect] == s { var from, to bh.PortIf if p.Direction() == gr.InPort { from = parentObject.(bh.PortIf) to = p } else { from = p to = parentObject.(bh.PortIf) } ret = behaviour.ConnectionNew(from, to) break } } case ePortType: switch parentObject.(type) { case bh.PortTypeIf: j.parentId = getParentId(j.parentId) case bh.NodeTypeIf: default: log.Fatal("NewElementJob.CreateObject(ePortType) error: referenced parentObject wrong type...") } _, ok := freesp.GetSignalTypeByName(j.input[iSignalTypeSelect]) if !ok { err = fmt.Errorf("NewElementJob.CreateObject(ePortType) error: referenced signal type wrong...") return } ret = behaviour.PortTypeNew(j.input[iPortName], j.input[iSignalTypeSelect], string2direction[j.input[iDirection]]) case eSignalType: switch parentObject.(type) { case bh.SignalTypeIf: j.parentId = getParentId(j.parentId) case bh.NodeTypeIf: j.parentId = getParentId(j.parentId) case bh.LibraryIf: default: log.Fatalf("NewElementJob.CreateObject(eSignalType) error: referenced parentObject wrong type %T\n", parentObject) } parentObject, err = fts.GetObjectById(j.parentId) if err != nil { log.Fatalf("NewElementJob.CreateObject(eSignalType) error: parent library object not found\n") } name := j.input[iSignalTypeName] cType := j.input[iCType] channelId := j.input[iChannelId] scope := string2scope[j.input[iScope]] mode := string2mode[j.input[iSignalMode]] ret, err = behaviour.SignalTypeNew(name, cType, channelId, scope, mode, parentObject.(bh.LibraryIf).Filename()) if err != nil { log.Printf("NewElementJob.CreateObject(eSignalType) error: SignalTypeNew failed: %s\n", err) return } case eImplementation: switch parentObject.(type) { case bh.ImplementationIf: j.parentId = getParentId(j.parentId) case bh.NodeTypeIf: default: log.Fatalf("NewElementJob.CreateObject(eSignalType) error: referenced parentObject wrong type %T\n", parentObject) } implType := string2implType[j.input[iImplementationType]] ret = behaviour.ImplementationNew(j.input[iImplName], implType, &global) case eArch: switch parentObject.(type) { case pf.ArchIf: j.parentId = getParentId(j.parentId) parentObject = parentObject.(pf.ArchIf).Platform() case pf.PlatformIf: default: log.Fatalf("NewElementJob.CreateObject(eArch) error: referenced parentObject wrong type %T\n", parentObject) } ret = platform.ArchNew(j.input[iArchName], parentObject.(pf.PlatformIf)) case eIOType: var p pf.PlatformIf switch parentObject.(type) { case pf.IOTypeIf: j.parentId = getParentId(j.parentId) p = parentObject.(pf.IOTypeIf).Platform() case pf.ArchIf: p = parentObject.(pf.ArchIf).Platform() default: log.Fatalf("NewElementJob.CreateObject(eIOType) error: referenced parentObject wrong type %T\n", parentObject) } ret, err = platform.IOTypeNew(j.input[iIOTypeName], gr.IOMode(j.input[iIOModeSelect]), p) case eProcess: switch parentObject.(type) { case pf.ProcessIf: j.parentId = getParentId(j.parentId) parentObject = parentObject.(pf.ProcessIf).Arch() case pf.ArchIf: default: log.Fatalf("NewElementJob.CreateObject(eProcess) error: referenced parentObject wrong type %T\n", parentObject) } ret = platform.ProcessNew(j.input[iProcessName], parentObject.(pf.ArchIf)) case eChannel: switch parentObject.(type) { case pf.ChannelIf: j.parentId = getParentId(j.parentId) parentObject = parentObject.(pf.ChannelIf).Process() case pf.ProcessIf: default: log.Fatalf("NewElementJob.CreateObject(eChannel) error: referenced parentObject wrong type %T\n", parentObject) } processes := getOtherProcesses(fts, parentObject) var p pf.ProcessIf for _, p = range processes { s := fmt.Sprintf("%s/%s", p.Arch().Name(), p.Name()) if s == j.input[iChannelLinkSelect] { break } } if p == nil { log.Fatalf("NewElementJob.CreateObject(eChannel) error: can't find chosen process\n", j.input[iChannelLinkSelect]) } ioType, ok := freesp.GetIOTypeByName(j.input[iIOTypeSelect]) if !ok { log.Fatalf("NewElementJob.CreateObject(eChannel) error: can't find chosen ioType\n", j.input[iIOTypeSelect]) } ret = platform.ChannelNew(string2direction[j.input[iChannelDirection]], ioType, parentObject.(pf.ProcessIf), j.input[iChannelLinkSelect]) default: log.Fatal("NewElementJob.CreateObject error: invalid elemType ", j.elemType) } return }