public virtual DeploymentDto redeploy(UriInfo uriInfo, RedeploymentDto redeployment)
{
DeploymentWithDefinitions deployment = null;
try
{
deployment = tryToRedeploy(redeployment);
}
catch (NotFoundException e)
{
throw createInvalidRequestException("redeploy", Status.NOT_FOUND, e);
}
catch (NotValidException e)
{
throw createInvalidRequestException("redeploy", Status.BAD_REQUEST, e);
}
DeploymentWithDefinitionsDto deploymentDto = DeploymentWithDefinitionsDto.fromDeployment(deployment);
URI uri = uriInfo.BaseUriBuilder.path(relativeRootResourcePath).path(org.camunda.bpm.engine.rest.DeploymentRestService_Fields.PATH).path(deployment.Id).build();
// GET /
deploymentDto.addReflexiveLink(uri, HttpMethod.GET, "self");
return(deploymentDto);
}
public virtual IList <DeploymentDto> getDeployments(UriInfo uriInfo, int?firstResult, int?maxResults)
{
DeploymentQueryDto queryDto = new DeploymentQueryDto(ObjectMapper, uriInfo.QueryParameters);
ProcessEngine engine = ProcessEngine;
DeploymentQuery query = queryDto.toQuery(engine);
IList <Deployment> matchingDeployments;
if (firstResult != null || maxResults != null)
{
matchingDeployments = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
matchingDeployments = query.list();
}
IList <DeploymentDto> deployments = new List <DeploymentDto>();
foreach (Deployment deployment in matchingDeployments)
{
DeploymentDto def = DeploymentDto.fromDeployment(deployment);
deployments.Add(def);
}
return(deployments);
}
public virtual IList <IncidentDto> getIncidents(UriInfo uriInfo, int?firstResult, int?maxResults)
{
IncidentQueryDto queryDto = new IncidentQueryDto(ObjectMapper, uriInfo.QueryParameters);
IncidentQuery query = queryDto.toQuery(processEngine);
IList <Incident> queryResult;
if (firstResult != null || maxResults != null)
{
queryResult = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
queryResult = query.list();
}
IList <IncidentDto> result = new List <IncidentDto>();
foreach (Incident incident in queryResult)
{
IncidentDto dto = IncidentDto.fromIncident(incident);
result.Add(dto);
}
return(result);
}
public static UriInfo GetUriInfo()
{
// 起動に使用されたURLスキームを解析.
var urlScheme = UrlSchemeReader.GetBootUrlScheme();
return(UriInfo.Parse(urlScheme));
}
private UriInfo UriInfo(URI baseUri)
{
UriInfo uriInfo = mock(typeof(UriInfo));
when(uriInfo.BaseUri).thenReturn(baseUri);
return(uriInfo);
}
private void AddButton_Click(object sender, EventArgs e)
{
using (AddAddressesDialog dialog = new AddAddressesDialog())
{
if (dialog.ShowDialog(this) == DialogResult.OK)
{
string[] addresses;
addresses = dialog.Addresses;
for (int i = 0; i < addresses.Length; i++)
{
string address;
address = addresses[i];
if (!_items.Contains(address))
{
UriInfo item;
ListViewItem listViewItem;
item = new UriInfo(address);
listViewItem = this.CreateListViewItem(item);
this.Populate(item, listViewItem);
addressesListView.Items.Add(listViewItem);
_items.Add(item);
}
}
}
}
}
public virtual CommentDto createComment(UriInfo uriInfo, CommentDto commentDto)
{
ensureHistoryEnabled(Status.FORBIDDEN);
ensureTaskExists(Status.BAD_REQUEST);
Comment comment;
try
{
comment = engine.TaskService.createComment(taskId, null, commentDto.Message);
}
catch (ProcessEngineException e)
{
throw new InvalidRequestException(Status.BAD_REQUEST, e, "Not enough parameters submitted");
}
URI uri = uriInfo.BaseUriBuilder.path(rootResourcePath).path(org.camunda.bpm.engine.rest.TaskRestService_Fields.PATH).path(taskId + "/comment/" + comment.Id).build();
CommentDto resultDto = CommentDto.fromComment(comment);
// GET /
resultDto.addReflexiveLink(uri, HttpMethod.GET, "self");
return(resultDto);
}
public virtual IList <HistoricDetailDto> getHistoricDetails(UriInfo uriInfo, int?firstResult, int?maxResults, bool deserializeObjectValues)
{
HistoricDetailQueryDto queryDto = new HistoricDetailQueryDto(objectMapper, uriInfo.QueryParameters);
HistoricDetailQuery query = queryDto.toQuery(processEngine);
return(executeHistoricDetailQuery(query, firstResult, maxResults, deserializeObjectValues));
}
public virtual CountResultDto queryUserOperationCount(UriInfo uriInfo)
{
UserOperationLogQueryDto queryDto = new UserOperationLogQueryDto(objectMapper, uriInfo.QueryParameters);
UserOperationLogQuery query = queryDto.toQuery(processEngine);
return(new CountResultDto(query.count()));
}
public virtual IList <DecisionDefinitionDto> getDecisionDefinitions(UriInfo uriInfo, int?firstResult, int?maxResults)
{
DecisionDefinitionQueryDto queryDto = new DecisionDefinitionQueryDto(ObjectMapper, uriInfo.QueryParameters);
IList <DecisionDefinitionDto> definitions = new List <DecisionDefinitionDto>();
ProcessEngine engine = ProcessEngine;
DecisionDefinitionQuery query = queryDto.toQuery(engine);
IList <DecisionDefinition> matchingDefinitions = null;
if (firstResult != null || maxResults != null)
{
matchingDefinitions = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
matchingDefinitions = query.list();
}
foreach (DecisionDefinition definition in matchingDefinitions)
{
DecisionDefinitionDto def = DecisionDefinitionDto.fromDecisionDefinition(definition);
definitions.Add(def);
}
return(definitions);
}
//Code inspired by Rasmus Faber's solution in this post: http://stackoverflow.com/questions/781205/getting-a-url-with-an-url-encoded-slash
public void Purify(Uri uri)
{
if (!uri.IsAbsoluteUri)
{
return;
}
string paq = uri.PathAndQuery; // need to access PathAndQuery
var abs = uri.AbsoluteUri; //need to access this as well the MoreInfo prop is initialized.
ulong flags = (ulong)flagsField.GetValue(uri);
flags &= ~((ulong)0x30); // Flags.PathNotCanonical|Flags.QueryNotCanonical
flagsField.SetValue(uri, flags);
object info = infoField.GetValue(uri);
var source = (string)stringField.GetValue(uri);
infoStringField.SetValue(info, source);
object moreInfo = moreInfoField.GetValue(info);
moreInfoAbsoluteUri.SetValue(moreInfo, source);
var uriInfo = new UriInfo(uri, source);
moreInfoPath.SetValue(moreInfo, uriInfo.Path);
moreInfoQuery.SetValue(moreInfo, uriInfo.Query);
}
public virtual ResourceOptionsDto availableOperations(UriInfo context)
{
UriBuilder baseUriBuilder = context.BaseUriBuilder.path(relativeRootResourcePath).path(org.camunda.bpm.engine.rest.AuthorizationRestService_Fields.PATH);
ResourceOptionsDto resourceOptionsDto = new ResourceOptionsDto();
// GET /
URI baseUri = baseUriBuilder.build();
resourceOptionsDto.addReflexiveLink(baseUri, HttpMethod.GET, "list");
// GET /count
URI countUri = baseUriBuilder.clone().path("/count").build();
resourceOptionsDto.addReflexiveLink(countUri, HttpMethod.GET, "count");
// POST /create
if (isAuthorized(CREATE))
{
URI createUri = baseUriBuilder.clone().path("/create").build();
resourceOptionsDto.addReflexiveLink(createUri, HttpMethod.POST, "create");
}
return(resourceOptionsDto);
}
public virtual IList <BatchStatisticsDto> getStatistics(UriInfo uriInfo, int?firstResult, int?maxResults)
{
BatchStatisticsQueryDto queryDto = new BatchStatisticsQueryDto(ObjectMapper, uriInfo.QueryParameters);
BatchStatisticsQuery query = queryDto.toQuery(ProcessEngine);
IList <BatchStatistics> batchStatisticsList;
if (firstResult != null || maxResults != null)
{
batchStatisticsList = executePaginatedStatisticsQuery(query, firstResult, maxResults);
}
else
{
batchStatisticsList = query.list();
}
IList <BatchStatisticsDto> statisticsResults = new List <BatchStatisticsDto>();
foreach (BatchStatistics batchStatistics in batchStatisticsList)
{
statisticsResults.Add(BatchStatisticsDto.fromBatchStatistics(batchStatistics));
}
return(statisticsResults);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private javax.ws.rs.core.Response batchProcessAndStream(final javax.ws.rs.core.UriInfo uriInfo, final javax.ws.rs.core.HttpHeaders httpHeaders, final javax.servlet.http.HttpServletRequest req, final java.io.InputStream body)
private Response BatchProcessAndStream(UriInfo uriInfo, HttpHeaders httpHeaders, HttpServletRequest req, Stream body)
{
try
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final javax.ws.rs.core.StreamingOutput stream = output ->
StreamingOutput stream = _output =>
{
try
{
ServletOutputStream servletOutputStream = new ServletOutputStreamAnonymousInnerClass(this);
(new StreamingBatchOperations(_webServer)).readAndExecuteOperations(uriInfo, httpHeaders, req, body, servletOutputStream);
_representationWriteHandler.onRepresentationWritten();
}
catch (Exception e)
{
_logger.warn("Error executing batch request ", e);
}
finally
{
_representationWriteHandler.onRepresentationFinal();
}
};
return(Response.ok(stream).type(HttpHeaderUtils.mediaTypeWithCharsetUtf8(MediaType.APPLICATION_JSON_TYPE)).build());
}
catch (Exception e)
{
return(_output.serverError(e));
}
}
public virtual ResourceOptionsDto availableOperations(UriInfo context)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.IdentityService identityService = getIdentityService();
IdentityService identityService = IdentityService;
UriBuilder baseUriBuilder = context.BaseUriBuilder.path(relativeRootResourcePath).path(org.camunda.bpm.engine.rest.GroupRestService_Fields.PATH);
ResourceOptionsDto resourceOptionsDto = new ResourceOptionsDto();
// GET /
URI baseUri = baseUriBuilder.build();
resourceOptionsDto.addReflexiveLink(baseUri, HttpMethod.GET, "list");
// GET /count
URI countUri = baseUriBuilder.clone().path("/count").build();
resourceOptionsDto.addReflexiveLink(countUri, HttpMethod.GET, "count");
// POST /create
if (!identityService.ReadOnly && isAuthorized(CREATE))
{
URI createUri = baseUriBuilder.clone().path("/create").build();
resourceOptionsDto.addReflexiveLink(createUri, HttpMethod.POST, "create");
}
return(resourceOptionsDto);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: public TransactionalService(@Context TransactionFacade facade, @Context UriInfo uriInfo, @Context UsageData usage, @Context Log log)
public TransactionalService(TransactionFacade facade, UriInfo uriInfo, UsageData usage, Log log)
{
this._facade = facade;
this._usage = usage;
this._uriScheme = new TransactionUriBuilder(uriInfo);
this._log = log;
}
protected internal virtual string getReportResultAsCsv(UriInfo uriInfo)
{
IList <ReportResult> reports = queryHistoricProcessInstanceReport(uriInfo);
MultivaluedMap <string, string> queryParameters = uriInfo.QueryParameters;
string reportType = queryParameters.getFirst("reportType");
return(ReportResultToCsvConverter.convertReportResult(reports, reportType));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void readAndExecuteOperations(javax.ws.rs.core.UriInfo uriInfo, javax.ws.rs.core.HttpHeaders httpHeaders, javax.servlet.http.HttpServletRequest req, java.io.InputStream body, javax.servlet.ServletOutputStream output) throws java.io.IOException, javax.servlet.ServletException
public virtual void ReadAndExecuteOperations(UriInfo uriInfo, HttpHeaders httpHeaders, HttpServletRequest req, Stream body, ServletOutputStream output)
{
_results = new StreamingBatchOperationResults(JsonFactory.createJsonGenerator(output), output);
IDictionary <int, string> locations = _results.Locations;
ParseAndPerform(uriInfo, httpHeaders, req, body, locations);
_results.close();
}
public void Constructor_Uri()
{
String uri = "mysql://*****:*****@localhost:1527/big_db";
UriInfo result = new UriInfo(uri);
AssertUriInfoEquals(result, "localhost", 1527, "joe", "joes_password", "big_db", null);
Assert.Equal(uri, result.UriString);
}
public void Constructor_WithExplicitParameters()
{
string uri = "mysql://*****:*****@localhost:1527/big_db";
UriInfo result = new UriInfo("mysql", "localhost", 1527, "joe", "joes_password", "big_db");
AssertUriInfoEquals(result, "localhost", 1527, "joe", "joes_password", "big_db", null);
Assert.Equal(uri, result.UriString);
}
public void Constructor_NoUsernamePassword()
{
string uri = "mysql://localhost:1527/big_db";
UriInfo result = new UriInfo(uri);
AssertUriInfoEquals(result, "localhost", 1527, null, null, "big_db", null);
Assert.Equal(uri, result.UriString);
}
public void Constructor_WithQuery()
{
string uri = "mysql://*****:*****@localhost:1527/big_db?p1=v1&p2=v2";
UriInfo result = new UriInfo(uri);
AssertUriInfoEquals(result, "localhost", 1527, "joe", "joes_password", "big_db", "p1=v1&p2=v2");
Assert.Equal(uri, result.UriString);
}
public void Constructor_Uri_Unsupported_Format_Returns_Expected()
{
string uri = "mongodb://*****:*****@10.66.105.42:28000,10.66.105.45:28000,10.66.105.41:28000/data?authSource=admin";
UriInfo result = new UriInfo(uri);
AssertUriInfoEquals(result, null, 0, null, null, null, null);
Assert.Equal(uri, result.UriString);
}
public virtual MetricsResultDto sum(UriInfo uriInfo)
{
MetricsQuery query = processEngine.ManagementService.createMetricsQuery().name(metricsName);
applyQueryParams(query, uriInfo);
return(new MetricsResultDto(query.sum()));
}
private void AssertUriInfoEquals(UriInfo result, string host, int port, string username, string password, string path, string query)
{
Assert.Equal(host, result.Host);
Assert.Equal(port, result.Port);
Assert.Equal(username, result.UserName);
Assert.Equal(password, result.Password);
Assert.Equal(path, result.Path);
Assert.Equal(query, result.Query);
}
public virtual CountResultDto getStatisticsCount(UriInfo uriInfo)
{
BatchStatisticsQueryDto queryDto = new BatchStatisticsQueryDto(ObjectMapper, uriInfo.QueryParameters);
BatchStatisticsQuery query = queryDto.toQuery(ProcessEngine);
long count = query.count();
return(new CountResultDto(count));
}
public virtual CountResultDto getTenantCount(UriInfo uriInfo)
{
TenantQueryDto queryDto = new TenantQueryDto(ObjectMapper, uriInfo.QueryParameters);
TenantQuery query = queryDto.toQuery(ProcessEngine);
long count = query.count();
return(new CountResultDto(count));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @POST @Consumes({javax.ws.rs.core.MediaType.APPLICATION_JSON}) @Produces({javax.ws.rs.core.MediaType.APPLICATION_JSON}) public javax.ws.rs.core.Response executeStatementsInNewTransaction(final java.io.InputStream input, @Context final javax.ws.rs.core.UriInfo uriInfo, @Context final javax.servlet.http.HttpServletRequest request)
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public virtual Response ExecuteStatementsInNewTransaction(Stream input, UriInfo uriInfo, HttpServletRequest request)
{
_usage.get(features).flag(http_tx_endpoint);
LoginContext loginContext = AuthorizedRequestWrapper.getLoginContextFromHttpServletRequest(request);
long customTransactionTimeout = HttpHeaderUtils.getTransactionTimeout(request, _log);
TransactionHandle transactionHandle = _facade.newTransactionHandle(_uriScheme, false, loginContext, customTransactionTimeout);
return(CreatedResponse(transactionHandle, executeStatements(input, transactionHandle, uriInfo.BaseUri, request)));
}
public virtual CountResultDto getHistoricBatchesCount(UriInfo uriInfo)
{
HistoricBatchQueryDto queryDto = new HistoricBatchQueryDto(objectMapper, uriInfo.QueryParameters);
HistoricBatchQuery query = queryDto.toQuery(processEngine);
long count = query.count();
return(new CountResultDto(count));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @POST public javax.ws.rs.core.Response performBatchOperations(@Context UriInfo uriInfo, @Context HttpHeaders httpHeaders, @Context HttpServletRequest req, java.io.InputStream body)
public virtual Response PerformBatchOperations(UriInfo uriInfo, HttpHeaders httpHeaders, HttpServletRequest req, Stream body)
{
_usage.get(features).flag(http_batch_endpoint);
if (IsStreaming(httpHeaders))
{
return(BatchProcessAndStream(uriInfo, httpHeaders, req, body));
}
return(BatchProcess(uriInfo, httpHeaders, req, body));
}
//
// Uri(Uri , Uri )
// Note: a static Create() method should be used by users, not this .ctor
//
public Uri(Uri baseUri, Uri relativeUri)
{
if ((object)baseUri == null)
throw new ArgumentNullException(nameof(baseUri));
if (!baseUri.IsAbsoluteUri)
throw new ArgumentOutOfRangeException(nameof(baseUri));
CreateThisFromUri(relativeUri);
string newUriString = null;
UriFormatException e;
bool dontEscape;
if (baseUri.Syntax.IsSimple)
{
dontEscape = InFact(Flags.UserEscaped);
relativeUri = ResolveHelper(baseUri, this, ref newUriString, ref dontEscape, out e);
if (e != null)
throw e;
if (relativeUri != null)
{
if ((object)relativeUri != (object)this)
CreateThisFromUri(relativeUri);
return;
}
}
else
{
dontEscape = false;
newUriString = baseUri.Syntax.InternalResolve(baseUri, this, out e);
if (e != null)
throw e;
}
_flags = Flags.Zero;
_info = null;
_syntax = null;
CreateThis(newUriString, dontEscape, UriKind.Absolute);
}
private unsafe void CreateUriInfo(Flags cF)
{
ushort length;
UriInfo info = new UriInfo();
info.Offset.End = (ushort) this.m_String.Length;
if (this.UserDrivenParsing)
{
goto Label_041E;
}
bool flag = false;
if ((cF & (Flags.HostNotParsed | Flags.ImplicitFile)) != Flags.HostNotParsed)
{
length = 0;
while (IsLWS(this.m_String[length]))
{
length = (ushort) (length + 1);
info.Offset.Scheme = (ushort) (info.Offset.Scheme + 1);
}
if (StaticInFact(cF, Flags.HostNotParsed | Flags.UncPath))
{
for (length = (ushort) (length + 2); (length < ((ushort) (cF & (Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed)))) && ((this.m_String[length] == '/') || (this.m_String[length] == '\\')); length = (ushort) (length + 1))
{
}
}
goto Label_016D;
}
length = (ushort) this.m_Syntax.SchemeName.Length;
Label_00E2:
length = (ushort) (length + 1);
if (this.m_String[length] != ':')
{
info.Offset.Scheme = (ushort) (info.Offset.Scheme + 1);
goto Label_00E2;
}
if ((cF & Flags.AuthorityFound) != Flags.HostNotParsed)
{
if ((this.m_String[length] == '\\') || (this.m_String[length + 1] == '\\'))
{
flag = true;
}
length = (ushort) (length + 2);
if ((cF & (Flags.DosPath | Flags.UncPath)) != Flags.HostNotParsed)
{
while ((length < ((ushort) (cF & (Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed)))) && ((this.m_String[length] == '/') || (this.m_String[length] == '\\')))
{
flag = true;
length = (ushort) (length + 1);
}
}
}
Label_016D:
if (this.m_Syntax.DefaultPort != -1)
{
info.Offset.PortValue = (ushort) this.m_Syntax.DefaultPort;
}
if (((cF & (Flags.BasicHostType | Flags.IPv4HostType)) == (Flags.BasicHostType | Flags.IPv4HostType)) || StaticInFact(cF, Flags.DosPath))
{
info.Offset.User = (ushort) (cF & (Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed));
info.Offset.Host = info.Offset.User;
info.Offset.Path = info.Offset.User;
cF &= ~(Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed);
if (flag)
{
cF |= Flags.HostNotParsed | Flags.SchemeNotCanonical;
}
}
else
{
info.Offset.User = length;
if (this.HostType == Flags.BasicHostType)
{
info.Offset.Host = length;
info.Offset.Path = (ushort) (cF & (Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed));
cF &= ~(Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed);
}
else
{
if ((cF & Flags.HasUserInfo) != Flags.HostNotParsed)
{
while (this.m_String[length] != '@')
{
length = (ushort) (length + 1);
}
length = (ushort) (length + 1);
info.Offset.Host = length;
}
else
{
info.Offset.Host = length;
}
length = (ushort) (cF & (Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed));
cF &= ~(Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed);
if (flag)
{
cF |= Flags.HostNotParsed | Flags.SchemeNotCanonical;
}
info.Offset.Path = length;
bool flag2 = false;
bool flag3 = (cF & (Flags.HostNotParsed | Flags.UseOrigUncdStrOffset)) != Flags.HostNotParsed;
cF &= ~(Flags.HostNotParsed | Flags.UseOrigUncdStrOffset);
if (flag3)
{
info.Offset.End = (ushort) this.m_originalUnicodeString.Length;
}
if (length < info.Offset.End)
{
fixed (char* str = (flag3 ? ((char*) this.m_originalUnicodeString) : ((char*) this.m_String)))
{
char* chPtr = str;
if (chPtr[length] != ':')
{
goto Label_041E;
}
int num2 = 0;
if ((length = (ushort) (length + 1)) < info.Offset.End)
{
num2 = chPtr[length] - '0';
switch (num2)
{
case 0xffff:
case 15:
case 0xfff3:
goto Label_03D8;
}
flag2 = true;
if (num2 == 0)
{
cF |= Flags.E_PortNotCanonical | Flags.PortNotCanonical;
}
length = (ushort) (length + 1);
while (length < info.Offset.End)
{
ushort num3 = chPtr[length] - '0';
switch (num3)
{
case 0xffff:
case 15:
case 0xfff3:
goto Label_03D8;
}
num2 = (num2 * 10) + num3;
length = (ushort) (length + 1);
}
}
Label_03D8:
if (flag2 && (info.Offset.PortValue != ((ushort) num2)))
{
info.Offset.PortValue = (ushort) num2;
cF |= Flags.HostNotParsed | Flags.NotDefaultPort;
}
else
{
cF |= Flags.E_PortNotCanonical | Flags.PortNotCanonical;
}
info.Offset.Path = length;
}
}
}
}
Label_041E:
cF |= Flags.HostNotParsed | Flags.MinimalUriInfoSet;
info.DnsSafeHost = this.m_DnsSafeHost;
lock (this.m_String)
{
if ((this.m_Flags & (Flags.HostNotParsed | Flags.MinimalUriInfoSet)) == Flags.HostNotParsed)
{
this.m_Info = info;
this.m_Flags = (this.m_Flags & ~(Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.ShouldBeCompressed)) | cF;
}
}
}
private void CreateUri(Uri baseUri, string relativeUri, bool dontEscape)
{
UriFormatException exception;
this.CreateThis(relativeUri, dontEscape, UriKind.RelativeOrAbsolute);
if (baseUri.Syntax.IsSimple)
{
Uri otherUri = ResolveHelper(baseUri, this, ref relativeUri, ref dontEscape, out exception);
if (exception != null)
{
throw exception;
}
if (otherUri != null)
{
if (otherUri != this)
{
this.CreateThisFromUri(otherUri);
}
return;
}
}
else
{
dontEscape = false;
relativeUri = baseUri.Syntax.InternalResolve(baseUri, this, out exception);
if (exception != null)
{
throw exception;
}
}
this.m_Flags = Flags.HostNotParsed;
this.m_Info = null;
this.m_Syntax = null;
this.CreateThis(relativeUri, dontEscape, UriKind.Absolute);
}
private void CreateThisFromUri(Uri otherUri)
{
this.m_Info = null;
this.m_Flags = otherUri.m_Flags;
if (this.InFact(Flags.HostNotParsed | Flags.MinimalUriInfoSet))
{
this.m_Flags &= ~(Flags.AllUriInfoSet | Flags.BackslashInPath | Flags.CannotDisplayCanonical | Flags.E_CannotDisplayCanonical | Flags.FirstSlashAbsent | Flags.MinimalUriInfoSet | Flags.ShouldBeCompressed);
int path = otherUri.m_Info.Offset.Path;
if (this.InFact(Flags.HostNotParsed | Flags.NotDefaultPort))
{
while ((otherUri.m_String[path] != ':') && (path > otherUri.m_Info.Offset.Host))
{
path--;
}
if (otherUri.m_String[path] != ':')
{
path = otherUri.m_Info.Offset.Path;
}
}
this.m_Flags |= (Flags) path;
}
this.m_Syntax = otherUri.m_Syntax;
this.m_String = otherUri.m_String;
this.m_iriParsing = otherUri.m_iriParsing;
if (otherUri.OriginalStringSwitched)
{
this.m_originalUnicodeString = otherUri.m_originalUnicodeString;
}
if (otherUri.AllowIdn && (otherUri.InFact(Flags.HostNotParsed | Flags.IdnHost) || otherUri.InFact(Flags.HostNotParsed | Flags.UnicodeHost)))
{
this.m_DnsSafeHost = otherUri.m_DnsSafeHost;
}
}
public Uri(Uri baseUri, Uri relativeUri)
{
UriFormatException exception;
bool flag;
if (baseUri == null)
{
throw new ArgumentNullException("baseUri");
}
if (!baseUri.IsAbsoluteUri)
{
throw new ArgumentOutOfRangeException("baseUri");
}
this.CreateThisFromUri(relativeUri);
string newUriString = null;
if (baseUri.Syntax.IsSimple)
{
flag = this.InFact(Flags.HostNotParsed | Flags.UserEscaped);
relativeUri = ResolveHelper(baseUri, this, ref newUriString, ref flag, out exception);
if (exception != null)
{
throw exception;
}
if (relativeUri != null)
{
if (relativeUri != this)
{
this.CreateThisFromUri(relativeUri);
}
return;
}
}
else
{
flag = false;
newUriString = baseUri.Syntax.InternalResolve(baseUri, this, out exception);
if (exception != null)
{
throw exception;
}
}
this.m_Flags = Flags.HostNotParsed;
this.m_Info = null;
this.m_Syntax = null;
this.CreateThis(newUriString, flag, UriKind.Absolute);
}
private void CreateUri(Uri baseUri, string relativeUri, bool dontEscape)
{
// Parse relativeUri and populate Uri internal data.
CreateThis(relativeUri, dontEscape, UriKind.RelativeOrAbsolute);
UriFormatException e;
if (baseUri.Syntax.IsSimple)
{
// Resolve Uris if possible OR get merged Uri String to re-parse below
Uri uriResult = ResolveHelper(baseUri, this, ref relativeUri, ref dontEscape, out e);
if (e != null)
throw e;
// If resolved into a Uri then we build from that Uri
if (uriResult != null)
{
if ((object)uriResult != (object)this)
CreateThisFromUri(uriResult);
return;
}
}
else
{
dontEscape = false;
relativeUri = baseUri.Syntax.InternalResolve(baseUri, this, out e);
if (e != null)
throw e;
}
_flags = Flags.Zero;
_info = null;
_syntax = null;
// If not resolved, we reparse modified Uri string and populate Uri internal data.
CreateThis(relativeUri, dontEscape, UriKind.Absolute);
}
//
//
// The method is called when we have to access m_Info members.
// This will create the m_Info based on the copied parser context.
// If multi-threading, this method may do duplicated yet harmless work.
//
private unsafe void CreateUriInfo(Flags cF)
{
UriInfo info = new UriInfo();
// This will be revisited in ParseRemaining but for now just have it at least m_String.Length
info.Offset.End = (ushort)_string.Length;
if (UserDrivenParsing)
goto Done;
ushort idx;
bool notCanonicalScheme = false;
// The m_String may have leading spaces, figure that out
// plus it will set idx value for next steps
if ((cF & Flags.ImplicitFile) != 0)
{
idx = (ushort)0;
while (UriHelper.IsLWS(_string[idx]))
{
++idx;
++info.Offset.Scheme;
}
if (StaticInFact(cF, Flags.UncPath))
{
// For implicit file AND Unc only
idx += 2;
//skip any other slashes (compatibility with V1.0 parser)
while (idx < (ushort)(cF & Flags.IndexMask) && (_string[idx] == '/' || _string[idx] == '\\'))
{
++idx;
}
}
}
else
{
// This is NOT an ImplicitFile uri
idx = (ushort)_syntax.SchemeName.Length;
while (_string[idx++] != ':')
{
++info.Offset.Scheme;
}
if ((cF & Flags.AuthorityFound) != 0)
{
if (_string[idx] == '\\' || _string[idx + 1] == '\\')
notCanonicalScheme = true;
idx += 2;
if ((cF & (Flags.UncPath | Flags.DosPath)) != 0)
{
// Skip slashes if it was allowed during ctor time
// NB: Today this is only allowed if a Unc or DosPath was found after the scheme
while (idx < (ushort)(cF & Flags.IndexMask) && (_string[idx] == '/' || _string[idx] == '\\'))
{
notCanonicalScheme = true;
++idx;
}
}
}
}
// Some schemes (mailto) do not have Authority-based syntax, still they do have a port
if (_syntax.DefaultPort != UriParser.NoDefaultPort)
info.Offset.PortValue = (ushort)_syntax.DefaultPort;
//Here we set the indexes for already parsed components
if ((cF & Flags.HostTypeMask) == Flags.UnknownHostType
|| StaticInFact(cF, Flags.DosPath)
)
{
//there is no Authority component defined
info.Offset.User = (ushort)(cF & Flags.IndexMask);
info.Offset.Host = info.Offset.User;
info.Offset.Path = info.Offset.User;
cF &= ~Flags.IndexMask;
if (notCanonicalScheme)
{
cF |= Flags.SchemeNotCanonical;
}
goto Done;
}
info.Offset.User = idx;
//Basic Host Type does not have userinfo and port
if (HostType == Flags.BasicHostType)
{
info.Offset.Host = idx;
info.Offset.Path = (ushort)(cF & Flags.IndexMask);
cF &= ~Flags.IndexMask;
goto Done;
}
if ((cF & Flags.HasUserInfo) != 0)
{
// we previously found a userinfo, get it again
while (_string[idx] != '@')
{
++idx;
}
++idx;
info.Offset.Host = idx;
}
else
{
info.Offset.Host = idx;
}
//Now reload the end of the parsed host
idx = (ushort)(cF & Flags.IndexMask);
//From now on we do not need IndexMask bits, and reuse the space for X_NotCanonical flags
//clear them now
cF &= ~Flags.IndexMask;
// If this is not canonical, don't count on user input to be good
if (notCanonicalScheme)
{
cF |= Flags.SchemeNotCanonical;
}
//Guessing this is a path start
info.Offset.Path = idx;
// parse Port if any. The new spec allows a port after ':' to be empty (assuming default?)
bool notEmpty = false;
// Note we already checked on general port syntax in ParseMinimal()
// If iri parsing is on with unicode chars then the end of parsed host
// points to m_orig string and not m_String
bool UseOrigUnicodeStrOffset = ((cF & Flags.UseOrigUncdStrOffset) != 0);
// This should happen only once. Reset it
cF &= ~Flags.UseOrigUncdStrOffset;
if (UseOrigUnicodeStrOffset)
info.Offset.End = (ushort)_originalUnicodeString.Length;
if (idx < info.Offset.End)
{
fixed (char* userString = UseOrigUnicodeStrOffset ? _originalUnicodeString : _string)
{
if (userString[idx] == ':')
{
int port = 0;
//Check on some non-canonical cases http://host:0324/, http://host:03, http://host:0, etc
if (++idx < info.Offset.End)
{
port = (ushort)(userString[idx] - '0');
if (!(port == unchecked((ushort)('/' - '0')) || port == (ushort)('?' - '0') ||
port == unchecked((ushort)('#' - '0'))))
{
notEmpty = true;
if (port == 0)
{
cF |= (Flags.PortNotCanonical | Flags.E_PortNotCanonical);
}
for (++idx; idx < info.Offset.End; ++idx)
{
ushort val = (ushort)((ushort)userString[idx] - (ushort)'0');
if (val == unchecked((ushort)('/' - '0')) || val == (ushort)('?' - '0') ||
val == unchecked((ushort)('#' - '0')))
{
break;
}
port = (port * 10 + val);
}
}
}
if (notEmpty && info.Offset.PortValue != (ushort)port)
{
info.Offset.PortValue = (ushort)port;
cF |= Flags.NotDefaultPort;
}
else
{
//This will tell that we do have a ':' but the port value does
//not follow to canonical rules
cF |= (Flags.PortNotCanonical | Flags.E_PortNotCanonical);
}
info.Offset.Path = (ushort)idx;
}
}
}
Done:
cF |= Flags.MinimalUriInfoSet;
info.DnsSafeHost = _dnsSafeHost;
lock (_string)
{
if ((_flags & Flags.MinimalUriInfoSet) == 0)
{
_info = info;
_flags = (_flags & ~Flags.IndexMask) | cF;
}
}
}
