Exemple #1
0
        internal SvnInfoEventArgs(string path, svn_client_info2_t info, AprPool pool)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }
            if (info == null)
            {
                throw new ArgumentNullException(nameof(info));
            }
            if (pool == null)
            {
                throw new ArgumentNullException(nameof(pool));
            }

            _info = info;
            _pool = pool;

            Path               = path;
            Revision           = info.rev;
            NodeKind           = (SvnNodeKind)info.kind;
            LastChangeRevision = info.last_changed_rev;
            LastChangeTime     = SvnBase.DateTimeFromAprTime(info.last_changed_date);
            HasLocalInfo       = (info.wc_info != null);

            if (info.wc_info != null)
            {
                _wcSchedule      = (SvnSchedule)info.wc_info.schedule;
                CopyFromRevision = info.wc_info.copyfrom_rev;
                Depth            = (SvnDepth)info.wc_info.depth;

                ContentTime = SvnBase.DateTimeFromAprTime(info.wc_info.recorded_time);
                if (info.wc_info.recorded_size == -1)
                {
                    WorkingCopySize = -1;
                }
                else
                {
                    WorkingCopySize = info.wc_info.recorded_size;
                }

                Conflicted = info.wc_info.conflicts != null && (info.wc_info.conflicts.nelts > 0);
            }
            else
            {
                Depth            = SvnDepth.Unknown;
                WorkingCopySize  = -1;
                CopyFromRevision = -1;
            }

            if (info.size == -1)
            {
                RepositorySize = -1;
            }
            else
            {
                RepositorySize = info.size;
            }
        }
        static VersionInfo CreateVersionInfo(Repository repo, SvnStatusEventArgs ent)
        {
            VersionStatus rs = VersionStatus.Unversioned;
            Revision      rr = null;

            // TODO: Fix remote status for Win32 Svn.
            if (ent.IsRemoteUpdated)
            {
                rs = ConvertStatus(SvnSchedule.Normal, ent.RemoteContentStatus);
                rr = new SvnRevision(repo, (int)ent.RemoteUpdateRevision, ent.RemoteUpdateCommitTime,
                                     ent.RemoteUpdateCommitAuthor, "(unavailable)", null);
            }

            SvnSchedule   sched  = ent.WorkingCopyInfo != null ? ent.WorkingCopyInfo.Schedule : SvnSchedule.Normal;
            VersionStatus status = ConvertStatus(sched, ent.LocalContentStatus);

            bool readOnly = File.Exists(ent.FullPath) && (File.GetAttributes(ent.FullPath) & FileAttributes.ReadOnly) != 0;

            if (ent.WorkingCopyInfo != null)
            {
                if (ent.RemoteLock != null || ent.WorkingCopyInfo.LockToken != null)
                {
                    status |= VersionStatus.LockRequired;
                    if (ent.WorkingCopyInfo.LockToken != null || (ent.RemoteLock != null && ent.RemoteLock.Token != null))
                    {
                        status |= VersionStatus.LockOwned;
                    }
                    else
                    {
                        status |= VersionStatus.Locked;
                    }
                }
                else if (readOnly)
                {
                    status |= VersionStatus.LockRequired;
                }
            }

            string repoPath = ent.Uri != null?ent.Uri.ToString() : null;

            SvnRevision newRev = null;

            if (ent.WorkingCopyInfo != null)
            {
                newRev = new SvnRevision(repo, (int)ent.WorkingCopyInfo.Revision);
            }

            VersionInfo ret = new VersionInfo(ent.FullPath, repoPath, ent.NodeKind == SvnNodeKind.Directory,
                                              status, newRev,
                                              rs, rr);

            return(ret);
        }
Exemple #3
0
        internal unsafe void Ensure()
        {
            if (_ensured || _status == null)
            {
                return;
            }

            _ensured = true;

            svn_wc_status2_t.__Internal *status2;

            var error = libsvnsharp_wc_private.svn_wc__status2_from_3(
                (void **)&status2,
                svn_wc_status3_t.__CreateInstance(_status.backwards_compatibility_baton),
                _client.CtxHandle.wc_ctx,
                _status.local_abspath,
                _pool.Handle,
                _pool.Handle);

            if (error != null)
            {
                throw SvnException.Create(error);
            }

            var entry = svn_wc_entry_t.__CreateInstance(status2->entry);

            _entry = entry;

            _revision           = entry.revision;
            _nodeKind           = (SvnNodeKind)entry.kind;
            _schedule           = (SvnSchedule)entry.schedule;
            _copied             = entry.copied;
            _deleted            = entry.deleted;
            _absent             = entry.absent;
            _incomplete         = entry.incomplete;
            _copyFromRev        = entry.copyfrom_rev;
            _textTime           = SvnBase.DateTimeFromAprTime(entry.text_time);
            _lastChangeRev      = entry.cmt_rev;
            _lastChangeTime     = SvnBase.DateTimeFromAprTime(entry.cmt_date);
            _lockTime           = SvnBase.DateTimeFromAprTime(entry.lock_creation_date);
            _hasProperties      = entry.has_props;
            _hasPropertyChanges = entry.has_prop_mods;
            _wcSize             = entry.working_size;
            _keepLocal          = entry.keep_local;
            _depth = (SvnDepth)entry.depth;
        }
Exemple #4
0
        static VersionStatus ConvertStatus(SvnSchedule schedule, SvnStatus status)
        {
            switch (schedule)
            {
            case SvnSchedule.Add: return(VersionStatus.Versioned | VersionStatus.ScheduledAdd);

            case SvnSchedule.Delete: return(VersionStatus.Versioned | VersionStatus.ScheduledDelete);

            case SvnSchedule.Replace: return(VersionStatus.Versioned | VersionStatus.ScheduledReplace);
            }

            switch (status)
            {
            case SvnStatus.None: return(VersionStatus.Versioned);

            case SvnStatus.Normal: return(VersionStatus.Versioned);

            case SvnStatus.NotVersioned: return(VersionStatus.Unversioned);

            case SvnStatus.Modified: return(VersionStatus.Versioned | VersionStatus.Modified);

            case SvnStatus.Merged: return(VersionStatus.Versioned | VersionStatus.Modified);

            case SvnStatus.Conflicted: return(VersionStatus.Versioned | VersionStatus.Conflicted);

            case SvnStatus.Ignored: return(VersionStatus.Unversioned | VersionStatus.Ignored);

            case SvnStatus.Obstructed: return(VersionStatus.Versioned);

            case SvnStatus.Added: return(VersionStatus.Versioned | VersionStatus.ScheduledAdd);

            case SvnStatus.Deleted: return(VersionStatus.Versioned | VersionStatus.ScheduledDelete);

            case SvnStatus.Replaced: return(VersionStatus.Versioned | VersionStatus.ScheduledReplace);
            }

            return(VersionStatus.Unversioned);
        }
		static VersionStatus ConvertStatus (SvnSchedule schedule, SvnStatus status)
		{
			switch (schedule) {
				case SvnSchedule.Add: return VersionStatus.Versioned | VersionStatus.ScheduledAdd;
				case SvnSchedule.Delete: return VersionStatus.Versioned | VersionStatus.ScheduledDelete;
				case SvnSchedule.Replace: return VersionStatus.Versioned | VersionStatus.ScheduledReplace;
			}

			switch (status) {
				case SvnStatus.None: return VersionStatus.Versioned;
				case SvnStatus.Normal: return VersionStatus.Versioned;
				case SvnStatus.NotVersioned: return VersionStatus.Unversioned;
				case SvnStatus.Modified: return VersionStatus.Versioned | VersionStatus.Modified;
				case SvnStatus.Merged: return VersionStatus.Versioned | VersionStatus.Modified;
				case SvnStatus.Conflicted: return VersionStatus.Versioned | VersionStatus.Conflicted;
				case SvnStatus.Ignored: return VersionStatus.Unversioned | VersionStatus.Ignored;
				case SvnStatus.Obstructed: return VersionStatus.Versioned;
				case SvnStatus.Added: return VersionStatus.Versioned | VersionStatus.ScheduledAdd;
				case SvnStatus.Deleted: return VersionStatus.Versioned | VersionStatus.ScheduledDelete;
				case SvnStatus.Replaced: return VersionStatus.Versioned | VersionStatus.ScheduledReplace;
			}

			return VersionStatus.Unversioned;
		}