public void MethodDumpIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); Assert.Equal(Dump, sut.Dump()); }
private static void Main() { using (FileStream fileStream = new FileStream("output.ldif", FileMode.Create)) using (TextWriter textWriter = new StreamWriter(fileStream, Encoding.ASCII)) using (DirectorySearcher directorySearcher = new DirectorySearcher()) { foreach (SearchResult searchResult in directorySearcher.FindAll()) { List <LdifAttribute> ldifAttributes = new List <LdifAttribute>(); foreach (DictionaryEntry dictionaryEntry in searchResult.Properties) { List <object> values = new List <object>(); foreach (object value in (ResultPropertyValueCollection)dictionaryEntry.Value) { /* * The library does not make assumptions on what the string representation of an object should be. * All types must be converted to either a string or byte[] before being boxed. */ values.Add(value is byte[] ? value : value.ToString()); } ldifAttributes.Add(new LdifAttribute((string)dictionaryEntry.Key, values)); } ChangeAdd changeAdd = new ChangeAdd(searchResult.Path.Substring(7), ldifAttributes); textWriter.WriteLine(changeAdd.Dump()); } } }
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 void PropertyCountIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); // Assert. Assert.Equal(LdifAttributes.Length, sut.Count); }
public void PropertyTypesIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); // Assert. Assert.Equal(AttributeTypes, sut.AttributeTypes); }
public void CtorParameterAttributesNullCollectionIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, null); // Assert. Assert.NotNull(sut.LdifAttributes); Assert.Equal(0, sut.Count); }
public void PropertyAttributesIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); Assert.Equal(LdifAttributes, sut); Assert.Equal(LdifAttributes, sut.LdifAttributes); Assert.Equal(sut, sut.LdifAttributes); }
public void CollectionIndexerIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); // Assert. Assert.Equal(AttributeValuesObjectClass, sut[AttributeTypeObjectClass]); Assert.Equal(AttributeValuesDisplayName, sut[AttributeTypeDisplayName]); Assert.Equal(AttributeValuesGivenName, sut[AttributeTypeGivenName]); Assert.Equal(AttributeValuesSn, sut[AttributeTypeSn]); }
public void MethodTryGetAttributeIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); // Assert. Assert.True(sut.TryGetAttribute(AttributeTypeObjectClass, out LdifAttribute _)); Assert.True(sut.TryGetAttribute(AttributeTypeDisplayName, out LdifAttribute _)); Assert.True(sut.TryGetAttribute(AttributeTypeGivenName, out LdifAttribute _)); Assert.True(sut.TryGetAttribute(AttributeTypeSn, out LdifAttribute _)); }
public void MethodContainsIsValid() { // Act. ChangeAdd sut = new ChangeAdd(DistinguishedName, LdifAttributes); // Assert. Assert.True(sut.Contains(AttributeTypeObjectClass)); Assert.True(sut.Contains(AttributeTypeDisplayName)); Assert.True(sut.Contains(AttributeTypeGivenName)); Assert.True(sut.Contains(AttributeTypeSn)); }
public void insert(int index, T property) { List <Change <T> > changes = new List <Change <T> >(); { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { changeAdd.index = index; changeAdd.values.Add(property); } changes.Add(changeAdd); } this.processChange(changes); }
public void add(List <T> properties) { List <Change <T> > changes = new List <Change <T> >(); { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { changeAdd.index = this.vs.Count; changeAdd.values.AddRange(properties); } changes.Add(changeAdd); } this.processChange(changes); }
public void add(T property, bool needOrder = false) { List <Change <T> > changes = new List <Change <T> >(); { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { // index { // find int index = this.vs.Count; { if (needOrder) { if (this.vs.Count > 0) { Data newData = property as Data; for (int i = this.vs.Count - 1; i >= 0; i--) { Data check = this.vs[i] as Data; if (check != null) { if (newData.uid > check.uid) { index = i + 1; break; } else { index = i; } } else { Logger.LogError("check null: " + this); } } } } } // set changeAdd.index = index; } changeAdd.values.Add(property); } changes.Add(changeAdd); } this.processChange(changes); }
public void add(T property) { List <Change <T> > changes = new List <Change <T> >(); { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { // index { // find int index = this.vs.Count; // set changeAdd.index = index; } changeAdd.values.Add(property); } changes.Add(changeAdd); } this.processChange(changes); }
public static void refresh <T>(LO <T> listProperty, IList <T> syncList) { if (listProperty == null || syncList == null) { Debug.LogError("IdentityUtils null error"); return; } // find listChange List <Change <T> > changes = new List <Change <T> >(); { // make the same count { // remove excess value if (listProperty.getValueCount() > syncList.Count) { ChangeRemove <T> changeRemove = new ChangeRemove <T>(); { changeRemove.index = syncList.Count; changeRemove.number = listProperty.getValueCount() - syncList.Count; } changes.Add(changeRemove); } // need insert else if (listProperty.getValueCount() < syncList.Count) { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { changeAdd.index = listProperty.getValueCount(); for (int i = listProperty.getValueCount(); i < syncList.Count; i++) { changeAdd.values.Add(syncList[i]); } } changes.Add(changeAdd); } } // Copy each value { // oldChangeSet ChangeSet <T> oldChangeSet = null; // minCount int minCount = System.Math.Min(listProperty.getValueCount(), syncList.Count); // get changes for (int i = 0; i < minCount; i++) { T oldValue = (T)listProperty.getValue(i); T newValue = syncList[i]; if (!object.Equals(newValue, oldValue)) { // get changeSet ChangeSet <T> changeSet = null; { // setIdex: set position in list int setIndex = i; // check old if (oldChangeSet != null) { if (oldChangeSet.index + oldChangeSet.values.Count == setIndex) { changeSet = oldChangeSet; } } // make new if (changeSet == null) { changeSet = new ChangeSet <T>(); { changeSet.index = setIndex; } changes.Add(changeSet); // set new old oldChangeSet = changeSet; } } // add value changeSet.values.Add(newValue); } } } } // Change if (changes.Count > 0) { listProperty.processChange(changes); } }
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); } }
public override void copyWrapProperty(WrapProperty otherWrapProperty) { if (otherWrapProperty is LD <T> ) { LD <T> otherLD = (LD <T>)otherWrapProperty; // find listChange List <Change <T> > changes = new List <Change <T> >(); { // make the same count { // remove excess value if (this.getValueCount() > otherLD.getValueCount()) { ChangeRemove <T> changeRemove = new ChangeRemove <T>(); { changeRemove.index = otherLD.getValueCount(); changeRemove.number = this.getValueCount() - otherLD.getValueCount(); } changes.Add(changeRemove); } // need insert else if (this.getValueCount() < otherLD.getValueCount()) { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { changeAdd.index = this.getValueCount(); for (int i = this.getValueCount(); i < otherLD.getValueCount(); i++) { Data oldData = (Data)(object)otherLD.vs[i]; changeAdd.values.Add((T)(object)DataUtils.cloneData(oldData)); } } changes.Add(changeAdd); } } // Copy each value { // oldChangeSet ChangeSet <T> oldChangeSet = null; // minCount int minCount = Math.Min(this.getValueCount(), otherLD.getValueCount()); for (int i = 0; i < minCount; i++) { T oldValue = this.vs[i]; T newValue = otherLD.vs[i]; // get new add data T needAddData = default(T); bool needAdd = false; { // Get Data Data oldData = oldValue != null ? (Data)(object)oldValue : null; Data newData = newValue != null ? (Data)(object)newValue : null; // Check need new bool needNew = true; { if (oldData != null && newData != null) { if (oldData.GetType() == newData.GetType()) { if (oldData.uid == newData.uid) { needNew = false; } } } } if (needNew) { needAdd = true; needAddData = (T)(object)DataUtils.cloneData(newData); } else { // update DataUtils.copyData(oldData, newData); } } // Make changeSet if (needAdd) { // get changeSet ChangeSet <T> changeSet = null; { // setIdex: set position in list int setIndex = i; // check old if (oldChangeSet != null) { if (oldChangeSet.index + oldChangeSet.values.Count == setIndex) { changeSet = oldChangeSet; } } // make new if (changeSet == null) { changeSet = new ChangeSet <T>(); { changeSet.index = setIndex; } changes.Add(changeSet); // set new old oldChangeSet = changeSet; } } // add value changeSet.values.Add(needAddData); } } } } // Change if (changes.Count > 0) { this.processChange(changes); } } else { Logger.LogError("why not the same type wrapProperty: " + this + "; " + otherWrapProperty); } }
public void copyList(List <T> list) { // find listChange List <Change <T> > changes = new List <Change <T> >(); { // make the same count { // remove excess value if (this.getValueCount() > list.Count) { ChangeRemove <T> changeRemove = new ChangeRemove <T>(); { changeRemove.index = list.Count; changeRemove.number = this.getValueCount() - list.Count; } changes.Add(changeRemove); } // need insert else if (this.getValueCount() < list.Count) { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { changeAdd.index = this.getValueCount(); for (int i = this.getValueCount(); i < list.Count; i++) { changeAdd.values.Add(list[i]); } } changes.Add(changeAdd); } } // Copy each value { // oldChangeSet ChangeSet <T> oldChangeSet = null; // minCount int minCount = Math.Min(this.getValueCount(), list.Count); for (int i = 0; i < minCount; i++) { T oldValue = this.vs[i]; T newValue = list[i]; // get new add data T needAddData = default(T); bool needAdd = false; { if (!object.Equals(newValue, oldValue)) { needAdd = true; needAddData = newValue; } } // Make changeSet if (needAdd) { // get changeSet ChangeSet <T> changeSet = null; { // setIdex: set position in list int setIndex = i; // check old if (oldChangeSet != null) { if (oldChangeSet.index + oldChangeSet.values.Count == setIndex) { changeSet = oldChangeSet; } } // make new if (changeSet == null) { changeSet = new ChangeSet <T>(); { changeSet.index = setIndex; } changes.Add(changeSet); // set new old oldChangeSet = changeSet; } } // add value changeSet.values.Add(needAddData); } } } } // Change if (changes.Count > 0) { this.processChange(changes); } }
public override void copyWrapProperty(WrapProperty otherWrapProperty) { if (otherWrapProperty is LO <T> ) { LO <T> otherLP = (LO <T>)otherWrapProperty; // find listChange List <Change <T> > changes = new List <Change <T> >(); { // make the same count { // remove excess value if (this.getValueCount() > otherLP.getValueCount()) { ChangeRemove <T> changeRemove = new ChangeRemove <T>(); { changeRemove.index = otherLP.getValueCount(); changeRemove.number = this.getValueCount() - otherLP.getValueCount(); } changes.Add(changeRemove); } // need insert else if (this.getValueCount() < otherLP.getValueCount()) { ChangeAdd <T> changeAdd = new ChangeAdd <T>(); { changeAdd.index = this.getValueCount(); for (int i = this.getValueCount(); i < otherLP.getValueCount(); i++) { changeAdd.values.Add(otherLP.vs[i]); } } changes.Add(changeAdd); } } // Copy each value { // oldChangeSet ChangeSet <T> oldChangeSet = null; // minCount int minCount = Math.Min(this.getValueCount(), otherLP.getValueCount()); for (int i = 0; i < minCount; i++) { T oldValue = this.vs[i]; T newValue = otherLP.vs[i]; // get new add data T needAddData = default(T); bool needAdd = false; { if (!object.Equals(newValue, oldValue)) { needAdd = true; needAddData = newValue; } } // Make changeSet if (needAdd) { // get changeSet ChangeSet <T> changeSet = null; { // setIdex: set position in list int setIndex = i; // check old if (oldChangeSet != null) { if (oldChangeSet.index + oldChangeSet.values.Count == setIndex) { changeSet = oldChangeSet; } } // make new if (changeSet == null) { changeSet = new ChangeSet <T>(); { changeSet.index = setIndex; } changes.Add(changeSet); // set new old oldChangeSet = changeSet; } } // add value changeSet.values.Add(needAddData); } } } } // Change if (changes.Count > 0) { this.processChange(changes); } } else { Logger.LogError("why not the same type wrapProperty: " + this + "; " + otherWrapProperty); } }