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)
}