Exemplo n.º 1
0
func CreateXmlIONodePosHint(n bh.NodeIf, path string) (xmln *backend.XmlNodePosHint) {
	if len(path) == 0 {
		xmln = backend.XmlNodePosHintNew(n.Name())
	} else {
		xmln = backend.XmlNodePosHintNew(fmt.Sprintf("%s/%s", path, n.Name()))
	}
	empty := image.Point{}
	for _, p := range n.PathList() {
		for _, m := range gr.ValidModes {
			xmlp := string(gr.CreatePathMode(p, m))
			pos := n.PathModePosition(p, m)
			if pos != empty {
				xmln.Entry = append(xmln.Entry, *backend.XmlModeHintEntryNew(xmlp, pos.X, pos.Y))
			}
		}
	}
	for _, p := range n.InPorts() {
		xmlp := backend.XmlPortPosHintNew(p.Name())
		xmlp.Entry = freesp.CreateXmlModePosition(p).Entry
		xmln.InPorts = append(xmln.InPorts, *xmlp)
	}
	for _, p := range n.OutPorts() {
		xmlp := backend.XmlPortPosHintNew(p.Name())
		xmlp.Entry = freesp.CreateXmlModePosition(p).Entry
		xmln.OutPorts = append(xmln.OutPorts, *xmlp)
	}
	return
}
Exemplo n.º 2
0
func (t *signalGraphType) AddNewObject(tree tr.TreeIf, cursor tr.Cursor, obj tr.TreeElementIf) (newCursor tr.Cursor, err error) {
	switch obj.(type) {
	case bh.NodeIf:
		// TODO: Check if IO node and exists: copy position only and return
		n := obj.(bh.NodeIf)
		err = t.AddNode(n)
		if err != nil {
			err = fmt.Errorf("signalGraphType.AddNewObject error: %s", err)
			nt := n.ItsType().(*nodeType)
			if nt != nil {
				ok, _ := nt.instances.Find(n)
				if ok {
					nt.instances.Remove(n)
				}
			}
			return
		}
		newCursor = t.treeAddNewObject(tree, cursor, n)

		parent := tree.Object(cursor)
		switch parent.(type) {
		case bh.SignalGraphIf:
		case bh.ImplementationIf:
			// propagate new node to all instances of embracing type
			pCursor := tree.Parent(cursor)
			nt := tree.Object(pCursor)
			for _, nn := range nt.(bh.NodeTypeIf).Instances() {
				nCursor := tree.Cursor(nn)
				tCursor := tree.CursorAt(nCursor, parent)
				tCursor.Position = cursor.Position
				t.treeAddNewObject(tree, tCursor, n)
			}

		default:
			log.Fatalf("signalGraphType.AddNewObject error: wrong parent type %T: %v\n", parent, parent)
		}

	case bh.ConnectionIf:
		conn := obj.(bh.ConnectionIf)
		var n bh.NodeIf
		var p bh.PortIf
		for _, n = range t.Nodes() {
			if n.Name() == conn.From().Node().Name() {
				nCursor := tree.CursorAt(cursor, n)
				for _, p = range n.OutPorts() {
					if conn.From().Name() == p.Name() {
						pCursor := tree.CursorAt(nCursor, p)
						return p.AddNewObject(tree, pCursor, obj)
					}
				}
			}
		}
	default:
		log.Fatalf("signalGraphType.AddNewObject error: wrong type %t: %v\n", obj, obj)
	}
	return
}
Exemplo n.º 3
0
func CreateXmlProcessingNode(n bh.NodeIf) *backend.XmlProcessingNode {
	ret := backend.XmlProcessingNodeNew(n.Name(), n.ItsType().TypeName())
	for _, p := range n.InPorts() {
		ret.InPort = append(ret.InPort, *CreateXmlInPort(p))
	}
	for _, p := range n.OutPorts() {
		ret.OutPort = append(ret.OutPort, *CreateXmlOutPort(p))
	}
	return ret
}
Exemplo n.º 4
0
func CreateXmlOutputNode(n bh.NodeIf) *backend.XmlOutputNode {
	tName := n.ItsType().TypeName()
	if strings.HasPrefix(tName, "autoOutputNodeType-") {
		tName = ""
	}
	ret := backend.XmlOutputNodeNew(n.Name(), tName)
	if n.(*node).portlink != nil {
		ret.NPort = n.(*node).portlink.Name()
	}
	for _, p := range n.InPorts() {
		ret.InPort = append(ret.InPort, *CreateXmlInPort(p))
	}
	return ret
}
Exemplo n.º 5
0
func addExpandedMappings(m mp.MappingIf, n bh.NodeIf, parentId bh.NodeIdIf) {
	idlist := m.MappedIds()
	nId := behaviour.NodeIdNew(parentId, n.Name())
	for _, id := range idlist {
		if nId.String() == id.String() {
			return
		}
	}
	melem := m.AddMapping(n, nId, nil)
	melem.SetExpanded(true)
	for _, impl := range n.ItsType().Implementation() {
		if impl.ImplementationType() == bh.NodeTypeGraph {
			for _, nn := range impl.Graph().ProcessingNodes() {
				addExpandedMappings(m, nn, nId)
			}
		}
	}
}
Exemplo n.º 6
0
func CreateXmlNodeMapList(m mp.MappingIf, n bh.NodeIf, path string) (xmln []backend.XmlNodeMap) {
	p, ok := m.Mapped(n.Name())
	if ok { // entire node is mapped to p:
		pname := fmt.Sprintf("%s/%s", p.Arch().Name(), p.Name())
		xmln = append(xmln, *CreateXmlNodeMap(path, pname))
	}
	nt := n.ItsType()
	for _, impl := range nt.Implementation() {
		if impl.ImplementationType() == bh.NodeTypeGraph {
			for _, nn := range impl.Graph().ProcessingNodes() {
				xmlnn := CreateXmlNodeMapList(m, nn, fmt.Sprintf("%s/%s", path, nn.Name()))
				for _, x := range xmlnn {
					xmln = append(xmln, x)
				}
			}
		}
	}
	return
}
Exemplo n.º 7
0
func findNodeInIdList(n bh.NodeIf, parent bh.NodeIdIf, idlist []bh.NodeIdIf) bool {
	nId := behaviour.NodeIdNew(parent, n.Name())
	log.Printf("findNodeInIdList: n=%s, parent=%v\n", n.Name(), parent)
	for _, id := range idlist {
		if nId.String() == id.String() {
			return true
		}
	}
	for _, impl := range n.ItsType().Implementation() {
		if impl.ImplementationType() == bh.NodeTypeGraph {
			for _, nn := range impl.Graph().ProcessingNodes() {
				if !findNodeInIdList(nn, nId, idlist) {
					return false
				}
			}
			return true
		}
	}
	return false
}
Exemplo n.º 8
0
func CreateXmlNodePosHint(nd bh.NodeIf, path string) (xmln []backend.XmlNodePosHint) {
	xmlnd := CreateXmlIONodePosHint(nd, path)
	xmlnd.Expanded = nd.Expanded()
	xmln = append(xmln, *xmlnd)
	nt := nd.ItsType()
	for _, impl := range nt.Implementation() {
		if impl.ImplementationType() == bh.NodeTypeGraph {
			for _, n := range impl.Graph().ProcessingNodes() {
				var p string
				if len(path) == 0 {
					p = nd.Name()
				} else {
					p = fmt.Sprintf("%s/%s", path, nd.Name())
				}
				hintlist := CreateXmlNodePosHint(n, p)
				for _, h := range hintlist {
					xmln = append(xmln, h)
				}
			}
			break
		}
	}
	return
}
Exemplo n.º 9
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
}