best approach to code hierarchical classes ?

[someone]

Consider the following code in what I used nested-classes for the 
first time within D:

```d
import std.string;
import std.stdio;

class classComputers {

    classComputers lhs;
    classComputers rhs;

    int opApply(int delegate(classComputer) dg) { /// boilerplate 
code to handle the class's default collection

       int lintResult = 0; /// must find a better name

		foreach (lobjComputer; computers) { /// looping over the 
computers starting in current node

			lintResult = dg(lobjComputer); /// passing single object to 
the loop body

			if (lintResult != 0) { break; }

		}

       if (lintResult != 0 && lhs ! is null) { lintResult = 
lhs.opApply(dg); } /// recursing child nodes
       if (lintResult != 0 && rhs ! is null) { lintResult = 
rhs.opApply(dg); } /// recursing child nodes

       return lintResult;

    }

    public classComputer[] computers; alias computers this; /// 
ie: default property

    private string pstrNetwork;

    final @property string network() { return this.pstrNetwork; }
    final @property void network(in string lstrNetwork) { 
this.pstrNetwork = lstrNetwork.strip(); }

    this(
       string lstrNetwork
       ) {

       this.network = lstrNetwork;

    }

    class classComputer {

       private string pstrName;

       final @property string name() { return this.pstrName; }
       final @property void name(in string lstrName) { 
this.pstrName = lstrName.strip(); }

       this(
          string lstrName
          ) {

          this.name = lstrName;

       }

    }

}

void main (

    ) {

    classComputers lobjComputers = new classComputers(r"lab"c); 
/// ie: the lab network

    lobjComputers ~= lobjComputers.new classComputer(r"dell"c);
    lobjComputers ~= lobjComputers.new classComputer(r"ibm"c);
    lobjComputers ~= lobjComputers.new classComputer(r"apple"c);
    lobjComputers[1].name = r"lenovo"c;

    foreach(lobjComputer; lobjComputers) { writeln(r"["c ~ 
lobjComputer.outer.network ~ r" network has "c ~ 
lobjComputer.name ~ r"]"c); }

}
```

As expected, the above code produces:

[lab network has dell]
[lab network has lenovo]
[lab network has apple]

Now think of wider hierarchical structures, let's say 6~9 to 
begin with or greater; eg: computers.computer.devices.firmware... 
and so on.

Coding such scenario with nested classes will produce a huge code 
base within the same module. My first approach, obviously, was to 
put each class in its own module and in main() I instantiate the 
primary one and the child objects/classes are instantiated either 
directly in main or say, by each class' own add()/remove() 
methods. This works as expected. However, I can't manage to 
traverse the tree from main() like something.parent.somethingelse 
(like I can do with outer for the nested classes example I gave 
you) nor I am able to access parent members within the classes 
own bodies.

Are there alternatives to nested classes for such scenarios ?