public FinancialStatusByBranchController(Branch branch)
     : base(UITableViewStyle.Grouped, null)
 {
     Autorotate = false;
     this.branch = branch;
     buildReport ();
 }

    public void Connect(Uri path)
    {
      // Try to see if ther is already a git repository inside the filesystem path
      if (Repository.IsValid(m_fileSystemPath))
      {
        m_repository = new Repository(m_fileSystemPath, new RepositoryOptions());
      }
      else
      {
        var tempFolder = Guid.NewGuid().ToString("N");

        m_bareWorkDirPath = System.IO.Path.Combine(m_fileSystemPath, tempFolder);
        var ret = Repository.Clone(path.AbsoluteUri, m_bareWorkDirPath, new CloneOptions()
        {
          CredentialsProvider = (url, fromUrl, types) => new UsernamePasswordCredentials()
          {
            Password = m_password,
            Username = m_userName,
          },
          Checkout = false,
          IsBare = true,
        });

        m_repository = new Repository(m_bareWorkDirPath, new RepositoryOptions());
      }

      m_branch = m_repository.Branches[m_branchPath];
      if (m_branch == null)
      {
        throw new Exception("Branch not found: " + m_branchPath);
      }
    }

        public static Commit LatestMergeCommit(this Branch thisBranch, Branch otherBranch)
        {
            IEnumerable<Commit> otherBranchCommits = otherBranch.Commits;

            if (otherBranchCommits.Contains(thisBranch.Tip))
            {
                // Current branch is merged back to otherBranch.
                // So we find the last commit on otherBranch before this merge and all it's ancestors.
                var otherTipAfterMerge =
                    otherBranchCommits.SkipWhile(c => c.Parents.All(p => p != thisBranch.Tip)).FirstOrDefault();
                if (otherTipAfterMerge != null)
                {
                    var thisTipBeforeMerge = otherTipAfterMerge.Parents.First(p => p != thisBranch.Tip);
                    otherBranchCommits =
                        new List<Commit> { thisTipBeforeMerge }.Concat(thisTipBeforeMerge.GetAllAncestors());
                }
            }

            var branchCommits = thisBranch.Commits.Except(otherBranchCommits).ToList();
            var branchCommitsMergedFromOtherBranch =
                branchCommits.Where(c => c.IsMergeFrom(otherBranchCommits)).ToList();

            if (branchCommitsMergedFromOtherBranch.Any())
            {
                return branchCommitsMergedFromOtherBranch.First().GetSingleParentFrom(otherBranchCommits);
            }

            if (branchCommits.Any())
            {
                return branchCommits.Last().GetSingleParentFrom(otherBranchCommits);
            }

            return null;
        }

        public User Login(string username, string password)
        {
            var session = NHibernateSessionManager.GetLocalSession();
            var macAddress = _clientAdapter.GetCurrentClientMacAddress();
            var user = _userRepository.LoginActiveUser(username, password);
            var terminal = _terminalRepository.FindByMac(macAddress);

            if (user.IsNull())
            {
                throw new ApplicationException(@"User not found");
            }

            if (terminal == null)
            {
                session.DoTransactional(sess =>
                    terminal = _terminalRepository.Insert(
                        new Terminal(
                            string.Format(@"T-{0}/{1:00}", user.Employee.Branch.Code ,_terminalRepository.Count() + 1),
                            macAddress,
                            user.Employee.Branch
                        )
                    )
                );
            }

            LoggedInUser = user;
            LoggedInUserBranch = user.Employee.Branch;
            LoggedInTerminal = terminal;

            return user;
        }

 /// <summary>
 /// Push the specified branch to its tracked branch on the remote.
 /// </summary>
 /// <param name="network">The <see cref="Network"/> being worked with.</param>
 /// <param name="branch">The branch to push.</param>
 /// <param name="pushOptions"><see cref="PushOptions"/> controlling push behavior</param>
 /// <exception cref="LibGit2SharpException">Throws if either the Remote or the UpstreamBranchCanonicalName is not set.</exception>
 public static void Push(
     this Network network,
     Branch branch,
     PushOptions pushOptions = null)
 {
     network.Push(new[] { branch }, pushOptions);
 }

 static string GetUnknownBranchSuffix(Branch branch)
 {
     var unknownBranchSuffix = branch.Name.Split('-', '/');
     if (unknownBranchSuffix.Length == 1)
         return branch.Name;
     return unknownBranchSuffix[1];
 }

        void EnsureVersionIsValid(SemanticVersion version, Branch branch, BranchType branchType)
        {
            var msg = string.Format("Branch '{0}' doesn't respect the {1} branch naming convention. ",
                branch.Name, branchType);

            if (version.PreReleaseTag.HasTag())
            {
                throw new ErrorException(msg + string.Format("Supported format is '{0}-Major.Minor.Patch'.", branchType.ToString().ToLowerInvariant()));
            }

            switch (branchType)
            {
                case BranchType.Hotfix:
                    if (version.Patch == 0)
                    {
                        throw new ErrorException(msg + "A patch segment different than zero is required.");
                    }

                    break;

                case BranchType.Release:
                    if (version.Patch != 0)
                    {
                        throw new ErrorException(msg + "A patch segment equals to zero is required.");
                    }

                    break;

                case BranchType.Unknown:
                    break;

                default:
                    throw new NotSupportedException(string.Format("Unexpected branch type {0}.", branchType));
            }
        }

        /// <summary>Create <see cref="RenameBranchDialog"/>.</summary>
        /// <param name="branch">Branch to rename.</param>
        /// <exception cref="ArgumentNullException"><paramref name="branch"/> == <c>null</c>.</exception>
        public RenameBranchDialog(Branch branch)
        {
            Verify.Argument.IsNotNull(branch, "branch");
            Verify.Argument.IsFalse(branch.IsDeleted, "branch",
                Resources.ExcObjectIsDeleted.UseAsFormat("Branch"));

            _branch = branch;

            InitializeComponent();
            Localize();

            var inputs = new IUserInputSource[]
            {
                _newNameInput = new TextBoxInputSource(_txtNewName),
            };
            _errorNotifier = new UserInputErrorNotifier(NotificationService, inputs);

            SetupReferenceNameInputBox(_txtNewName, ReferenceType.LocalBranch);

            var branchName = branch.Name;
            _txtOldName.Text = branchName;
            _txtNewName.Text = branchName;
            _txtNewName.SelectAll();

            GitterApplication.FontManager.InputFont.Apply(_txtNewName, _txtOldName);

            _controller = new RenameBranchController(branch) { View = this };
        }

 public ElectronicObject(string catalogueNumber, string manufacturer, string model, string description, int quantity, Branch category, decimal price, Color color, double display, int capacity)
     : base(catalogueNumber, manufacturer, model, description, quantity, category, price)
 {
     this.display = display;
     this.capacity = capacity;
     this.color = color;
 }

        public static KeyValuePair<string, BranchConfig> GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)
        {
            var matchingBranches = LookupBranchConfiguration(config, currentBranch);

            if (matchingBranches.Length == 0)
            {
                var branchConfig = new BranchConfig();
                ConfigurationProvider.ApplyBranchDefaults(config, branchConfig);
                return new KeyValuePair<string, BranchConfig>(string.Empty, branchConfig);
            }
            if (matchingBranches.Length == 1)
            {
                var keyValuePair = matchingBranches[0];
                var branchConfiguration = keyValuePair.Value;

                if (branchConfiguration.Increment == IncrementStrategy.Inherit)
                {
                    return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, keyValuePair, branchConfiguration, config, excludedInheritBranches);
                }

                return keyValuePair;
            }

            const string format = "Multiple branch configurations match the current branch branchName of '{0}'. Matching configurations: '{1}'";
            throw new Exception(string.Format(format, currentBranch.Name, string.Join(", ", matchingBranches.Select(b => b.Key))));
        }

 public BranchWrapper(Repository repo, Branch branch)
 {
     this.repo = repo;
     this.branch = branch;
     IsRemote = branch.IsRemote;
     if (branch.TrackedBranch != null)
     {
         TrackedBranch = new BranchWrapper(repo, branch.TrackedBranch);
     }
     IsTracking = branch.IsTracking;
     TrackingDetails = (Func<object, Task<object>>)(async (j) => { return branch.TrackingDetails; });
     IsCurrentRepositoryHead = (Func<object, Task<object>>)(async (j) => { return branch.IsCurrentRepositoryHead; });
     Tip = async (j) => { return new CommitWrapper(branch.Tip); };
     UpstreamBranchCanonicalName = (Func<object, Task<object>>)(async (j) => { return branch.UpstreamBranchCanonicalName; });
     Remote = branch.Remote;
     CanonicalName = branch.CanonicalName;
     Commits = (Func<object, Task<object>>)(async (j) => {
         if (j != null)
         {
             Commit after = repo.Lookup<Commit>((string)j);
             Commit until = branch.Tip;
             Commit ancestor = repo.Commits.FindMergeBase(after, until) ?? after;
             return CommitsAfter(after, until, ancestor).Distinct().Select(c => new CommitWrapper(c));
         }
         else
         {
             return branch.Commits.Select(c => new CommitWrapper(c));
         }
     });
     Name = branch.Name;
 }

        /// <summary>
        /// Gets the <see cref="BranchConfig"/> for the current commit.
        /// </summary>
        public static BranchConfig GetBranchConfiguration(GitVersionContext context, Branch targetBranch, IList<Branch> excludedInheritBranches = null)
        {
            var matchingBranches = LookupBranchConfiguration(context.FullConfiguration, targetBranch).ToArray();

            BranchConfig branchConfiguration;
            if (matchingBranches.Length > 0)
            {
                branchConfiguration = matchingBranches[0];

                if (matchingBranches.Length > 1)
                {
                    Logger.WriteWarning(string.Format(
                        "Multiple branch configurations match the current branch branchName of '{0}'. Using the first matching configuration, '{1}'. Matching configurations include: '{2}'",
                        targetBranch.FriendlyName,
                        branchConfiguration.Name,
                        string.Join("', '", matchingBranches.Select(b => b.Name))));
                }
            }
            else
            {
                Logger.WriteInfo(string.Format(
                    "No branch configuration found for branch {0}, falling back to default configuration",
                    targetBranch.FriendlyName));

                branchConfiguration = new BranchConfig { Name = string.Empty };
                ConfigurationProvider.ApplyBranchDefaults(context.FullConfiguration, branchConfiguration, "");
            }

            return branchConfiguration.Increment == IncrementStrategy.Inherit ?
                InheritBranchConfiguration(context, targetBranch, branchConfiguration, excludedInheritBranches) :
                branchConfiguration;
        }

        static Branch[] CalculateWhenMultipleParents(IRepository repository, Commit currentCommit, ref Branch currentBranch, Branch[] excludedBranches)
        {
            var parents = currentCommit.Parents.ToArray();
            var branches = repository.Branches.Where(b => !b.IsRemote && b.Tip == parents[1]).ToList();
            if (branches.Count == 1)
            {
                var branch = branches[0];
                excludedBranches = new[]
                {
                    currentBranch,
                    branch
                };
                currentBranch = branch;
            }
            else if (branches.Count > 1)
            {
                currentBranch = branches.FirstOrDefault(b => b.Name == "master") ?? branches.First();
            }
            else
            {
                var possibleTargetBranches = repository.Branches.Where(b => !b.IsRemote && b.Tip == parents[0]).ToList();
                if (possibleTargetBranches.Count > 1)
                {
                    currentBranch = possibleTargetBranches.FirstOrDefault(b => b.Name == "master") ?? possibleTargetBranches.First();
                }
                else
                {
                    currentBranch = possibleTargetBranches.FirstOrDefault() ?? currentBranch;
                }
            }

            Logger.WriteInfo("HEAD is merge commit, this is likely a pull request using " + currentBranch.Name + " as base");

            return excludedBranches;
        }

        /// <summary>
        /// Create New Branch
        /// </summary>
        /// <param name="NewBranch"></param>
        public void CreateBranch(Branch NewBranch)
        {
            string qryInsertBranch =
                            @"INSERT INTO [dbo].[Company]
                            ([BranchID]
                            , [CompanyID]
                            , [BranchRegion]
                            , [BranchCode]
                            , [BranchName]
                            , [BranchHotelName]
                            , [BranchSpaName]
                            , [BranchAddress]
                            , [BranchCity]
                            , [BranchState]
                            , [BranchCountry]
                            , [BranchContactNo]
                            , [BranchComment]
                            , [BranchCreatedBy])
                            values
                            (@BranchID, @CompanyID, @BranchRegion, @BranchCode, @BranchName,
                            @BranchHotelName, @BranchSpaName, @BranchAddress, @BranchCity,
                            @BranchState, @BranchCountry, @BranchContactNo, @BranchComment, @BranchCreatedBy)";

            //creates new Branch
            this._con.Query<int>(qryInsertBranch, NewBranch);
        }

 public int NumberOfCommitsOnBranchSinceCommit(Branch branch, Commit commit)
 {
     var olderThan = branch.Tip.Committer.When;
     return branch.Commits
         .TakeWhile(x => x != commit)
         .Count();
 }

        /// <summary>
        /// Checkout the tip commit of the specified <see cref="Branch"/> object. If this commit is the
        /// current tip of the branch, will checkout the named branch. Otherwise, will checkout the tip commit
        /// as a detached HEAD.
        /// </summary>
        /// <param name="repository">The repository to act on</param>
        /// <param name="branch">The <see cref="Branch"/> to check out.</param>
        /// <param name="options"><see cref="CheckoutOptions"/> controlling checkout behavior.</param>
        /// <returns>The <see cref="Branch"/> that was checked out.</returns>
        public static Branch Checkout(IRepository repository, Branch branch, CheckoutOptions options)
        {
            Ensure.ArgumentNotNull(repository, "repository");
            Ensure.ArgumentNotNull(branch, "branch");
            Ensure.ArgumentNotNull(options, "options");

            // Make sure this is not an unborn branch.
            if (branch.Tip == null)
            {
                throw new UnbornBranchException("The tip of branch '{0}' is null. There's nothing to checkout.",
                    branch.FriendlyName);
            }

            if (!branch.IsRemote && !(branch is DetachedHead) &&
                string.Equals(repository.Refs[branch.CanonicalName].TargetIdentifier, branch.Tip.Id.Sha,
                    StringComparison.OrdinalIgnoreCase))
            {
                Checkout(repository, branch.Tip.Tree, options, branch.CanonicalName);
            }
            else
            {
                Checkout(repository, branch.Tip.Tree, options, branch.Tip.Id.Sha);
            }

            return repository.Head;
        }

        //readonly Tree masterTree;
        //readonly Tree currentTree;
        public Stalker(String localRepo, String sourceFileName, String ignoreFileName, String localStalkBranch = null, String targetTag = null, String localMaster = "master")
        {
            repo = new Repository (localRepo);

            master = repo.Branches.Single (branch => branch.FriendlyName == localMaster);

            if (targetTag != null) {
                tag = repo.Tags.Single (t => t.FriendlyName == targetTag);
            }

            //			if (localStalkBranch != null)
                head = repo.Branches.Single (branch => branch.FriendlyName == localStalkBranch);
            //			else
            //				head = repo.Head;

            //			if (head != repo.Branches.Single (b => b.IsCurrentRepositoryHead)) {
            //                repo.Checkout(head);
            //			}
            //            head = repo.Branches.Single(b => b.IsCurrentRepositoryHead);
            //var filter = new CommitFilter { Since = repo.Branches["master"], Until = repo.Branches["development"] };
            //masterTree = repo.Lookup<Tree>(master.Tip.Sha);
            //currentTree = repo.Lookup<Tree>(head.Tip.Sha);
            try {
                sources = File.ReadAllLines (Path.Combine (localRepo, sourceFileName));
            } catch {
            } finally {
            }
            try {
                ignore = File.ReadAllLines (Path.Combine (localRepo, ignoreFileName));
            } catch {
            } finally {
            }
        }

 public Employee(Branch branch, Position position, PersonName name, Gender gender)
     : base(name)
 {
     _branch = branch;
     _position = position;
     base.Gender = gender;
 }

        public MainViewModel(KeyHooker hookerKey, MouseHooker hookerMouse, KeySenderInput keySenderInput, MouseSenderInput mouseSenderInput)
        {
            mHookerKey = hookerKey;
            mHookerKey.SetHook();
            mHookerMouse = hookerMouse;
            mHookerMouse.SetHook();

            mKeySenderInput = keySenderInput;
            mMouseSenderInput = mouseSenderInput;

            mStopMacroBranch = new Branch<IInput>(mInputEqualityComparer);
            mMacrosModeBranch = new Branch<IInput>(mInputEqualityComparer);

            Settings.Default.Setting = Settings.Default.Setting ?? new AppSettings(mInputEqualityComparer);
            AppSettings settings = Settings.Default.Setting;
            mTreeRoot = settings.TreeRoot;
            mTreeSequence = settings.TreeSequence;
            MacrosCollection = settings.MacrosCollection;
            StopMacroCollection = settings.SequenceStopMacro;
            MacrosModeCollection = settings.SequenceMacrosMode;
            SequenceCollection = settings.Sequence;
            MacroCollection = settings.Macro;

            mSequenceReader = new HookNotRepeatReader(mHookerKey, SequenceCollection);
            ObservableCollection<IInput> tempCollection = new ObservableCollection<IInput>(MacroCollection.Cast<IInput>());
            tempCollection.CollectionChanged += ReadMacro_CollectionChanged;
            mMacroReader = new MultiHookNotRepeatReader(new List<IHooker> { mHookerKey, mHookerMouse }, tempCollection);
            mStopMacroReader = new HookNotRepeatReader(mHookerKey, StopMacroCollection);
            mMacrosModeReader = new HookNotRepeatReader(mHookerKey, MacrosModeCollection);

            RecordSequenceCommand = new RelayCommand(RecordSequence);
            RecordMacroCommand = new RelayCommand(RecordMacro);
            CreateMacrosCommand = new RelayCommand(CreateMacros);
            CleanRowsSequenceCommand = new RelayCommand(CleanSequence);
            CleanRowsMacroCommand = new RelayCommand(CleanMacro);
            CleanRowsMacrosCommand = new RelayCommand(CleanMacros);
            DeleteRowSequenceCommand = new RelayCommand<IInput>(RemoveSequence);
            DeleteRowMacroCommand = new RelayCommand<InputDelay>(RemoveMacro);
            DeleteRowMacrosCommand = new RelayCommand<Macros>(RemoveMacros);
            StopRecordStopMacroCommand = new RelayCommand(StopRecordStopMacro);
            StartRecordStopMacroCommand = new RelayCommand(StartRecordStopMacro);
            StartRecordMacrosModeCommand = new RelayCommand(StartRecordMacrosMode);
            StopRecordMacrosModeCommand = new RelayCommand(StopRecordMacrosMode);
            SetDefaultDelayCommand = new RelayCommand(SetDefaultDelay);
            StopAllRecordCommand = new RelayCommand(StopAllRecord);

            mCancellationState = new CancelState<IInput>(mInputEqualityComparer);

            StateWalker<IInput> machineWalker = new StateWalker<IInput>(mTreeRoot);
            mHookerKey.Hooked += arg =>
            {
                State<IInput> currentState = machineWalker.WalkStates(arg);
                return currentState is FunctionState<IInput>
                    ? (bool)((FunctionState<IInput>)currentState).ExecuteFunction()
                    : currentState is CancellationFunctionState<IInput>
                    ? (bool)((CancellationFunctionState<IInput>)currentState).ExecuteFunction(mCancellationState.CancelToken)
                    : true;
            };
        }

        public string GenerateCode(Branch b, string newLine)
        {
            if (string.IsNullOrEmpty(b.Path))
                return string.Format("(\"{0}\", {1})", b.Name, GenerateCode(b.Tree, newLine)); ;

            return string.Format("(\"{0}\", {1} {2} {3} )", b.Name,
                b.Many ? "mapTrees" : "mapTree", b.Path, GenerateCode(b.Tree, newLine)); ;
        }