public static void HasChangeType(ChangeType type, params SyncAction[] objects)
 {
     foreach (var obj in objects)
     {
         Assert.Equal(type, obj.Type);
     }
 }

        protected virtual ExitCode ChangeSetting(IClientSettings clientSettings, SettingsLocation location, ChangeType changeType)
        {
            // Don't want to save defaults for options that apply directly to this command
            List<string> settingsToSkip = new List<string>();
            settingsToSkip.AddRange(StandardOptions.List);
            settingsToSkip.AddRange(StandardOptions.Add);
            settingsToSkip.AddRange(StandardOptions.Remove);

            foreach (var setting in this.Arguments.Options)
            {
                if (settingsToSkip.Contains(setting.Key, StringComparer.OrdinalIgnoreCase)) { continue; }
                bool success = false;
                switch (changeType)
                {
                    case ChangeType.Add:
                        this.Loggers[LoggerType.Status].Write(XTaskStrings.DefaultsSavingProgress, setting.Key);
                        success = clientSettings.SaveSetting(location, setting.Key, setting.Value);
                        break;
                    case ChangeType.Remove:
                        this.Loggers[LoggerType.Status].Write(XTaskStrings.DefaultsRemovingProgress, setting.Key);
                        success = clientSettings.RemoveSetting(location, setting.Key);
                        break;
                }

                this.Loggers[LoggerType.Status].WriteLine(success ? XTaskStrings.Succeeded : XTaskStrings.Failed);
            }

            return ExitCode.Success;
        }

 public PythonTypeChangedEventArgs(CodeContext context, SymbolId changed, ChangeType type, object previous, object newValue) {
     _context = context;
     _changed = changed;
     _type = type;
     _previous = previous;
     _newValue = newValue;
 }

 public ChangeEvent(ChangeType type, UniqueId beforeId, UniqueId afterId, Instant versionInstant)
 {
     _type = type;
     _beforeId = beforeId;
     _afterId = afterId;
     _versionInstant = versionInstant;
 }

 public HistoryItem(StreamReader sr)
 {
     this.user = sr.ReadLine();
     this.type = (ChangeType)Convert.ToInt32(sr.ReadLine());
     this.otherInfo = sr.ReadLine();
     this.time = new DateTime(Convert.ToInt64(sr.ReadLine()));
 }

		/// <summary>
		/// Initializes a new instance.
		/// </summary>
		internal ChangeEntry(ChangeType changeType, IUberMap map, object entity)
		{
			UberMap = map;
			ChangeType = changeType;
			Entity = entity;
			MetaEntity = MetaEntity.Locate(entity);
		}

 public Change(string resultRow)
 {
     string[] separated = resultRow.Split(' ');
     ChangeType = GetFromString(separated[0]);
     FullPath = separated[1];
     Name = Path.GetFileName(separated[1]);
 }

 public ChangeAction(ChangeType changeType, TranscriptionElement changedElement, TranscriptionIndex changeIndex, int changeAbsoluteIndex)
 {
     _changeType = changeType;
     _changedElement = changedElement;
     _changeTranscriptionIndex = changeIndex;
     _changeAbsoluteIndex = changeAbsoluteIndex;
 }

 internal FileChange(string directory, string path, ChangeType type)
 {
     Debug.Assert(path != null);
     _directory = directory;
     _path = path;
     _chageType = type;
 }

 /// <summary>
 /// This constructor is used when triggering a provider change
 /// </summary>
 /// <param name="providerId">Provider Id</param>
 /// <param name="aigSubscriberId">Subscriber Id</param>
 /// <param name="changeType">Change Type</param>
 /// <param name="isAttributeUpdate">Attribute update</param>
 /// <param name="isRateUpdate">Rate update</param>
 /// <param name="isFullUpdate">Full update</param>
 private ProviderChangeMessage(Guid providerId, Guid aigSubscriberId, ChangeType changeType, bool isAttributeUpdate, bool isRateUpdate, bool isFullUpdate)
     : base(providerId, aigSubscriberId, changeType)
 {
     IsAttributeUpdate = isAttributeUpdate;
     IsRateUpdate = isRateUpdate;
     IsFullUpdate = isFullUpdate;
 }

		private void AssertChange(string name, ChangeType change)
		{
			RootDetail r1 = ExtractAttribute(Subjects.One, name);
			RootDetail r2 = ExtractAttribute(Subjects.Two, name);

			Assert.AreEqual(change, r1.PerformCompare(r2));
		}

 public virtual void Transition(BaseScreen transitionTo, ChangeType changeType)
 {
     Transitioning = true;
     TransitionTo = transitionTo;
     ChangeType = changeType;
     transitionTimer = TimeSpan.Zero;
 }

 public TableChanges(Table oldTable, Table newTable, ChangeType changeType)
 {
     this.OldTable = oldTable;
     this.NewTable = newTable;
     this.ChangeType = changeType;
     this.ColumnsChanged = new List<ColumnChanges>();
 }

 void OnAppliedChange(ChangeType type, string newPath, string oldPath = null)
 {
     if (AppliedChange != null)
     {
         AppliedChange(this, new MyAppliedChangeEventArgs(type, newPath, oldPath));
     }
 }

 public static bool IsInOriginalDocument(ChangeType t)
 {
     switch (t)
     {
         case ChangeType.None:
         case ChangeType.Deletion:
         case ChangeType.MoveSource:
         case ChangeType.FormatChange:
         case ChangeType.Match:
         case ChangeType.ChangedText:
         case ChangeType.StyleChangeText:
             return true;
         case ChangeType.MoveDestination:
         case ChangeType.Insertion:
         case ChangeType.MovedDeletion:
         case ChangeType.CellInserted:
         case ChangeType.CellDeleted:
         case ChangeType.CellMerged:
         case ChangeType.CellIsPadding:
         case ChangeType.ChangeNumber:
         case ChangeType.Delimiter:
         case ChangeType.StyleChangedLabel:
         case ChangeType.Comment:
         case ChangeType.InsertedComment:
         case ChangeType.DeletedComment:
         case ChangeType.ChangedComment:
         default:
             return false;
     }
 }

 public WpfLayerInfo( int priority, Action<DrawingContext> draw, DrawingVisual visual, ChangeType notifyOnChange )
 {
     NotifyOnChange = notifyOnChange;
     Priority = priority;
     Visual = visual;
     Draw = draw;
 }

 public DiffPiece(string text, ChangeType type, int? position)
 {
     Text = text;
     Position = position;
     Type = type;
     SubPieces = new List<DiffPiece>();
 }

 public virtual void Transition(ChangeType change, BaseGameState gameState)
 {
     Transitioning = true;
     changeType = change;
     TransitionTo = gameState;
     transitionTimer = TimeSpan.Zero;
 }

 private void ProcessEvent(FileSystemEventArgs e, ChangeType changeType)
 {
     this.eventCallback(new FileEvent
     {
         changeType = (int)changeType,
         path = e.FullPath
     });
 }

 public Line(DiffPiece a, DiffPiece b, ChangeType type, int position)
 {
     AText = a.Text;
     BText = b.Text;
     Position = position + 1;
     Type = type;
     this.BackGroundColor = type == ChangeType.Modified ? "#D3D3D3" : "#fff";
 }