Module org.autogui
Package org.autogui.swing.table

Class ObjectTableModelColumns.ObjectTableColumnSize

java.lang.Object
org.autogui.swing.table.ObjectTableModelColumns.ObjectTableColumnSize
Direct Known Subclasses:
GuiSwingTableColumnCollection.ObjectTableColumnSizeConcrete, ObjectTableModelColumns.ObjectTableColumnSizeComposite
Enclosing class:
ObjectTableModelColumns
public abstract static class ObjectTableModelColumns.ObjectTableColumnSize extends Object
size information of hierarchical composition of sub-columns 
      Size ::= { Size, Size, ... }  //SizeComposite
             | Int                  //SizeConcrete

      getColumnSize(List<E> l)  ::=  size(l.get(0)).set(size(l.get(1)).set(...)...

      {a,b,c}.set({a',b',c',d}) ::= {a.set(a'),b.set(b'),c.set(c'),d}
      {a,b,c}.set({a',b'})      ::= {a.set(a'),b.set(b'),c}
            n.set(n')           ::= max(n,n')

         size(List<V> l) where V is a value-type
                                ::= l.size()
         size(List<E> s)        ::= { size(s.get(0)), size(s.get(1)), ... }
         size(C c) and class C { T0 f0; T1 f1;...; }
                                ::= { size(c.f0), size(c.f1), ... }
         size(V v)              ::= 1
  
      {a,b,c,...}.create(con) ::=
                      con.columns.forEach(c -> c.modelIndex = con.lastIndex++);
                      a.create(con.child(0)); con.lastIndex = con.child(0).lastIndex;
                      b.create(con.child(1)); con.lastIndex = con.child(1).lastIndex;
                      ...
                      con.columns.remove(con.lastIndex,...);
                n.create(con) ::=
                      con.columns.forEach(c -> c.modelIndex = con.lastIndex++);
                      diff = n - con.columns.size();
                      if diff < 0: con.columns.remove(n,n+1,...);
                      else       : for (...diff...) con.columns.add(new Column(con.lastIndex++));


  
    //examples: getColumnSize
      List<List<Float>> l1 = asList(
                              asList(1.0),
                              asList(2.0,3.0),
                              asList(4.0,5.0,6.0));
      => 1.set(2).set(3) => 3

      List<List<List<Float>>> l2 = asList(
                              asList(asList(1.0), asList(2.0)),
                              asList(asList(1.0), asList(2.0,3.0), asList(4.0,5.0)),
                              asList(asList(1.0), asList(2.0,3.0), asList(4.0,5.0,6.0)));
      => {1,1}.set({1,2,2}).set({1,2,3}) => {1,2,3}

      class E { List<Float> l1, l2; } //E({l1_1,l1_2,...},{l2_1,l2_2,...})
      List<E> l3 = asList(
                E({1.0},         {2.0,3.0}),
                E({4.0,5.0,6.0}, {7.0,8.0,9.0,10.0});

      => {1, 2}.set({3,4}) => {3,4}


      class F { int x, int y; } //F(x,y)
      List<List<F>> l4 = asList(
                      asList(F(1,2)),
                      asList(F(3,4), F(5,6)),
                      asList(F(7,8), F(9,10), F(11,12)));
      => {{1,1}}.set({{1,1},{1,1}}).set({{1,1},{1,1},{1,1}}) => {{1,1},{1,1},{1,1}}