func (s *signalGraph) RemoveFromTree(tree tr.TreeIf) { gt := s.ItsType() tree.Remove(tree.Cursor(s)) for len(gt.Nodes()) > 0 { gt.RemoveNode(gt.Nodes()[0].(*node)) } }
func (t *nodeType) RemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parentId := tree.Parent(cursor) if t != tree.Object(parentId) { log.Fatal("nodeType.RemoveObject error: not removing child of mine.") } obj := tree.Object(cursor) del := t.treeRemoveObject(tree, cursor) for _, d := range del { removed = append(removed, d) } del = t.treeRemoveInstObject(tree, cursor) for _, d := range del { removed = append(removed, d) } prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, obj}) switch obj.(type) { case bh.ImplementationIf: impl := obj.(bh.ImplementationIf) // Remove obj in freesp model t.RemoveImplementation(impl) case bh.PortTypeIf: nt := obj.(bh.PortTypeIf) t.RemoveNamedPortType(nt) default: log.Fatalf("nodeType.RemoveObject error: invalid type %T\n", obj) } return }
func (n *node) RemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parentId := tree.Parent(cursor) if n != tree.Object(parentId) { log.Fatal("node.RemoveObject error: not removing child of mine.") } nt := n.ItsType() obj := tree.Object(cursor) switch obj.(type) { case bh.PortIf: p := obj.(bh.PortIf) for index, c := range p.Connections() { conn := p.Connection(c) removed = append(removed, tr.IdWithObject{cursor.Path, index, conn}) } var list portTypeList if p.Direction() == gr.InPort { list = nt.(*nodeType).inPorts } else { list = nt.(*nodeType).outPorts } _, ok, index := list.Find(p.Name()) if !ok { log.Println("node.RemoveObject: saving removed port", p) removed = append(removed, tr.IdWithObject{parentId.Path, index, obj}) } tree.Remove(cursor) default: log.Fatal("bh.NodeIf.RemoveObject error: invalid type %T", obj) } return }
func (p *process) RemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parent := tree.Parent(cursor) if p != tree.Object(parent) { log.Fatal("process.RemoveObject error: not removing child of mine.") } obj := tree.Object(cursor) switch obj.(type) { case pf.ChannelIf: c := obj.(pf.ChannelIf) cc := c.Link() pp := cc.Process() ppCursor := tree.Cursor(pp) // TODO. better search over platform... ccCursor := tree.CursorAt(ppCursor, cc) var l *channelList var ll *channelList if c.Direction() == gr.InPort { l = &p.inChannels ll = &pp.(*process).outChannels } else { l = &p.outChannels ll = &pp.(*process).inChannels } l.Remove(c) ll.Remove(cc) tree.Remove(ccCursor) prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, c}) default: log.Fatalf("Port.RemoveObject error: invalid type %T: %v\n", obj, obj) } return }
func (p *port) treeRemoveObject(tree tr.TreeIf, cursor tr.Cursor, conn bh.ConnectionIf, otherPort bh.PortIf) (removed []tr.IdWithObject) { contextCursor := tree.Parent(tree.Parent(tree.Parent(cursor))) pCursor := tree.CursorAt(contextCursor, otherPort) otherCursor := tree.CursorAt(pCursor, conn) prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, conn}) tree.Remove(otherCursor) return }
func (t *signalGraphType) RemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { obj := tree.Object(cursor) switch obj.(type) { case bh.NodeIf: n := obj.(bh.NodeIf) // Remove all connections first for _, p := range n.OutPorts() { for _, c := range p.Connections() { conn := p.Connection(c) cCursor := tree.CursorAt(cursor, conn) del := p.RemoveObject(tree, cCursor) for _, d := range del { removed = append(removed, d) } } } for _, p := range n.InPorts() { for _, c := range p.Connections() { conn := p.Connection(c) cCursor := tree.CursorAt(cursor, conn) del := p.RemoveObject(tree, cCursor) for _, d := range del { removed = append(removed, d) } } } parentCursor := tree.Parent(cursor) parent := tree.Object(parentCursor) switch parent.(type) { case bh.SignalGraphIf: case bh.ImplementationIf: // propagate new node to all instances of embracing type pCursor := tree.Parent(parentCursor) nt := tree.Object(pCursor) for _, nn := range nt.(bh.NodeTypeIf).Instances() { nCursor := tree.Cursor(nn) tCursor := tree.CursorAt(nCursor, parent) tree.Remove(tree.CursorAt(tCursor, n)) } default: log.Fatalf("signalGraphType.RemoveObject error: wrong parent type %t: %v\n", parent, parent) } prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, obj}) t.RemoveNode(n) default: log.Fatalf("signalGraphType.RemoveObject error: wrong type %t: %v", obj, obj) } return }
func (l *library) RemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parent := tree.Parent(cursor) if l != tree.Object(parent) { log.Fatal("library.RemoveObject error: not removing child of mine.") } obj := tree.Object(cursor) switch obj.(type) { case bh.SignalTypeIf: st := tree.Object(cursor).(bh.SignalTypeIf) for _, nt := range l.NodeTypes() { for _, p := range nt.InPorts() { if p.SignalType().TypeName() == st.TypeName() { log.Printf(`library.RemoveObject warning: bh.SignalTypeIf %v is still in use\n`, st) return } } for _, p := range nt.OutPorts() { if p.SignalType().TypeName() == st.TypeName() { log.Printf(`library.RemoveObject warning: bh.SignalTypeIf %v is still in use\n`, st) return } } } prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, obj}) l.RemoveSignalType(st) case bh.NodeTypeIf: nt := tree.Object(cursor).(bh.NodeTypeIf) log.Printf("library.RemoveObject: nt=%v\n", nt) if len(nt.Instances()) > 0 { log.Printf(`library.RemoveObject warning: The following nodes are still instances of bh.NodeTypeIf %s:\n`, nt.TypeName()) for _, n := range nt.Instances() { log.Printf(" %s\n", n.Name()) } return } prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, obj}) l.RemoveNodeType(nt) default: log.Fatalf("library.RemoveObject error: invalid type %T\n", obj) } return }
// Remove object mirrored in all instance node type func (t *nodeType) treeRemoveInstObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parentId := tree.Parent(cursor) if t != tree.Object(parentId) { log.Fatal("nodeType.RemoveObject error: not removing child of mine.") } obj := tree.Object(cursor) switch obj.(type) { case bh.ImplementationIf: for _, n := range t.Instances() { nCursor := tree.Cursor(n) tCursor := tree.CursorAt(nCursor, t) iCursor := tree.CursorAt(tCursor, obj) iCursor.Position = cursor.Position tree.Remove(iCursor) } case bh.PortTypeIf: nt := obj.(bh.PortTypeIf) for _, n := range t.Instances() { var p bh.PortIf var list []bh.PortIf nCursor := tree.Cursor(n) if nt.Direction() == gr.InPort { list = n.InPorts() } else { list = n.OutPorts() } for _, p = range list { if p.Name() == nt.Name() { break } } _ = p.(*port) pCursor := tree.CursorAt(nCursor, p) prefix, index := tree.Remove(pCursor) removed = append(removed, tr.IdWithObject{prefix, index, p}) tCursor := tree.CursorAt(nCursor, obj) del := t.treeRemoveObject(tree, tCursor) for _, d := range del { removed = append(removed, d) } tree.Remove(tCursor) } default: log.Fatalf("nodeType.RemoveObject error: invalid type %T\n", obj) } return }
func (m *mapping) RemoveFromTree(tree tr.TreeIf) { tree.Remove(tree.Cursor(m)) }
func (t *nodeType) treeRemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parentId := tree.Parent(cursor) if t != tree.Object(parentId) { log.Fatal("nodeType.RemoveObject error: not removing child of mine.") } obj := tree.Object(cursor) switch obj.(type) { case bh.ImplementationIf: impl := obj.(bh.ImplementationIf) if impl.ImplementationType() == bh.NodeTypeGraph { // TODO: This is redundant with implementation.go // Simply remove all nodes? Do not traverse a modifying list... // Removed Input- and Output nodes are NOT stored (they are // created automatically when adding the implementation graph). // Return all removed edges ... for _, n := range impl.Graph().Nodes() { nCursor := tree.Cursor(n) for _, p := range n.OutPorts() { pCursor := tree.CursorAt(nCursor, p) for index, c := range p.Connections() { conn := p.Connection(c) removed = append(removed, tr.IdWithObject{pCursor.Path, index, conn}) } } } // ... and processing nodes for _, n := range impl.Graph().ProcessingNodes() { nCursor := tree.Cursor(n) gCursor := tree.Parent(nCursor) nIndex := gCursor.Position removed = append(removed, tr.IdWithObject{nCursor.Path, nIndex, n}) } } case bh.PortTypeIf: nt := obj.(bh.PortTypeIf) for _, impl := range t.Implementation() { if impl.ImplementationType() == bh.NodeTypeGraph { // Remove and store all edges connected to the nodes linked to the outer ports g := impl.Graph().(*signalGraphType) var n bh.NodeIf if nt.Direction() == gr.InPort { n = g.findInputNodeFromPortType(nt) } else { n = g.findOutputNodeFromPortType(nt) } if n == nil { log.Fatalf("nodeType.RemoveObject error: invalid implementation...\n") } nCursor := tree.CursorAt(parentId, n) for _, p := range n.InPorts() { pCursor := tree.CursorAt(nCursor, p) for _, c := range p.Connections() { conn := p.Connection(c) removed = append(removed, tr.IdWithObject{pCursor.Path, -1, conn}) } } for _, p := range n.OutPorts() { pCursor := tree.CursorAt(nCursor, p) for _, c := range p.Connections() { conn := p.Connection(c) removed = append(removed, tr.IdWithObject{pCursor.Path, -1, conn}) } } // Remove (but dont store) the nodes linked to the outer ports: tree.Remove(nCursor) } } default: log.Fatalf("nodeType.RemoveObject error: invalid type %T\n", obj) } return }
func (a *arch) RemoveObject(tree tr.TreeIf, cursor tr.Cursor) (removed []tr.IdWithObject) { parent := tree.Parent(cursor) if a != tree.Object(parent) { log.Printf("arch.RemoveObject error: not removing child of mine.") return } obj := tree.Object(cursor) switch obj.(type) { case pf.IOTypeIf: t := obj.(pf.IOTypeIf) _, ok := a.iotypes.Find(t.Name()) if ok { a.iotypes.Remove(t) } else { log.Printf("arch.RemoveObject error: iotype to be removed not found.\n") } prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, t}) case pf.ProcessIf: p := obj.(pf.ProcessIf) if p.Arch() != a { log.Printf("arch.RemoveObject error: process to be removed is no child of mine.") } _, ok := a.processes.Find(p.Name()) if ok { a.processes.Remove(p) } else { log.Printf("arch.RemoveObject error: process to be removed not found.\n") } for _, c := range p.InChannels() { cc := c.Link() pp := cc.Process() ppCursor := tree.Cursor(pp) // TODO: better search over platform... ccCursor := tree.CursorAt(ppCursor, cc) //log.Printf("arch.RemoveObject: remove %v\n", cc) pp.(*process).outChannels.Remove(cc) prefix, index := tree.Remove(ccCursor) removed = append(removed, tr.IdWithObject{prefix, index, cc}) } for _, c := range p.InChannels() { p.(*process).inChannels.Remove(c) } for _, c := range p.OutChannels() { cc := c.Link() pp := cc.Process() ppCursor := tree.Cursor(pp) // TODO: better search over platform... ccCursor := tree.CursorAt(ppCursor, cc) //log.Printf("arch.RemoveObject: remove %v\n", cc) pp.(*process).inChannels.Remove(cc) prefix, index := tree.Remove(ccCursor) removed = append(removed, tr.IdWithObject{prefix, index, cc}) } for _, c := range p.OutChannels() { p.(*process).outChannels.Remove(c) } prefix, index := tree.Remove(cursor) removed = append(removed, tr.IdWithObject{prefix, index, p}) //log.Printf("arch.RemoveObject: successfully removed process %v\n", p) default: log.Fatalf("arch.AddNewObject error: invalid type %T\n", obj) } return }
func (l *library) RemoveFromTree(tree tr.TreeIf) { tree.Remove(tree.Cursor(l)) freesp.RemoveRegisteredLibrary(l) }