A representation of a change of map like object.

class ChangeSet {

 /**
  * Contains mapping between the changed children and respective changes.
  *
  * The changes are represented either by [ChangeSet] object or by [Change].
  */
 Map changedItems = new Map();

 /**
  * Creates an empty [ChangeSet].
  */

 ChangeSet([Map changedItems = const {}]) {
   this.changedItems = new Map.from(changedItems);
 }

 /**
  * Creates [ChangeSet] from [other]
  */
 ChangeSet.from(ChangeSet changeSet) {
   changeSet.changedItems.forEach((key, change) {
     changedItems[key] = change.clone();
   });
 }
 bool equals (dynamic other) {
   if (other is ChangeSet){
     if (this.changedItems.keys.length != other.changedItems.keys.length) return false;
     for (var k in changedItems.keys){
       var v = changedItems[k];
       if (v is Change || v is ChangeSet) {
         if (!v.equals(other.changedItems[k])){
           return false;
         }
       } else {
         return false;
       }
     }
     return true;
   } else {
     return false;
   }
 }

 /**
  * Clone changeSet.
  */
 ChangeSet clone() {
   return new ChangeSet.from(this);
 }

 /**
  * Marks [key] as added with value [value].
  */
 void markAdded(dynamic key, dynamic value) {
   markChanged(key, new Change(undefined, value));
 }

 void markRemoved(dynamic key, dynamic value) {
   markChanged(key, new Change(value, undefined));
 }

 Set get addedItems {
   var res = new Set();
   changedItems.forEach((key, dynamic change){
     if(change is Change && change.oldValue == undefined){
       res.add(key);
     }
   });
   return res;
 }

 Set get removedItems {
   var res = new Set();
   changedItems.forEach((key, dynamic change){
     if(change is Change && change.newValue == undefined){
       res.add(key);
     }
   });
   return res;
 }

 get strictlyChanged {
   var res = {};
   changedItems.forEach((key, dynamic change) {
     if(change is ChangeSet)
       res[key] = change;
   });
   return res;
 }

 /**
  * Marks all the changes in [ChangeSet] or [Change] for a
  * given [dataObj].
  */

 void markChanged(dynamic key, change) {
   bool contains = changedItems.containsKey(key);
   bool oldIsChangeSet = contains && changedItems[key] is ChangeSet;
   bool newIsChangeSet = change is ChangeSet;
   bool oldIsChange = !oldIsChangeSet;
   bool newIsChange = !newIsChangeSet;

   if (!contains || oldIsChangeSet && newIsChange) {
     changedItems[key] = change.clone();
     return;
   }
   if (oldIsChange && newIsChange || oldIsChangeSet && newIsChangeSet){
     changedItems[key].mergeIn(change);
     return;
   }
   if (oldIsChange && newIsChangeSet) {
     // do nothing
     return;
   }
   // previous ifs should contain all possible cases
   assert(false);
 }

 /**
  * Merges two [ChangeSet]s together.
  */
 void mergeIn(ChangeSet changeSet) {
   changeSet.changedItems.forEach((key, changeSet) {
     markChanged(key, changeSet);
   });
 }

 /**
  * Returns true if there are no changes in the [ChangeSet].
  */
 bool get isEmpty =>
   this.changedItems.isEmpty;

 String toString() {
   return 'ChangeSet(${changedItems.toString()})';
 }
}