Exemple #1
0
        private RefUpdateResult UpdateImpl(RevWalk.RevWalk walk, StoreBase store)
        {
            if (isNameConflicting())
            {
                return(RefUpdateResult.LockFailure);
            }

            var @lock = new LockFile(_looseFile);

            if ([email protected]())
            {
                return(RefUpdateResult.LockFailure);
            }

            try
            {
                OldObjectId = _db.IdOf(Name);
                if (_expValue != null)
                {
                    ObjectId o = OldObjectId ?? ObjectId.ZeroId;
                    if (!AnyObjectId.equals(_expValue, o))
                    {
                        return(RefUpdateResult.LockFailure);
                    }
                }

                if (OldObjectId == null)
                {
                    return(store.Store(@lock, RefUpdateResult.New));
                }

                RevObject newObj = SafeParse(walk, _newValue);
                RevObject oldObj = SafeParse(walk, OldObjectId);
                if (newObj == oldObj)
                {
                    return(store.Store(@lock, RefUpdateResult.NoChange));
                }

                RevCommit newCom = (newObj as RevCommit);
                RevCommit oldCom = (oldObj as RevCommit);
                if (newCom != null && oldCom != null)
                {
                    if (walk.isMergedInto(oldCom, newCom))
                    {
                        return(store.Store(@lock, RefUpdateResult.FastForward));
                    }
                }

                if (IsForceUpdate)
                {
                    return(store.Store(@lock, RefUpdateResult.Forced));
                }

                return(RefUpdateResult.Rejected);
            }
            finally
            {
                @lock.Unlock();
            }
        }
        private RefUpdateResult updateImpl(RevWalk.RevWalk walk, Store store)
        {
            RevObject newObj;
            RevObject oldObj;

            if (getRefDatabase().isNameConflicting(Name))
            {
                return(RefUpdateResult.LOCK_FAILURE);
            }
            try
            {
                if (!tryLock(true))
                {
                    return(RefUpdateResult.LOCK_FAILURE);
                }
                if (expValue != null)
                {
                    ObjectId o;
                    o = oldValue != null ? oldValue : ObjectId.ZeroId;
                    if (!AnyObjectId.equals(expValue, o))
                    {
                        return(RefUpdateResult.LOCK_FAILURE);
                    }
                }
                if (oldValue == null)
                {
                    return(store.execute(RefUpdateResult.NEW));
                }

                newObj = safeParse(walk, newValue);
                oldObj = safeParse(walk, oldValue);
                if (newObj == oldObj)
                {
                    return(store.execute(RefUpdateResult.NO_CHANGE));
                }

                if (newObj is RevCommit && oldObj is RevCommit)
                {
                    if (walk.isMergedInto((RevCommit)oldObj, (RevCommit)newObj))
                    {
                        return(store.execute(RefUpdateResult.FAST_FORWARD));
                    }
                }

                if (IsForceUpdate)
                {
                    return(store.execute(RefUpdateResult.FORCED));
                }
                return(RefUpdateResult.REJECTED);
            }
            finally
            {
                unlock();
            }
        }
 /// <summary>
 /// Lookup an existing mapping.
 /// </summary>
 /// <param name="toFind">the object identifier to find.</param>
 /// <returns>the instance mapped to toFind, or null if no mapping exists.</returns>
 public TObject Get(AnyObjectId toFind)
 {
     return(this.SingleOrDefault(x => AnyObjectId.equals(toFind.ToObjectId(), x.ToObjectId())));
 }