1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
namespace LibGit2Sharp.Core
{
/// <summary>
/// Ensure input parameters
/// </summary>
[DebuggerStepThrough]
internal static class Ensure
{
/// <summary>
/// Checks an argument to ensure it isn't null.
/// </summary>
/// <param name="argumentValue">The argument value to check.</param>
/// <param name="argumentName">The name of the argument.</param>
public static void ArgumentNotNull(object argumentValue, string argumentName)
{
if (argumentValue == null)
{
throw new ArgumentNullException(argumentName);
}
}
/// <summary>
/// Checks a string argument to ensure it isn't null or empty.
/// </summary>
/// <param name="argumentValue">The argument value to check.</param>
/// <param name="argumentName">The name of the argument.</param>
public static void ArgumentNotNullOrEmptyString(string argumentValue, string argumentName)
{
ArgumentNotNull(argumentValue, argumentName);
if (argumentValue.Trim().Length == 0)
{
throw new ArgumentException("String cannot be empty", argumentName);
}
}
/// <summary>
/// Checks a string argument to ensure it doesn't contain a zero byte.
/// </summary>
/// <param name="argumentValue">The argument value to check.</param>
/// <param name="argumentName">The name of the argument.</param>
public static void ArgumentDoesNotContainZeroByte(string argumentValue, string argumentName)
{
if (string.IsNullOrEmpty(argumentValue))
{
return;
}
int zeroPos = -1;
for (var i = 0; i < argumentValue.Length; i++)
{
if (argumentValue[i] == '\0')
{
zeroPos = i;
break;
}
}
if (zeroPos == -1)
{
return;
}
throw new ArgumentException(
string.Format("Zero bytes ('\\0') are not allowed. A zero byte has been found at position {0}.", zeroPos), argumentName);
}
private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException>>
GitErrorsToLibGit2SharpExceptions =
new Dictionary<GitErrorCode, Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException>>
{
{ GitErrorCode.User, (m, r, c) => new UserCancelledException(m, r, c) },
{ GitErrorCode.BareRepo, (m, r, c) => new BareRepositoryException(m, r, c) },
{ GitErrorCode.Exists, (m, r, c) => new NameConflictException(m, r, c) },
{ GitErrorCode.InvalidSpecification, (m, r, c) => new InvalidSpecificationException(m, r, c) },
{ GitErrorCode.UnmergedEntries, (m, r, c) => new UnmergedIndexEntriesException(m, r, c) },
{ GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },
{ GitErrorCode.MergeConflict, (m, r, c) => new MergeConflictException(m, r, c) },
{ GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },
};
private static void HandleError(int result)
{
string errorMessage;
GitError error = NativeMethods.giterr_last().MarshalAsGitError();
if (error == null)
{
error = new GitError { Category = GitErrorCategory.Unknown, Message = IntPtr.Zero };
errorMessage = "No error message has been provided by the native library";
}
else
{
errorMessage = LaxUtf8Marshaler.FromNative(error.Message);
}
Func<string, GitErrorCode, GitErrorCategory, LibGit2SharpException> exceptionBuilder;
if (!GitErrorsToLibGit2SharpExceptions.TryGetValue((GitErrorCode) result, out exceptionBuilder))
{
exceptionBuilder = (m, r, c) => new LibGit2SharpException(m, r, c);
}
throw exceptionBuilder(errorMessage, (GitErrorCode) result, error.Category);
}
/// <summary>
/// Check that the result of a C call was successful
/// <para>
/// The native function is expected to return strictly 0 for
/// success or a negative value in the case of failure.
/// </para>
/// </summary>
/// <param name="result">The result to examine.</param>
public static void ZeroResult(int result)
{
if (result == (int)GitErrorCode.Ok)
{
return;
}
HandleError(result);
}
/// <summary>
/// Check that the result of a C call that returns a boolean value
/// was successful
/// <para>
/// The native function is expected to return strictly 0 for
/// success or a negative value in the case of failure.
/// </para>
/// </summary>
/// <param name="result">The result to examine.</param>
public static void BooleanResult(int result)
{
if (result == (int)GitErrorCode.Ok || result == 1)
{
return;
}
HandleError(result);
}
/// <summary>
/// Check that the result of a C call that returns an integer value
/// was successful
/// <para>
/// The native function is expected to return strictly 0 for
/// success or a negative value in the case of failure.
/// </para>
/// </summary>
/// <param name="result">The result to examine.</param>
public static void Int32Result(int result)
{
if (result >= (int)GitErrorCode.Ok)
{
return;
}
HandleError(result);
}
/// <summary>
/// Checks an argument by applying provided checker.
/// </summary>
/// <param name="argumentValue">The argument value to check.</param>
/// <param name="checker">The predicate which has to be satisfied</param>
/// <param name="argumentName">The name of the argument.</param>
public static void ArgumentConformsTo<T>(T argumentValue, Func<T, bool> checker, string argumentName)
{
if (checker(argumentValue))
{
return;
}
throw new ArgumentException(argumentName);
}
public static void GitObjectIsNotNull(GitObject gitObject, string identifier)
{
if (gitObject != null)
{
return;
}
throw new LibGit2SharpException(string.Format(CultureInfo.InvariantCulture,
"No valid git object identified by '{0}' exists in the repository.",
identifier));
}
}
}
|
