//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <R> R query(java.time.temporal.TemporalQuery<R> query) public override R query <R>(TemporalQuery <R> query) { if (query == TemporalQueries.ZoneId()) { return((R)Zone); } else if (query == TemporalQueries.Chronology()) { return((R)Chrono); } else if (query == TemporalQueries.LocalDate()) { return((R)(Date != java.time.temporal.TemporalAccessor_Fields.Null ? LocalDate.From(Date) : java.time.temporal.TemporalAccessor_Fields.Null)); } else if (query == TemporalQueries.LocalTime()) { return((R)Time); } else if (query == TemporalQueries.Zone() || query == TemporalQueries.Offset()) { return(query.QueryFrom(this)); } else if (query == TemporalQueries.Precision()) { return(java.time.temporal.TemporalAccessor_Fields.Null); // not a complete date/time } // inline TemporalAccessor.super.query(query) as an optimization // non-JDK classes are not permitted to make this optimization return(query.QueryFrom(this)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <R> R query(java.time.temporal.TemporalQuery<R> query) public override R query <R>(TemporalQuery <R> query) { if (query == TemporalQueries.ZoneId()) { return((R)ZoneId.this); } return(TemporalAccessor.this.query(query)); }
//----------------------------------------------------------------------- /// <summary> /// Queries this offset using the specified query. /// <para> /// This queries this offset using the specified query strategy object. /// The {@code TemporalQuery} object defines the logic to be used to /// obtain the result. Read the documentation of the query to understand /// what the result of this method will be. /// </para> /// <para> /// The result of this method is obtained by invoking the /// <seealso cref="TemporalQuery#queryFrom(TemporalAccessor)"/> method on the /// specified query passing {@code this} as the argument. /// /// </para> /// </summary> /// @param <R> the type of the result </param> /// <param name="query"> the query to invoke, not null </param> /// <returns> the query result, null may be returned (defined by the query) </returns> /// <exception cref="DateTimeException"> if unable to query (defined by the query) </exception> /// <exception cref="ArithmeticException"> if numeric overflow occurs (defined by the query) </exception> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <R> R query(java.time.temporal.TemporalQuery<R> query) public override R query <R>(TemporalQuery <R> query) { if (query == TemporalQueries.Offset() || query == TemporalQueries.Zone()) { return((R)this); } return(TemporalAccessor.this.query(query)); }
//----------------------------------------------------------------------- /// <summary> /// Queries this month-day using the specified query. /// <para> /// This queries this month-day using the specified query strategy object. /// The {@code TemporalQuery} object defines the logic to be used to /// obtain the result. Read the documentation of the query to understand /// what the result of this method will be. /// </para> /// <para> /// The result of this method is obtained by invoking the /// <seealso cref="TemporalQuery#queryFrom(TemporalAccessor)"/> method on the /// specified query passing {@code this} as the argument. /// /// </para> /// </summary> /// @param <R> the type of the result </param> /// <param name="query"> the query to invoke, not null </param> /// <returns> the query result, null may be returned (defined by the query) </returns> /// <exception cref="DateTimeException"> if unable to query (defined by the query) </exception> /// <exception cref="ArithmeticException"> if numeric overflow occurs (defined by the query) </exception> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <R> R query(java.time.temporal.TemporalQuery<R> query) public override R query <R>(TemporalQuery <R> query) { if (query == TemporalQueries.Chronology()) { return((R)IsoChronology.INSTANCE); } return(TemporalAccessor.this.query(query)); }
/// <summary> /// Validates that the temporal has the correct chronology. /// </summary> private void ValidateChrono(TemporalAccessor temporal) { Objects.RequireNonNull(temporal, "temporal"); Chronology temporalChrono = temporal.query(TemporalQueries.Chronology()); if (temporalChrono != null && Chrono.Equals(temporalChrono) == ChronoPeriod_Fields.False) { throw new DateTimeException("Chronology mismatch, expected: " + Chrono.Id + ", actual: " + temporalChrono.Id); } }
//----------------------------------------------------------------------- /// <summary> /// Obtains an instance of {@code ZoneId} from a temporal object. /// <para> /// This obtains a zone based on the specified temporal. /// A {@code TemporalAccessor} represents an arbitrary set of date and time information, /// which this factory converts to an instance of {@code ZoneId}. /// </para> /// <para> /// A {@code TemporalAccessor} represents some form of date and time information. /// This factory converts the arbitrary temporal object to an instance of {@code ZoneId}. /// </para> /// <para> /// The conversion will try to obtain the zone in a way that favours region-based /// zones over offset-based zones using <seealso cref="TemporalQueries#zone()"/>. /// </para> /// <para> /// This method matches the signature of the functional interface <seealso cref="TemporalQuery"/> /// allowing it to be used as a query via method reference, {@code ZoneId::from}. /// /// </para> /// </summary> /// <param name="temporal"> the temporal object to convert, not null </param> /// <returns> the zone ID, not null </returns> /// <exception cref="DateTimeException"> if unable to convert to a {@code ZoneId} </exception> public static ZoneId From(TemporalAccessor temporal) { ZoneId obj = temporal.query(TemporalQueries.Zone()); if (obj == null) { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new DateTimeException("Unable to obtain ZoneId from TemporalAccessor: " + temporal + " of type " + temporal.GetType().FullName); } return(obj); }
//----------------------------------------------------------------------- /// <summary> /// Obtains an instance of {@code ZoneOffset} from a temporal object. /// <para> /// This obtains an offset based on the specified temporal. /// A {@code TemporalAccessor} represents an arbitrary set of date and time information, /// which this factory converts to an instance of {@code ZoneOffset}. /// </para> /// <para> /// A {@code TemporalAccessor} represents some form of date and time information. /// This factory converts the arbitrary temporal object to an instance of {@code ZoneOffset}. /// </para> /// <para> /// The conversion uses the <seealso cref="TemporalQueries#offset()"/> query, which relies /// on extracting the <seealso cref="ChronoField#OFFSET_SECONDS OFFSET_SECONDS"/> field. /// </para> /// <para> /// This method matches the signature of the functional interface <seealso cref="TemporalQuery"/> /// allowing it to be used as a query via method reference, {@code ZoneOffset::from}. /// /// </para> /// </summary> /// <param name="temporal"> the temporal object to convert, not null </param> /// <returns> the zone-offset, not null </returns> /// <exception cref="DateTimeException"> if unable to convert to an {@code ZoneOffset} </exception> public static ZoneOffset From(TemporalAccessor temporal) { Objects.RequireNonNull(temporal, "temporal"); ZoneOffset offset = temporal.query(TemporalQueries.Offset()); if (offset == temporal.TemporalAccessor_Fields.Null) { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new DateTimeException("Unable to obtain ZoneOffset from TemporalAccessor: " + temporal + " of type " + temporal.GetType().FullName); } return(offset); }
internal static ZoneId ParseZoneName(string zoneName) { ZoneId parsedName; try { parsedName = _zoneNameParser.parse(zoneName.Replace(' ', '_')).query(TemporalQueries.zoneId()); } catch (DateTimeParseException e) { throw new TemporalParseException("Invalid value for TimeZone: " + e.Message, e.ParsedString, e.ErrorIndex, e); } return(parsedName); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public <R> R query(java.time.temporal.TemporalQuery<R> query) public override R query <R>(TemporalQuery <R> query) { if (query == TemporalQueries.Chronology()) { return((R)EffectiveChrono); } if (query == TemporalQueries.ZoneId()) { return((R)EffectiveZone); } if (query == TemporalQueries.Precision()) { return(Temporal.query(query)); } return(query.QueryFrom(this)); }
public static ZoneId ParseZoneOffsetOrZoneName(string zoneName) { Matcher matcher = OFFSET.matcher(zoneName); if (matcher.matches()) { return(parseOffset(matcher)); } try { return(_zoneNameParser.parse(zoneName.Replace(' ', '_')).query(TemporalQueries.zoneId())); } catch (DateTimeParseException e) { throw new TemporalParseException("Invalid value for TimeZone: " + e.Message, e.ParsedString, e.ErrorIndex, e); } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not allowed in .NET: //ORIGINAL LINE: private static java.time.temporal.TemporalAccessor adjust(final java.time.temporal.TemporalAccessor temporal, DateTimeFormatter formatter) private static TemporalAccessor Adjust(TemporalAccessor temporal, DateTimeFormatter formatter) { // normal case first (early return is an optimization) Chronology overrideChrono = formatter.Chronology; ZoneId overrideZone = formatter.Zone; if (overrideChrono == null && overrideZone == null) { return(temporal); } // ensure minimal change (early return is an optimization) Chronology temporalChrono = temporal.query(TemporalQueries.Chronology()); ZoneId temporalZone = temporal.query(TemporalQueries.ZoneId()); if (Objects.Equals(overrideChrono, temporalChrono)) { overrideChrono = null; } if (Objects.Equals(overrideZone, temporalZone)) { overrideZone = null; } if (overrideChrono == null && overrideZone == null) { return(temporal); } // make adjustment //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.chrono.Chronology effectiveChrono = (overrideChrono != null ? overrideChrono : temporalChrono); Chronology effectiveChrono = (overrideChrono != null ? overrideChrono : temporalChrono); if (overrideZone != null) { // if have zone and instant, calculation is simple, defaulting chrono if necessary if (temporal.IsSupported(INSTANT_SECONDS)) { Chronology chrono = (effectiveChrono != null ? effectiveChrono : IsoChronology.INSTANCE); return(chrono.zonedDateTime(Instant.From(temporal), overrideZone)); } // block changing zone on OffsetTime, and similar problem cases if (overrideZone.Normalized() is ZoneOffset && temporal.IsSupported(OFFSET_SECONDS) && temporal.get(OFFSET_SECONDS) != overrideZone.Rules.GetOffset(Instant.EPOCH).TotalSeconds) { throw new DateTimeException("Unable to apply override zone '" + overrideZone + "' because the temporal object being formatted has a different offset but" + " does not represent an instant: " + temporal); } } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.ZoneId effectiveZone = (overrideZone != null ? overrideZone : temporalZone); ZoneId effectiveZone = (overrideZone != null ? overrideZone : temporalZone); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.chrono.ChronoLocalDate effectiveDate; ChronoLocalDate effectiveDate; if (overrideChrono != null) { if (temporal.IsSupported(EPOCH_DAY)) { effectiveDate = effectiveChrono.Date(temporal); } else { // check for date fields other than epoch-day, ignoring case of converting null to ISO if (!(overrideChrono == IsoChronology.INSTANCE && temporalChrono == null)) { foreach (ChronoField f in ChronoField.values()) { if (f.DateBased && temporal.IsSupported(f)) { throw new DateTimeException("Unable to apply override chronology '" + overrideChrono + "' because the temporal object being formatted contains date fields but" + " does not represent a whole date: " + temporal); } } } effectiveDate = null; } } else { effectiveDate = null; } // combine available data // this is a non-standard temporal that is almost a pure delegate // this better handles map-like underlying temporal instances return(new TemporalAccessorAnonymousInnerClassHelper(temporal, effectiveChrono, effectiveZone, effectiveDate)); }
private static void BuildUpExpectedData(IList <InputEntity> nodeData, IList <InputEntity> relationshipData, IDictionary <string, InputEntity> expectedNodes, IDictionary <string, string[]> expectedNodeNames, IDictionary <string, IDictionary <string, System.Action <object> > > expectedNodePropertyVerifiers, IDictionary <string, IDictionary <string, IDictionary <string, AtomicInteger> > > expectedRelationships, IDictionary <string, AtomicLong> nodeCounts, IDictionary <string, IDictionary <string, IDictionary <string, AtomicLong> > > relationshipCounts) { foreach (InputEntity node in nodeData) { expectedNodes[( string )node.Id()] = node; expectedNodeNames[NameOf(node)] = node.Labels(); // Build default verifiers for all the properties that compares the property value using equals assertTrue(!node.HasIntPropertyKeyIds); IDictionary <string, System.Action <object> > propertyVerifiers = new SortedDictionary <string, System.Action <object> >(); for (int i = 0; i < node.PropertyCount(); i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Object expectedValue = node.propertyValue(i); object expectedValue = node.PropertyValue(i); System.Action verify; if (expectedValue is TemporalAmount) { // Since there is no straightforward comparison for TemporalAmount we add it to a reference // point in time and compare the result verify = actualValue => { DateTime referenceTemporal = new DateTime(0, 1, 1, 0, 0); DateTime expected = referenceTemporal.plus(( TemporalAmount )expectedValue); DateTime actual = referenceTemporal.plus(( TemporalAmount )actualValue); assertEquals(expected, actual); }; } else if (expectedValue is Temporal) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.LocalDate expectedDate = ((java.time.temporal.Temporal) expectedValue).query(java.time.temporal.TemporalQueries.localDate()); LocalDate expectedDate = (( Temporal )expectedValue).query(TemporalQueries.localDate()); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.LocalTime expectedTime = ((java.time.temporal.Temporal) expectedValue).query(java.time.temporal.TemporalQueries.localTime()); LocalTime expectedTime = (( Temporal )expectedValue).query(TemporalQueries.localTime()); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.time.ZoneId expectedZoneId = ((java.time.temporal.Temporal) expectedValue).query(java.time.temporal.TemporalQueries.zone()); ZoneId expectedZoneId = (( Temporal )expectedValue).query(TemporalQueries.zone()); verify = actualValue => { LocalDate actualDate = (( Temporal )actualValue).query(TemporalQueries.localDate()); LocalTime actualTime = (( Temporal )actualValue).query(TemporalQueries.localTime()); ZoneId actualZoneId = (( Temporal )actualValue).query(TemporalQueries.zone()); assertEquals(expectedDate, actualDate); assertEquals(expectedTime, actualTime); if (expectedZoneId == null) { if (actualZoneId != null) { // If the actual value is zoned it should have the default zone assertEquals(_testDefaultTimeZone.get(), actualZoneId); } } else { assertEquals(expectedZoneId, actualZoneId); } }; } else { verify = actualValue => assertEquals(expectedValue, actualValue); } propertyVerifiers[( string )node.PropertyKey(i)] = verify; } // Special verifier for pointA property System.Action verifyPointA = actualValue => { // The y-coordinate should match the node number PointValue v = ( PointValue )actualValue; double actualY = v.Coordinates.get(0).Coordinate.get(1); double expectedY = IndexOf(node); string message = actualValue.ToString() + " does not have y=" + expectedY; assertEquals(message, expectedY, actualY, 0.1); message = actualValue.ToString() + " does not have crs=wgs-84"; assertEquals(message, CoordinateReferenceSystem.WGS84.Name, v.CoordinateReferenceSystem.Name); }; propertyVerifiers["pointA"] = verifyPointA; // Special verifier for pointB property System.Action verifyPointB = actualValue => { // The y-coordinate should match the node number PointValue v = ( PointValue )actualValue; double actualY = v.Coordinates.get(0).Coordinate.get(1); double expectedY = IndexOf(node); string message = actualValue.ToString() + " does not have y=" + expectedY; assertEquals(message, expectedY, actualY, 0.1); message = actualValue.ToString() + " does not have crs=cartesian"; assertEquals(message, CoordinateReferenceSystem.Cartesian.Name, v.CoordinateReferenceSystem.Name); }; propertyVerifiers["pointB"] = verifyPointB; expectedNodePropertyVerifiers[NameOf(node)] = propertyVerifiers; CountNodeLabels(nodeCounts, node.Labels()); } foreach (InputEntity relationship in relationshipData) { // Expected relationship counts per node, type and direction InputEntity startNode = expectedNodes[relationship.StartId()]; InputEntity endNode = expectedNodes[relationship.EndId()]; { expectedRelationships[NameOf(startNode)][NameOf(endNode)][relationship.StringType].incrementAndGet(); } // Expected counts per start/end node label ids // Let's do what CountsState#addRelationship does, roughly relationshipCounts[null][null][null].incrementAndGet(); relationshipCounts[null][relationship.StringType][null].incrementAndGet(); foreach (string startNodeLabelName in asSet(startNode.Labels())) { IDictionary <string, IDictionary <string, AtomicLong> > startLabelCounts = relationshipCounts[startNodeLabelName]; startLabelCounts[null][null].incrementAndGet(); IDictionary <string, AtomicLong> typeCounts = startLabelCounts[relationship.StringType]; typeCounts[null].incrementAndGet(); if (COMPUTE_DOUBLE_SIDED_RELATIONSHIP_COUNTS) { foreach (string endNodeLabelName in asSet(endNode.Labels())) { startLabelCounts[null][endNodeLabelName].incrementAndGet(); typeCounts[endNodeLabelName].incrementAndGet(); } } } foreach (string endNodeLabelName in asSet(endNode.Labels())) { relationshipCounts[null][null][endNodeLabelName].incrementAndGet(); relationshipCounts[null][relationship.StringType][endNodeLabelName].incrementAndGet(); } } }