Rework for performances

command.go

@@ -26,18 +26,15 @@ func cmdHead(config *configCollect) {
   log.Println("Proposing following HEAD:\n"+rc.Head.Content.String())
 }
 
+
+type LsWalker struct { }
+func (lw* LsWalker) onDir(dn *DirNode) {
+  log.Println(dn.String())
+}
+func (lw* LsWalker) onFile(fn *FileNode) {
+  log.Println(fn.String())
+}
 func cmdLs(config *configCollect) {
-  rf := NewRepoFs(config)
+  en := NewEntryNode(config)
-  rf.EntryNode.Walk(ExpandOnlyDirectory, -1)
+  en.Walk(new(LsWalker))
-
-  stackFolders := []*DirNode{rf.EntryNode}
-  for len(stackFolders) > 0 {
-    fold := stackFolders[0]
-    stackFolders = append(stackFolders[1:], fold.Folders...)
-
-    log.Println(fold.String())
-    for _, file := range fold.Files {
-      log.Println(file.String())
-    }
-  }
 }

fs.go

@@ -43,9 +43,6 @@ type DirNode struct {
   Config *configCollect
   Ent *DirEnt
   Elem DirElem
-  Folders []*DirNode
-  Files []*FileNode
-  Parent *DirNode
   AbsolutePath string
 }
 
@@ -56,34 +53,27 @@ type FileNode struct {
   AbsolutePath string
 }
 
-type RepoFs struct {
+type TreeObserver interface {
-  Config *configCollect
+  onDir(dir *DirNode)
-  EntryNode *DirNode
+  onFile(file *FileNode)
 }
 
-func NewRepoFs(config *configCollect) *RepoFs {
+func NewEntryNode(config *configCollect) *DirNode {
-  rf := new(RepoFs)
+  entryNode := new(DirNode)
-  rf.Config = config
+  entryNode.Ent = new(DirEnt)
-  rf.EntryNode = new(DirNode)
+  entryNode.Ent.Id = config.DirId
-  rf.EntryNode.Ent = new(DirEnt)
+  entryNode.Ent.Name = ""
-  rf.EntryNode.Ent.Id = config.DirId
+  entryNode.AbsolutePath = "/"
-  rf.EntryNode.Ent.Name = ""
+  entryNode.Config = config
-  rf.EntryNode.AbsolutePath = "/"
-  rf.EntryNode.Files = make([]*FileNode,0)
-  rf.EntryNode.Folders = make([]*DirNode,0)
-  rf.EntryNode.Config = config
 
-  return rf
+  return entryNode
 }
 
 func NewDirNode(parent *DirNode, ent *DirEnt) *DirNode {
   dn := new(DirNode)
   dn.Ent = ent
   dn.Config = parent.Config
-  dn.Files = make([]*FileNode,0)
+  dn.AbsolutePath = parent.AbsolutePath + ent.Name + "/"
-  dn.Folders = make([]*DirNode,0)
-  dn.Parent = parent
-  dn.AbsolutePath = dn.Parent.AbsolutePath + ent.Name + "/"
 
   return dn
 }
@@ -118,16 +108,6 @@ func (dn* DirNode) Parse() {
   jdec := json.NewDecoder(zfile)
   err = jdec.Decode(&dn.Elem)
   if err != nil { log.Fatal(err) }
-
-  for _, el := range dn.Elem.Entries {
-    if IsDir(el.Mode) {
-      dn.Folders = append(dn.Folders, NewDirNode(dn, el))
-    } else if IsRegular(el.Mode) {
-      dn.Files = append(dn.Files, NewFileNode(dn, el))
-    } else {
-      log.Fatal("Unknown mode", el.Mode, "for", el.Name, "in object id", dn.Ent.Id)
-    }
-  }
 }
 
 func (fn* FileNode) Parse() {
@@ -145,29 +125,36 @@ func (fn* FileNode) Parse() {
   if err != nil { log.Fatal(err) }
 }
 
-type ExpandStrat int
+func (dn* DirNode) Children() ([]*DirNode, []*FileNode) {
-const (
+  folders := make([]*DirNode,0)
-  ExpandOnlyDirectory ExpandStrat = iota
+  files := make([]*FileNode, 0)
-  ExpandAll
-)
 
-func (dn* DirNode) Walk(strat ExpandStrat, depth int) {
+  for _, el := range dn.Elem.Entries {
+    if IsDir(el.Mode) {
+      folders = append(folders, NewDirNode(dn, el))
+    } else if IsRegular(el.Mode) {
+      files = append(files, NewFileNode(dn, el))
+    } else {
+      log.Fatal("Unknown mode", el.Mode, "for", el.Name, "in object id", dn.Ent.Id)
+    }
+  }
+
+  return folders, files
+}
+
+func (dn* DirNode) Walk(tobs TreeObserver) {
   qNode := []*DirNode{dn}
-  for len(qNode) > 0 && depth != 0{
+  for len(qNode) > 0 {
-    if depth > 0 { depth = depth - 1 }
 
     cursor := qNode[0]
     qNode = qNode[1:]
     cursor.Parse()
+    dir, file := cursor.Children()
+    qNode = append(dir, qNode...)
 
-    for _, ndn := range dn.Folders {
+    tobs.onDir(cursor)
-      qNode = append(qNode, ndn)
+    for _, f := range file {
-    }
+      tobs.onFile(f)
-
-    if ExpandAll == strat {
-      for _, nfn := range dn.Files {
-        nfn.Parse()
-      }
     }
   }
 }