// Meta - a "minimal" approach to adding meta-level to Java objects
//
//   v2 - now much easier and more performant

// OK you can read the rants here: #1031838 so right now I will stick to
// describing the changes.

sclass Meta_v2 implements IMeta_v2 {

  // So what's new in Meta v2?
  
  // We still have one field - but now it's definitely a map (a map
  // can hold anything, so...)
  // And we make this field, or rather, the object contained in it,
  // "speak" for itself. It's just a map that you can use like any
  // other one. It may shape-shift during its operation, meaning it
  // can even change its base class to accomodate for special cases.
  
  // This, however, necessitates that the object can exchange itself
  // for another one at any point. Thus the regular Map interface
  // will not cut it. We design a variation of the Map interface called
  // MutatingMap.
  
  MutatingMap meta = someNiceEmptyMutatingMapImplementationSingleton();
  
  // Field is still not transient.
  // And this time it is no longer volatile either which is of no
  // benefit in the new approach.
  
  // External mutexes and tempMetaMutex we don't need anymore.
  
  // So how do we synchronize? We just synchronize on the current meta
  // map. We do our deeds with it and if it mutates in the process, we
  // just put the mutation in the meta slot. And release the original
  // map's monitor after that. Done. "You end clean" as the magicians
  // say. Ahahaha.
  
  // So things should simplify from here, at least over version 1 of
  // the Meta interface.
  
  // You can still replace the whole map, nut this time we enforce a
  // proper type and we synchronize as per the statutes laid out above.
  
  public void _setMeta(MutatingMap meta) {
    assertNotNull(meta);
    synchronized(meta) {
      this.meta = meta;
    }
  }
  
  public MutatingMap _getMeta() { ret meta; }
  
  // That was layer 1...
  // ...and here is the convenience stuff - just use the meta field like a regular map.
  
  void metaSet aka metaPut(O key, O value) {
    synchronized(...
    metaMapPut(this, key, value); }
  O metaGet(O key) { ret metaMapGet(this, key); }
}