Ejemplo n.º 1
0
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
}
Ejemplo n.º 2
0
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}
}
Ejemplo n.º 3
0
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
}
Ejemplo n.º 4
0
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)
}
Ejemplo n.º 5
0
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
}
Ejemplo n.º 6
0
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)
				}
			}
		}
	}
}
Ejemplo n.º 7
0
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
}