public void Write( FilePath filePath, Stream data, DateTimeOffset modificationTime, int mode, string userId, string groupId, char typeflag, string userName, string groupName, string deviceMajorNumber, string deviceMinorNumber, string entrySha, bool isLink) { FileNameExtendedHeader fileNameExtendedHeader = FileNameExtendedHeader.Parse(filePath.Posix, entrySha); LinkExtendedHeader linkExtendedHeader = ParseLink(isLink, data, entrySha); WriteExtendedHeader(fileNameExtendedHeader, linkExtendedHeader, entrySha, modificationTime); // Note: in case of links, we won't add a content, but the size in the header will still be != 0. It seems strange, but it seem to be what git.git is doing? WriteHeader(fileNameExtendedHeader.Name, fileNameExtendedHeader.Prefix, modificationTime, (data != null) ? data.Length : 0, mode, userId, groupId, typeflag, linkExtendedHeader.Link, userName, groupName, deviceMajorNumber, deviceMinorNumber); // folders have no data, and so do links if (data != null && !isLink) { WriteContent(data.Length, data, OutStream); } AlignTo512((data != null) ? data.Length : 0, false); }
internal unsafe FilterSource(FilePath path, FilterMode mode, git_filter_source* source) { SourceMode = mode; ObjectId = ObjectId.BuildFromPtr(&source->oid); Path = path.Native; Root = Proxy.git_repository_workdir(new IntPtr(source->repository)).Native; }
public static IntPtr FromManaged(FilePath filePath) { if (null == filePath) { return IntPtr.Zero; } return Utf8Marshaler.FromManaged(filePath.Posix); }
public static IntPtr FromManaged(FilePath filePath) { if (filePath == null) { return IntPtr.Zero; } return StrictUtf8Marshaler.FromManaged(filePath.Posix); }
internal TreeEntryChanges(FilePath path, Mode mode, ObjectId oid, ChangeKind status, FilePath oldPath, Mode oldMode, ObjectId oldOid) { Path = path.Native; Mode = mode; Oid = oid; Status = status; OldPath = oldPath.Native; OldMode = oldMode; OldOid = oldOid; }
internal TreeEntryChanges(FilePath path, Mode mode, ObjectId oid, ChangeKind status, FilePath oldPath, Mode oldMode, ObjectId oldOid, bool isBinaryComparison) { Path = path.Native; Mode = mode; Oid = oid; Status = status; OldPath = oldPath.Native; OldMode = oldMode; OldOid = oldOid; IsBinaryComparison = isBinaryComparison; }
public static GitStrArrayIn BuildFrom(FilePath[] paths) { var nbOfPaths = paths.Length; var pathPtrs = new IntPtr[nbOfPaths]; for (int i = 0; i < nbOfPaths; i++) { var s = paths[i].Posix; pathPtrs[i] = FilePathMarshaler.FromManaged(s); } int dim = IntPtr.Size * nbOfPaths; IntPtr arrayPtr = Marshal.AllocHGlobal(dim); Marshal.Copy(pathPtrs, 0, arrayPtr, nbOfPaths); return new GitStrArrayIn { strings = arrayPtr, size = (uint)nbOfPaths }; }
/// <summary> /// Create wrapper around <see cref="GitCheckoutOpts"/> from <see cref="CheckoutOptions"/>. /// </summary> /// <param name="options">Options to create native GitCheckoutOpts structure from.</param> /// <param name="paths">Paths to checkout.</param> public GitCheckoutOptsWrapper(IConvertableToGitCheckoutOpts options, FilePath[] paths = null) { Callbacks = options.GenerateCallbacks(); if (paths != null) { PathArray = GitStrArrayManaged.BuildFrom(paths); } Options = new GitCheckoutOpts { version = 1, checkout_strategy = options.CheckoutStrategy, progress_cb = Callbacks.CheckoutProgressCallback, notify_cb = Callbacks.CheckoutNotifyCallback, notify_flags = options.CheckoutNotifyFlags, paths = PathArray.Array, }; }
public static GitRepositoryInitOptions BuildFrom(FilePath workdirPath, bool isBare) { var opts = new GitRepositoryInitOptions { Flags = GitRepositoryInitFlags.GIT_REPOSITORY_INIT_MKPATH, Mode = 0 /* GIT_REPOSITORY_INIT_SHARED_UMASK */ }; if (workdirPath != null) { Debug.Assert(!isBare); opts.WorkDirPath = StrictFilePathMarshaler.FromManaged(workdirPath); } if (isBare) { opts.Flags |= GitRepositoryInitFlags.GIT_REPOSITORY_INIT_BARE; } return opts; }
private static Tuple<string, string> ExtractPosixLeadingSegment(FilePath targetPath) { string[] segments = targetPath.Posix.Split(new[] { '/' }, 2); if (segments[0] == string.Empty || (segments.Length == 2 && (segments[1] == string.Empty || segments[1].StartsWith("/", StringComparison.Ordinal)))) { throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "'{0}' is not a valid path.", targetPath)); } return new Tuple<string, string>(segments[0], segments.Length == 2 ? segments[1] : null); }
private static GitDiffOptions BuildOptions(DiffModifiers diffOptions, FilePath[] filePaths = null, MatchedPathsAggregator matchedPathsAggregator = null, CompareOptions compareOptions = null) { var options = new GitDiffOptions(); options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_TYPECHANGE; compareOptions = compareOptions ?? new CompareOptions(); options.ContextLines = (ushort)compareOptions.ContextLines; options.InterhunkLines = (ushort)compareOptions.InterhunkLines; if (diffOptions.HasFlag(DiffModifiers.IncludeUntracked)) { options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_UNTRACKED | GitDiffOptionFlags.GIT_DIFF_RECURSE_UNTRACKED_DIRS | GitDiffOptionFlags.GIT_DIFF_INCLUDE_UNTRACKED_CONTENT; } if (diffOptions.HasFlag(DiffModifiers.IncludeIgnored)) { options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_IGNORED; } if (diffOptions.HasFlag(DiffModifiers.IncludeUnmodified)) { options.Flags |= GitDiffOptionFlags.GIT_DIFF_INCLUDE_UNMODIFIED; } if (diffOptions.HasFlag(DiffModifiers.DisablePathspecMatch)) { options.Flags |= GitDiffOptionFlags.GIT_DIFF_DISABLE_PATHSPEC_MATCH; } if (matchedPathsAggregator != null) { options.NotifyCallback = matchedPathsAggregator.OnGitDiffNotify; } if (filePaths == null) { return options; } options.PathSpec = GitStrArrayIn.BuildFrom(filePaths); return options; }
internal GitObject LookupTreeEntryTarget(ObjectId id, FilePath path) { return LookupInternal(id, GitObjectType.Any, path); }
internal GitObject LookupInternal(ObjectId id, GitObjectType type, FilePath knownPath) { Ensure.ArgumentNotNull(id, "id"); GitOid oid = id.Oid; GitObjectSafeHandle obj = null; try { int res; if (id is AbbreviatedObjectId) { res = NativeMethods.git_object_lookup_prefix(out obj, handle, ref oid, (uint)((AbbreviatedObjectId)id).Length, type); } else { res = NativeMethods.git_object_lookup(out obj, handle, ref oid, type); } if (res == (int)GitErrorCode.GIT_ENOTFOUND) { return null; } Ensure.Success(res); if (id is AbbreviatedObjectId) { id = GitObject.ObjectIdOf(obj); } return GitObject.CreateFromPtr(obj, id, this, knownPath); } finally { obj.SafeDispose(); } }