public static int ReportDuplicates(
[NotNull] IRow row1, int tableIndex1,
[NotNull] IRow row2, int tableIndex2,
[NotNull] IErrorReporting errorReporting,
[CanBeNull] IssueCode issueCode,
[CanBeNull] IValidRelationConstraint validRelationConstraint)
{
Assert.ArgumentNotNull(row1, nameof(row1));
Assert.ArgumentNotNull(row2, nameof(row2));
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
string errorDescription;
if (!AreDuplicates(row1, tableIndex1,
row2, tableIndex2,
validRelationConstraint,
out errorDescription))
{
return(_noError);
}
IGeometry errorGeometry = ((IFeature)row1).ShapeCopy;
const bool reportIndividualParts = false;
return(errorReporting.Report(errorDescription,
errorGeometry, issueCode,
reportIndividualParts,
row1, row2));
}
public static int ReportIntersections(
[NotNull] IRow row1, int tableIndex1,
[NotNull] IRow row2, int tableIndex2,
[NotNull] IErrorReporting errorReporting,
[CanBeNull] IssueCode issueCode,
[CanBeNull] IValidRelationConstraint validRelationConstraint,
bool reportIndividualParts,
[CanBeNull] GeometryConstraint validIntersectionGeometryConstraint = null,
GeometryComponent geomComponent1 = GeometryComponent.EntireGeometry,
GeometryComponent geomComponent2 = GeometryComponent.EntireGeometry)
{
Assert.ArgumentNotNull(row1, nameof(row1));
Assert.ArgumentNotNull(row2, nameof(row2));
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
if (row1 == row2)
{
return(_noError);
}
string errorDescription;
if (HasFulfilledConstraint(row1, tableIndex1,
row2, tableIndex2,
validRelationConstraint, "Features intersect",
out errorDescription))
{
return(_noError);
}
IGeometry shape1 = ((IFeature)row1).Shape;
IGeometry shape2 = ((IFeature)row2).Shape;
var g1 = GeometryComponentUtils.GetGeometryComponent(shape1, geomComponent1);
var g2 = GeometryComponentUtils.GetGeometryComponent(shape2, geomComponent2);
var errorCount = 0;
if (g1 != null && g2 != null)
{
foreach (IGeometry errorGeometry in
IntersectionUtils.GetAllIntersections(g1, g2))
{
if (validIntersectionGeometryConstraint == null ||
!validIntersectionGeometryConstraint.IsFulfilled(errorGeometry))
{
errorCount += errorReporting.Report(errorDescription,
errorGeometry,
issueCode, reportIndividualParts,
row1, row2);
}
}
}
return(errorCount);
}
public VertexCoincidenceChecker(
[NotNull] IErrorReporting errorReporting,
[NotNull] Func <double, string, double, string, string> formatComparisonFunction,
double maximumXYTolerance)
{
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
Assert.ArgumentNotNull(formatComparisonFunction, nameof(formatComparisonFunction));
Assert.ArgumentCondition(maximumXYTolerance > 0, "maximum xy tolerance must be > 0");
_errorReporting = errorReporting;
_formatComparisonFunction = formatComparisonFunction;
_maximumXYTolerance = maximumXYTolerance;
}
public ZDifferenceStrategyBoundingBox(double minimumZDifference,
[CanBeNull] string minimumZDifferenceExpression,
double maximumZDifference,
[CanBeNull] string maximumZDifferenceExpression,
[CanBeNull] string zRelationConstraint,
bool expressionCaseSensitivity,
[NotNull] IErrorReporting errorReporting,
[NotNull] Func <double, string, double, string, string>
formatComparisonFunction)
: base(minimumZDifference, minimumZDifferenceExpression,
maximumZDifference, maximumZDifferenceExpression,
zRelationConstraint, expressionCaseSensitivity,
errorReporting, formatComparisonFunction)
{
}
public ZDifferenceStrategyIntersectionPoints(
double minimumZDifference, [CanBeNull] string minimumZDifferenceExpression,
double maximumZDifference, [CanBeNull] string maximumZDifferenceExpression,
[CanBeNull] string zRelationConstraint, bool expressionCaseSensitivity,
[NotNull] IErrorReporting errorReporting,
[NotNull] Func <double, string, double, string, string> formatComparisonFunction,
Func <int, bool> useDistanceFromPlane = null,
double coplanarityTolerance = 0,
bool ignoreNonCoplanarReferenceRings = false)
: base(minimumZDifference, minimumZDifferenceExpression,
maximumZDifference, maximumZDifferenceExpression,
zRelationConstraint, expressionCaseSensitivity,
errorReporting, formatComparisonFunction)
{
_useDistanceFromPlane = useDistanceFromPlane;
_coplanarityTolerance = coplanarityTolerance;
_ignoreNonCoplanarReferenceRings = ignoreNonCoplanarReferenceRings;
}
protected ZDifferenceStrategy(
double minimumZDifference, [CanBeNull] string minimumZDifferenceExpression,
double maximumZDifference, [CanBeNull] string maximumZDifferenceExpression,
[CanBeNull] string zRelationConstraint, bool expressionCaseSensitivity,
[NotNull] IErrorReporting errorReporting,
[NotNull] Func <double, string, double, string, string> formatComparisonFunction)
{
Assert.ArgumentNotNaN(minimumZDifference, nameof(minimumZDifference));
Assert.ArgumentNotNaN(maximumZDifference, nameof(maximumZDifference));
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
Assert.ArgumentNotNull(formatComparisonFunction,
nameof(formatComparisonFunction));
_minimumZDifference = minimumZDifference;
_maximumZDifference = maximumZDifference;
if (StringUtils.IsNotEmpty(minimumZDifferenceExpression))
{
_minimumZDifferenceExpression = new ZDifferenceBoundExpression(
minimumZDifferenceExpression, expressionCaseSensitivity);
}
if (StringUtils.IsNotEmpty(maximumZDifferenceExpression))
{
_maximumZDifferenceExpression = new ZDifferenceBoundExpression(
maximumZDifferenceExpression, expressionCaseSensitivity);
}
ErrorReporting = errorReporting;
_formatComparisonFunction = formatComparisonFunction;
if (zRelationConstraint != null &&
zRelationConstraint.IndexOf(_zDifferenceColumn,
StringComparison
.InvariantCultureIgnoreCase) >= 0)
{
_zDifferenceColumnValue = new Dictionary <string, object>();
}
_zRelationCondition = new ZRelationCondition(
zRelationConstraint,
expressionCaseSensitivity);
}
public static int ReportOverlaps(
[NotNull] IRow row1, int tableIndex1,
[NotNull] IRow row2, int tableIndex2,
[NotNull] IErrorReporting errorReporting,
[CanBeNull] IssueCode issueCode,
[CanBeNull] IValidRelationConstraint validRelationConstraint,
bool reportIndividualParts)
{
Assert.ArgumentNotNull(row1, nameof(row1));
Assert.ArgumentNotNull(row2, nameof(row2));
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
if (row1 == row2)
{
return(_noError);
}
IGeometry g1 = ((IFeature)row1).Shape;
IGeometry g2 = ((IFeature)row2).Shape;
string errorDescription;
if (HasFulfilledConstraint(row1, tableIndex1,
row2, tableIndex2,
validRelationConstraint, "Features overlap",
out errorDescription))
{
return(_noError);
}
IGeometry intersection = TestUtils.GetOverlap(g1, g2);
if (intersection.IsEmpty)
{
Marshal.ReleaseComObject(intersection);
return(_noError);
}
return(errorReporting.Report(errorDescription,
intersection, issueCode,
reportIndividualParts,
row1, row2));
}
public static ZDifferenceStrategy CreateStrategy(
ZComparisonMethod zComparisonMethod,
double minimumZDifference,
string minimumZDifferenceExpression,
double maximumZDifference,
string maximumZDifferenceExpression,
[CanBeNull] string zRelationConstraint,
bool caseSensitivity,
[NotNull] Func <double, string, double, string, string> formatComparisonFunction,
[NotNull] IErrorReporting errorReporting,
Func <int, bool> useDistanceFromPlane = null,
double coplanarityTolerance = 0,
bool ignoreNonCoplanarReferenceRings = false)
{
switch (zComparisonMethod)
{
case ZComparisonMethod.BoundingBox:
return(new ZDifferenceStrategyBoundingBox(
minimumZDifference, minimumZDifferenceExpression,
maximumZDifference, maximumZDifferenceExpression,
zRelationConstraint, caseSensitivity,
errorReporting, formatComparisonFunction));
case ZComparisonMethod.IntersectionPoints:
return(new ZDifferenceStrategyIntersectionPoints(
minimumZDifference, minimumZDifferenceExpression,
maximumZDifference, maximumZDifferenceExpression,
zRelationConstraint, caseSensitivity,
errorReporting, formatComparisonFunction,
useDistanceFromPlane, coplanarityTolerance,
ignoreNonCoplanarReferenceRings
));
default:
throw new ArgumentOutOfRangeException(
nameof(zComparisonMethod), zComparisonMethod,
$@"Unsupported ZComparisonMethod: {zComparisonMethod}");
}
}
/// <summary>
/// Prepares the return value for the GetRequest method in the event of an exception.
/// </summary>
/// <param name="ex">The exception that forms the basis of the error response. Must not be null.</param>
/// <param name="request">The incoming HTTP request. Must not be null.</param>
/// <param name="incomingMessage">The incoming message. May be null in the case that it was malformed.</param>
/// <returns>
/// Either the <see cref="IRequest"/> to return to the host site or null to indicate no response could be reasonably created and that the caller should rethrow the exception.
/// </returns>
private IRequest GetErrorResponse(ProtocolException ex, HttpRequestMessage request, IDirectedProtocolMessage incomingMessage)
{
Requires.NotNull(ex, "ex");
Requires.NotNull(request, "request");
Logger.OpenId.ErrorException("An exception was generated while processing an incoming OpenID request.", ex);
IErrorMessage errorMessage;
// We must create the appropriate error message type (direct vs. indirect)
// based on what we see in the request.
string returnTo = HttpUtility.ParseQueryString(request.RequestUri.Query)[Protocol.Default.openid.return_to];
if (returnTo != null)
{
// An indirect request message from the RP
// We need to return an indirect response error message so the RP can consume it.
// Consistent with OpenID 2.0 section 5.2.3.
var indirectRequest = incomingMessage as SignedResponseRequest;
if (indirectRequest != null)
{
errorMessage = new IndirectErrorResponse(indirectRequest);
}
else
{
errorMessage = new IndirectErrorResponse(Protocol.Default.Version, new Uri(returnTo));
}
}
else if (request.Method == HttpMethod.Post)
{
// A direct request message from the RP
// We need to return a direct response error message so the RP can consume it.
// Consistent with OpenID 2.0 section 5.1.2.2.
errorMessage = new DirectErrorResponse(Protocol.Default.Version, incomingMessage);
}
else
{
// This may be an indirect request from an RP that was so badly
// formed that we cannot even return an error to the RP.
// The best we can do is display an error to the user.
// Returning null cues the caller to "throw;"
return(null);
}
errorMessage.ErrorMessage = ex.ToStringDescriptive();
// Allow host to log this error and issue a ticket #.
// We tear off the field to a local var for thread safety.
IErrorReporting hostErrorHandler = this.ErrorReporting;
if (hostErrorHandler != null)
{
errorMessage.Contact = hostErrorHandler.Contact;
errorMessage.Reference = hostErrorHandler.LogError(ex);
}
if (incomingMessage != null)
{
return(new AutoResponsiveRequest(incomingMessage, errorMessage, this.SecuritySettings));
}
else
{
return(new AutoResponsiveRequest(errorMessage, this.SecuritySettings));
}
}
public int ReportErrors([NotNull] IFeature feature1, int tableIndex1,
[NotNull] IFeature feature2, int tableIndex2,
[NotNull] IErrorReporting reportError,
[CanBeNull] IssueCode issueCode,
bool reportIndividualErrors)
{
Assert.ArgumentNotNull(feature1, nameof(feature1));
Assert.ArgumentNotNull(feature2, nameof(feature2));
Assert.ArgumentNotNull(reportError, nameof(reportError));
if (feature1 == feature2)
{
return(0);
}
string conditionMessage;
if (IsFulfilled(feature1, tableIndex1,
feature2, tableIndex2,
out conditionMessage))
{
// currently: no error, even if intersection geometry constraint would be violated
// (parameter for constraint combination operation could be added)
return(0);
}
// geometries of multiple dimensions possible
var errorCount = 0;
foreach (IGeometry geometry in GetIntersections(feature1, feature2))
{
foreach (IGeometry reportableGeometry in GetGeometries(geometry,
reportIndividualErrors))
{
if (_validIntersectionDimensions != null &&
_validIntersectionDimensions.Contains(reportableGeometry.Dimension))
{
continue;
}
if (_intersectionGeometryConstraint != null)
{
if (_intersectionGeometryConstraint.IsFulfilled(reportableGeometry))
{
continue;
}
string displayValues =
_intersectionGeometryConstraint.FormatValues(reportableGeometry,
CultureInfo.CurrentCulture)
.Replace("$", string.Empty);
string rawValues =
_intersectionGeometryConstraint.FormatValues(reportableGeometry,
CultureInfo
.InvariantCulture);
// format for display to the user (current culture)
string description = GetErrorDescription(
conditionMessage,
_intersectionGeometryConstraint.Constraint.Replace("$", string.Empty),
displayValues);
errorCount += reportError.Report(description, reportableGeometry,
issueCode, null,
new object[] { rawValues },
feature1, feature2);
}
else
{
string description = GetErrorDescription(conditionMessage);
errorCount += reportError.Report(description, reportableGeometry,
issueCode, null,
feature1, feature2);
}
}
}
return(errorCount);
}
public static int ReportCrossings(
[NotNull] IRow row1, int tableIndex1,
[NotNull] IRow row2, int tableIndex2,
[NotNull] IErrorReporting errorReporting,
[CanBeNull] IssueCode issueCode,
[CanBeNull] IValidRelationConstraint validRelationConstraint,
bool reportIndividualParts)
{
Assert.ArgumentNotNull(row1, nameof(row1));
Assert.ArgumentNotNull(row2, nameof(row2));
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
if (row1 == row2)
{
return(_noError);
}
IGeometry g1 = ((IFeature)row1).Shape;
IGeometry g2 = ((IFeature)row2).Shape;
string errorDescription;
if (HasFulfilledConstraint(row1, tableIndex1,
row2, tableIndex2,
validRelationConstraint, "Features cross",
out errorDescription))
{
return(_noError);
}
var errorCount = 0;
foreach (IGeometry errorGeometry in GetCrossings(g1, g2))
{
if (errorGeometry.IsEmpty)
{
continue;
}
errorCount += errorReporting.Report(errorDescription,
errorGeometry, issueCode,
reportIndividualParts,
row1, row2);
}
return(errorCount);
//const bool overlap = false;
//IGeometry intersection = TestUtils.GetIntersection(g1, g2, overlap);
//// TODO remove boundary
//try
//{
// if (intersection.IsEmpty)
// {
// return _noError;
// }
// return errorReporting.Report("Features cross",
// intersection, reportIndividualParts,
// row1, row2);
//}
//finally
//{
// Marshal.ReleaseComObject(intersection);
//}
}
public static int ReportTouches(
[NotNull] IRow row1, int tableIndex1,
[NotNull] IRow row2, int tableIndex2,
[NotNull] IErrorReporting errorReporting,
[CanBeNull] IssueCode issueCode,
[CanBeNull] IValidRelationConstraint validRelationConstraint,
[CanBeNull] GeometryConstraint validTouchGeometryConstraint,
bool reportIndividualParts = false)
{
Assert.ArgumentNotNull(row1, nameof(row1));
Assert.ArgumentNotNull(row2, nameof(row2));
Assert.ArgumentNotNull(errorReporting, nameof(errorReporting));
if (row1 == row2)
{
return(_noError);
}
IGeometry g1 = ((IFeature)row1).Shape;
IGeometry g2 = ((IFeature)row2).Shape;
string errorDescription;
if (HasFulfilledConstraint(row1, tableIndex1,
row2, tableIndex2,
validRelationConstraint, "Geometries touch",
out errorDescription))
{
return(_noError);
}
var errorCount = 0;
foreach (IGeometry geometry in GetTouches(g1, g2))
{
if (geometry.IsEmpty)
{
continue;
}
if (reportIndividualParts)
{
foreach (IGeometry part in GeometryUtils.Explode(geometry))
{
if (part.IsEmpty ||
validTouchGeometryConstraint != null &&
validTouchGeometryConstraint.IsFulfilled(part))
{
continue;
}
errorCount += errorReporting.Report(errorDescription,
part, issueCode,
false, // already exploded
row1, row2);
}
}
else
{
if (validTouchGeometryConstraint != null &&
validTouchGeometryConstraint.IsFulfilled(geometry))
{
continue;
}
errorCount += errorReporting.Report(errorDescription,
geometry, issueCode,
false,
row1, row2);
}
}
return(errorCount);
}
/// <summary>
/// Prepares the return value for the GetRequest method in the event of an exception.
/// </summary>
/// <param name="ex">The exception that forms the basis of the error response. Must not be null.</param>
/// <param name="httpRequestInfo">The incoming HTTP request. Must not be null.</param>
/// <param name="incomingMessage">The incoming message. May be null in the case that it was malformed.</param>
/// <returns>
/// Either the <see cref="IRequest"/> to return to the host site or null to indicate no response could be reasonably created and that the caller should rethrow the exception.
/// </returns>
private IRequest GetErrorResponse(ProtocolException ex, HttpRequestInfo httpRequestInfo, IDirectedProtocolMessage incomingMessage)
{
ErrorUtilities.VerifyArgumentNotNull(ex, "ex");
ErrorUtilities.VerifyArgumentNotNull(httpRequestInfo, "httpRequestInfo");
Logger.Error("An exception was generated while processing an incoming OpenID request.", ex);
IErrorMessage errorMessage;
// We must create the appropriate error message type (direct vs. indirect)
// based on what we see in the request.
if (httpRequestInfo.QueryString[Protocol.Default.openid.return_to] != null)
{
// An indirect request message from the RP
// We need to return an indirect response error message so the RP can consume it.
// Consistent with OpenID 2.0 section 5.2.3.
var indirectRequest = incomingMessage as SignedResponseRequest;
if (indirectRequest != null)
{
errorMessage = new IndirectErrorResponse(indirectRequest);
}
else
{
errorMessage = new IndirectErrorResponse(Protocol.Default.Version, new Uri(httpRequestInfo.QueryString[Protocol.Default.openid.return_to]));
}
}
else if (httpRequestInfo.HttpMethod == "POST")
{
// A direct request message from the RP
// We need to return a direct response error message so the RP can consume it.
// Consistent with OpenID 2.0 section 5.1.2.2.
errorMessage = new DirectErrorResponse(Protocol.Default.Version, incomingMessage);
}
else
{
// This may be an indirect request from an RP that was so badly
// formed that we cannot even return an error to the RP.
// The best we can do is display an error to the user.
// Returning null cues the caller to "throw;"
return(null);
}
errorMessage.ErrorMessage = ex.GetAllMessages();
// Allow host to log this error and issue a ticket #.
// We tear off the field to a local var for thread safety.
IErrorReporting hostErrorHandler = this.ErrorReporting;
if (hostErrorHandler != null)
{
errorMessage.Contact = hostErrorHandler.Contact;
errorMessage.Reference = hostErrorHandler.LogError(ex);
}
if (incomingMessage != null)
{
return(new AutoResponsiveRequest(this, incomingMessage, errorMessage));
}
else
{
return(new AutoResponsiveRequest(this, errorMessage));
}
}
