private void redo(List <Sync <T> > syncs)
{
List <Change <T> > changes = new List <Change <T> >();
{
for (int syncCount = 0; syncCount < syncs.Count; syncCount++)
{
Sync <T> sync = syncs[syncCount];
switch (sync.getType())
{
case Sync <T> .Type.Set:
{
SyncSet <T> syncSet = (SyncSet <T>)sync;
// Make change
ChangeSet <T> changeSet = new ChangeSet <T>();
{
changeSet.index = syncSet.index;
changeSet.values.AddRange(syncSet.news);
}
changes.Add(changeSet);
}
break;
case Sync <T> .Type.Add:
{
SyncAdd <T> syncAdd = (SyncAdd <T>)sync;
// Make change
ChangeAdd <T> changeAdd = new ChangeAdd <T>();
{
changeAdd.index = syncAdd.index;
changeAdd.values.AddRange(syncAdd.values);
}
changes.Add(changeAdd);
}
break;
case Sync <T> .Type.Remove:
{
SyncRemove <T> syncRemove = (SyncRemove <T>)sync;
// Make change
ChangeRemove <T> changeRemove = new ChangeRemove <T>();
{
changeRemove.index = syncRemove.index;
changeRemove.number = syncRemove.values.Count;
}
changes.Add(changeRemove);
}
break;
default:
Logger.LogError("unknown type: " + sync.getType() + "; " + this);
break;
}
}
}
if (changes.Count > 0)
{
this.processChange(changes);
}
}
public static void replaceCallBack <T>(ValueChangeCallBack callBack, List <Sync <T> > syncs)
{
for (int syncCount = 0; syncCount < syncs.Count; syncCount++)
{
Sync <T> sync = syncs[syncCount];
switch (sync.getType())
{
case Sync <T> .Type.Set:
{
SyncSet <T> syncSet = (SyncSet <T>)sync;
if (syncSet.olds.Count == syncSet.news.Count)
{
for (int i = 0; i < syncSet.olds.Count; i++)
{
// od value
RemoveCallBack(callBack, syncSet.olds[i]);
// add new value
AddCallBack(callBack, syncSet.news[i]);
}
}
else
{
Logger.LogError("count error: " + syncSet.olds.Count + "; " + syncSet.news.Count);
}
}
break;
case Sync <T> .Type.Add:
{
SyncAdd <T> syncAdd = (SyncAdd <T>)sync;
for (int i = 0; i < syncAdd.values.Count; i++)
{
T value = syncAdd.values[i];
AddCallBack(callBack, value);
}
}
break;
case Sync <T> .Type.Remove:
{
SyncRemove <T> syncRemove = (SyncRemove <T>)sync;
for (int i = 0; i < syncRemove.values.Count; i++)
{
T value = syncRemove.values[i];
RemoveCallBack(callBack, value);
}
}
break;
default:
Logger.LogError("unknown type: " + sync.getType());
break;
}
}
}
public static void getAddAndRemoveValues <T>(List <Sync <T> > syncs, List <T> addValues, List <T> removeValues)
{
for (int syncCount = 0; syncCount < syncs.Count; syncCount++)
{
Sync <T> sync = syncs[syncCount];
switch (sync.getType())
{
case Sync <T> .Type.Set:
{
SyncSet <T> syncSet = (SyncSet <T>)sync;
if (syncSet.olds.Count == syncSet.news.Count)
{
for (int i = 0; i < syncSet.olds.Count; i++)
{
// od value
removeValues.Add(syncSet.olds[i]);
// add new value
addValues.Add(syncSet.news[i]);
}
}
else
{
Logger.LogError("count error: " + syncSet.olds.Count + "; " + syncSet.news.Count);
}
}
break;
case Sync <T> .Type.Add:
{
SyncAdd <T> syncAdd = (SyncAdd <T>)sync;
for (int i = 0; i < syncAdd.values.Count; i++)
{
T value = syncAdd.values[i];
addValues.Add(value);
}
}
break;
case Sync <T> .Type.Remove:
{
SyncRemove <T> syncRemove = (SyncRemove <T>)sync;
for (int i = 0; i < syncRemove.values.Count; i++)
{
T value = syncRemove.values[i];
removeValues.Add(value);
}
}
break;
default:
Logger.LogError("unknown type: " + sync.getType());
break;
}
}
}
public void processChange(List <Change <T> > changes)
{
if (changes.Count > 0)
{
// Make list change
List <Sync <T> > syncs = new List <Sync <T> >();
{
for (int syncCount = 0; syncCount < changes.Count; syncCount++)
{
Change <T> change = changes[syncCount];
switch (change.getType())
{
case Change <T> .Type.Set:
{
ChangeSet <T> changeSet = (ChangeSet <T>)change;
// keep old SyncSet
SyncSet <T> oldSyncSet = null;
if (changeSet.index >= 0 && changeSet.index + changeSet.values.Count <= this.vs.Count)
{
for (int i = 0; i < changeSet.values.Count; i++)
{
int setIndex = changeSet.index + i;
T oldValue = this.vs[setIndex];
// check is different
bool isDifferent = true;
{
if (object.Equals(oldValue, changeSet.values[i]))
{
isDifferent = false;
}
else
{
if (((Data)(object)changeSet.values[i]).uid == ((Data)(object)oldValue).uid)
{
isDifferent = false;
}
}
}
// Make change
if (isDifferent)
{
// Change
{
// Set parent
{
((Data)(object)oldValue).p = null;
((Data)(object)changeSet.values[i]).p = this;
}
// add
this.vs[setIndex] = changeSet.values[i];
}
// Make Sync
{
// get changeSet
SyncSet <T> syncSet = null;
{
// check old
if (oldSyncSet != null)
{
if (oldSyncSet.index + oldSyncSet.olds.Count == setIndex)
{
syncSet = oldSyncSet;
}
}
// make new
if (syncSet == null)
{
syncSet = new SyncSet <T>();
{
syncSet.index = setIndex;
}
syncs.Add(syncSet);
// set new old
oldSyncSet = syncSet;
}
}
// add value
{
syncSet.olds.Add(oldValue);
syncSet.news.Add(changeSet.values[i]);
}
}
}
else
{
// Debug.LogError("why the same: " + oldValue + "; " + changeSet.values[i]);
}
}
}
else
{
Logger.LogError("index error: " + changeSet.index + "; " + this.vs.Count + "; " + this);
}
}
break;
case Change <T> .Type.Add:
{
ChangeAdd <T> changeAdd = (ChangeAdd <T>)change;
// Add
if (changeAdd.index >= 0 && changeAdd.index <= this.vs.Count)
{
// Change
{
// set parent
{
foreach (T value in changeAdd.values)
{
if (value != null)
{
((Data)(object)value).p = this;
}
else
{
Logger.LogError("why value null: " + this);
}
}
}
this.vs.InsertRange(changeAdd.index, changeAdd.values);
}
// Make Sync
{
SyncAdd <T> syncAdd = new SyncAdd <T>();
{
syncAdd.index = changeAdd.index;
syncAdd.values.AddRange(changeAdd.values);
}
syncs.Add(syncAdd);
}
}
else
{
Logger.LogError("index error: " + changeAdd.index + "; " + this.vs.Count + "; " + this);
}
}
break;
case Change <T> .Type.Remove:
{
ChangeRemove <T> changeRemove = (ChangeRemove <T>)change;
// Check index
if (changeRemove.number > 0 && changeRemove.index >= 0 && changeRemove.index + changeRemove.number <= this.vs.Count)
{
// Make sync: phai make sync truoc moi lay duoc oldValues
SyncRemove <T> syncRemove = new SyncRemove <T>();
{
syncRemove.index = changeRemove.index;
for (int i = 0; i < changeRemove.number; i++)
{
syncRemove.values.Add(this.vs[changeRemove.index + i]);
}
}
syncs.Add(syncRemove);
// Change
{
// set parent
{
foreach (T value in syncRemove.values)
{
if (value != null)
{
((Data)(object)value).p = null;
}
else
{
Logger.LogError("why value null: " + this);
}
}
}
// Remove
this.vs.RemoveRange(changeRemove.index, changeRemove.number);
}
}
else
{
Logger.LogError("index error: " + this);
}
}
break;
default:
Logger.LogError("unknown change type: " + change.getType() + "; " + this);
break;
}
}
}
// CallBack
if (syncs.Count > 0)
{
foreach (ValueChangeCallBack callBack in p.callBacks.ToArray())
{
callBack.onUpdateSync(this, syncs);
}
}
else
{
// Debug.LogError("why don't have syncCount: " + this);
}
}
else
{
Logger.LogError("why don't have changes: " + this);
}
}
