|
|
The Data Assimilation Research Testbed (DART) is a public-domain, community facility for doing research on and applying ensemble data assimilation techniques over a variety of models and observation types. It includes many example models and support for common observation types and for different filter types. It also includes material for teaching and learning the basic principles of data assimilation.
DART strives to implement general solutions which work over a range of models and observation types, and to develop theory-based algorithms that solve the many real problems encountered when doing ensemble data assimilation. The algorithms in DART are tested on both simple one-dimensional models (e.g. the Lorenz series of models) as well as full-up 3D NWP (Numerical Weather Prediction) models and GCMs (Global Climate Models). The basic Kalman filter code can be written in a few lines. In practice, however, there are a variety of difficulties resulting from sampling error, model bias, observation error, lack of model divergence, variations in observation density in space and time, etc. There are tools built into the DART framework to address many of these problems.
This release of DART includes many new features. DART will now read directly from NetCDF files. If your model uses NetCDF file format the model_to_dart and dart_to_model steps are no longer needed. Given that many jobs spend a large percentage of time doing file I/O, this can be a significant speedup in the overall assimilation cycle. DART now distributes the ensemble of model states across the MPI tasks, removing the hard memory limit that a single ensemble member's data fit into the memory of a single task. This removes the memory limit for models at high resolution or with nested grids. DART can assimilate forward operators computed outside of the filter process. Users can provide a table of observations and state vector items along with a factor that can easily prevent one class of observations from impacting another class of state vector data, and vice versa. The DART directory structure has been revamped to help users more easily find the various utilities, tools, supported models, and observation types that come with the DART distribution. The Matlab diagnostic routines have been rewritten to no longer require the external MEXNC toolbox. They now use the intrinsic Matlab NetCDF functions.
To get started, look here:
The best way to get to know the DART software is to follow along while reading the tutorial documents in the DART_LAB and then the DART/tutorial directory.
The latest official release is named "Manhattan". See the extensive release notes Manhattan_release which include installation help, a walk-through of building and running a model, and then examples of how to use the diagnostics to evaluate the success of the assimilation. See Manhattan_diffs_from_Lanai for a brief summary of changes since Lanai, including new functionality, new models and tools, and any non-backwards-compatible changes since the Lanai release.
Future releases of DART are expected to have substantial changes and will be less backwards compatible than has been historically true with DART releases. New development will continue on a separate subversion branch.
Every source file in the DART system has a corresponding .html file that contains specifics for public interfaces in each of the DART modules, for the executable programs which come with DART, and for how to interface new models into the DART system.
The remainder of this page contains links to all the documentation for this DART release.
Updates to the release are now summarized in a file at the top level called CHANGELOG. The latest updates are at the end of this file.
Start here if you are looking for DART User-level HTML documentation. DART comes with an extensive set of documentation including release notes for each version, a walk-through on-line tutorial, and a full set of pdf and framemaker tutorial materials.
The Manhattan release notes include installation hints, a walk-through of building and running a model, and an overview of the diagnostics. It also includes a list of new or changed models, observation support, diagnostics, and non-backwards compatible changes.
For a shorter summary document of only the changes since the last release see Manhattan_diffs_from_Lanai. This may be more helpful for current DART users who are looking for pointers to differences when they update.
Three tutorials, in PDF format, are available. The first is more introductory and interactive with PDF documents and Hands-On Matlab exercises. The full-fledged DART Tutorial is more of a workshop format, with multiple sections covering various parts of DART with suggested exercises at the end of most sections.
All sections below this one are detailed information on the programming interfaces of all the DART modules, the namelist details, the executable programs which are part of DART. For introductory materials, see the links above.
DART contains many library functions and separate executable programs. The main DART executable is the filter program. Other programs generate data or format the diagnostic information.
The executable programs that come with DART include:
The diagnostic programs that process observations after being assimilated by DART include:
The executable programs that convert observations into DART format include:
DART comes with several models which can be used to learn about data assimilation, to do actual experiments with real observations, or to use as a template for adding additional models to DART.
All models in the DART project have individual documentation pages, which can be found here (if an html document is not available, the link is to the .f90 source):
Currently Manhattan has support for many of our larger models such as WRF, POP, CAM, CICE, CLM, ROMS, MPAS_ATM, ... and all lower models such as lorenz_96. Models previously available on Lanai can still be used with DART classic.
Generally read from the file input.nml. We adhere to the F90 standard of starting a namelist with an ampersand '&' and terminating with a slash '/'.
Namelists for Programs:
Namelists for Observation Conversion Programs:
Namelists for Modules:
Namelists for Models:
All modules in the DART project have individual documentation pages, which can be found here:
Assimilation Modules| NOTE: 'work', 'matlab', and 'shell_scripts' directory names have been removed from this list. | |
|---|---|
|--assimilation_code | |--location | | |--annulus | | |--channel | | |--column | | |--oned | | |--threed | | |--threed_cartesian | | |--threed_sphere | | |--twod | | |--twod_annulus | | |--twod_sphere | |--modules | | |--assimilation | | |--io | | |--observations | | |--utilities | |--programs | | |--advance_time | | |--closest_member_tool | | |--compare_states | | | |--work | | |--compute_error | | |--create_fixed_network_seq | | |--create_obs_sequence | | |--fill_inflation_restart | | |--filter | | |--gen_sampling_err_table | | | |--work | | |--integrate_model | | |--model_mod_check | | |--obs_common_subset | | |--obs_diag | | | |--oned | | | |--threed_cartesian | | | |--threed_sphere | | |--obs_impact_tool | | |--obs_loop | | |--obs_selection | | |--obs_seq_coverage | | |--obs_seq_to_netcdf | | |--obs_sequence_tool | | |--obs_seq_verify | | |--perfect_model_obs | | |--preprocess | | |--system_simulation | | | |--final_full_precomputed_tables | | | |--work | | |--wakeup_filter | |--scripts |--build_templates |--developer_tests | |--forward_operators | |--harnesses | | |--filename_harness | | |--read_transpose_write | |--io | | |--work | |--location | | |--annulus | | | |--test | | |--channel | | | |--test | | |--column | | | |--test | | |--oned | | | |--test | | |--threed | | | |--test | | |--threed_cartesian | | | |--test | | |--threed_sphere | | | |--test | | |--twod | | | |--test | | |--twod_annulus | | | |--test | | |--twod_sphere | | |--test | |--mpi_utilities | | |--tests | |--obs_sequence | | |--data | | |--work | |--random_seq | | |--test | |--reg_factor | |--time_manager | |--utilities | |--work |--diagnostics | |--matlab | |--deprecated | |--private |--docs | |--DART_LAB | | |--matlab | | | |--private | | |--presentation | |--doxygen | |--Graphs | |--html | | |--boilerplate | | |--design | | |--history | |--images | |--tutorial |--observations |--forward_operators | |--test |--obs_converters |--AIRS | |--data | |--output |--Ameriflux |--AURA | |--data |--AVISO |--CHAMP |--cice | |--data |--CNOFS |--COSMOS | |--data |--DWL | |--data |--even_sphere |--gnd_gps_vtec |--gps | |--cosmic | | |--20071001 | |--matlab |--GPSPW | |--data |--GTSPP | |--data | |--matlab |--MADIS | |--data |--MIDAS | |--data |--MODIS | |--data |--NCEP | |--ascii_to_obs | |--prep_bufr | |--blk_ublk | |--convert_bufr | |--data | | |--201012 | |--docs | | |--Reason_codes | |--exe | |--lib | |--src |--obs_error |--ok_mesonet | |--data |--quikscat | |--data |--radar | |--examples |--ROMS | |--data |--SABER | |--data | |--progs |--snow | |--data |--SSEC | |--data |--SSUSI | |--data |--text | |--data |--text_GITM |--tpw | |--data | |--doc |--tropical_cyclone | |--data |--utilities | |--oned | |--threed_sphere |--var | |--3DVAR_OBSPROC | |--data |--WOD |--data |
|--models |--9var |--am2 |--bgrid_solo | |--fms_src | | |--atmos_bgrid | | | |--driver | | | | |--solo | | | |--model | | | |--tools | | |--atmos_param | | | |--hs_forcing | | |--atmos_shared | | | |--tracer_driver | | | |--vert_advection | | |--atmos_solo | | |--shared | | |--axis_utils | | |--constants | | |--diag_manager | | |--fft | | |--field_manager | | |--fms | | |--horiz_interp | | |--mpp | | |--platform | | |--sat_vapor_pres | | |--time_manager | | |--topography | | |--tracer_manager | | |--udunits | | |--utilities | |--test |--cam-fv | |--deprecated | |--doc | |--shell_scripts | |--cesm1_5 | |--cesm2_0 |--cam-old | |--deprecated | |--doc | |--full_experiment | |--perfect_model |--CESM | |--doc | |--CESM_DART_assim_modes |--cice |--clm | |--datm | |--docs |--cm1 |--coamps | |--doc | |--externals | | |--obs_def | |--templates |--coamps_nest | |--doc | |--externals | | |--obs_def | |--shell_scripts | | |--COAMPS_RESTART_SCRIPTS | | |--TEMPLATES | |--templates | | |--EXPERIMENT_EXAMPLE |--dynamo | |--data |--ECHAM |--forced_barot | |--obs |--forced_lorenz_96 |--gitm | |--GITM2 | | |--src | |--python | |--testdata1 |--ikeda |--LMDZ |--lorenz_04 |--lorenz_63 |--lorenz_84 |--lorenz_96 | |--tests |--lorenz_96_2scale |--MITgcm_annulus |--MITgcm_ocean | |--inputs |--model_mod_tools |--mpas_atm | |--data |--mpas_ocn | |--data |--NAAPS |--NCOMMAS | |--docs |--noah | |--ensemble_source | |--forcing | |--templates |--null_model |--PBL_1d |--pe2lyr |--POP |--ROMS | |--data | |--doc |--rose |--simple_advection |--sqg |--template |--tiegcm |--wrf |--experiments | |--Radar | |--IC | | |--sounding_perturbation | |--obs |--namelist |--PERTURB | |--3DVAR-COVAR |--regression | |--CONUS-V2 | |--CONUS-V3 | |--Global-V3 | |--Radar | |--WRF |--WRF_BC |--WRF_DART_utilities |
Additional documentation which didn't fit neatly into the other categories.
The kitchen sink - quick links to all existing html docs plus all model_mod source files in the DART distribution tree:
DART software - Copyright UCAR. This open source software is provided by UCAR, "as is", without charge, subject to all terms of use at http://www.image.ucar.edu/DAReS/DART/DART_download
| Contact: | DART core group |
| Revision: | $Revision$ |
| Source: | $URL$ |
| Change Date: | $Date$ |
| Change history: | try "svn log" or "svn diff" |


|
cds
1.2.0
|
Memory manager (Garbage collector) More...
#include <cds/gc/ptb/ptb.h>
Data Structures | |
| struct | InternalState |
| Internal GC statistics. More... |
Public Member Functions | |
| CDS_DECLARE_EXCEPTION (PTBManagerEmpty,"Global PTB GarbageCollector is NULL") | |
| Exception "No GarbageCollector object is created". | |
| InternalState & | getInternalState (InternalState &stat) const |
| Get internal statistics. | |
| bool | isStatisticsEnabled () const |
| Checks if internal statistics enabled. | |
| bool | enableStatistics (bool bEnable) |
| Enables/disables internal statistics. |
Static Public Member Functions | |
| static void CDS_STDCALL | Construct (size_t nLiberateThreshold=1024, size_t nInitialThreadGuardCount=8) |
| Initializes PTB memory manager singleton. | |
| static void CDS_STDCALL | Destruct () |
| Destroys PTB memory manager. | |
| static GarbageCollector & | instance () |
| Returns pointer to GarbageCollector instance. | |
| static bool | isUsed () noexcept() |
| Checks if global GC object is constructed and may be used. |
Private Attributes | |
| details::guard_allocator | m_GuardPool |
| Guard pool. | |
| details::retired_ptr_pool | m_RetiredAllocator |
| Pool of free retired pointers. | |
| details::retired_ptr_buffer | m_RetiredBuffer |
| Retired pointer buffer for liberating. | |
| std::atomic< size_t > | m_nLiberateThreshold |
| Max size of retired pointer buffer to call liberate. | |
| const size_t | m_nInitialThreadGuardCount |
| Initial count of guards allocated for ThreadGC. | |
| internal_stat | m_stat |
| Internal statistics. | |
| bool | m_bStatEnabled |
| Internal Statistics enabled. |
Static Private Attributes | |
| static GarbageCollector * | m_pManager |
| GC global instance. | |
| details::guard_data * | allocGuard () |
| Internal interface. | |
| void | freeGuard (details::guard_data *pGuard) |
Frees guard g for reusing in future. | |
| details::guard_data * | allocGuardList (size_t nCount) |
| Allocates guard list for a thread. | |
| void | freeGuardList (details::guard_data *pList) |
Frees thread's guard list pointed by pList . | |
| template<typename T > | |
| void | retirePtr (T *p, void(*pFunc)(T *)) |
Places retired pointer and its deleter pFunc into thread's array of retired pointer for deferred reclamation. | |
| void | retirePtr (const retired_ptr &p) |
Places retired pointer into thread's array of retired pointer for deferred reclamation. | |
| void | liberate () |
| Liberate function. |
Memory manager (Garbage collector)
|
inline |
Internal interface.
Allocates a guard
|
static |
Initializes PTB memory manager singleton.
This member function creates and initializes PTB global object. The function should be called before using CDS data structure based on cds::gc::PTB GC. Usually, this member function is called in the main()
function. See cds::gc::ptb for example. After calling of this function you may use CDS data structures based on cds::gc::PTB.
nLiberateThreshold
- the liberate threshold. When count of retired pointers reaches this value, the liberate member function would be called for freeing retired pointers. If nLiberateThreshold
<= 1, liberate
would called after each retirePtr call. nInitialThreadGuardCount
- initial count of guard allocated for ThreadGC. When a thread is initialized the GC allocates local guard pool for the thread from common guard pool. By perforce the local thread's guard pool is grown automatically from common pool. When the thread terminated its guard pool is backed to common GC's pool.
|
static |
Destroys PTB memory manager.
The member function destroys PTB global object. After calling of this function you may NOT use CDS data structures based on cds::gc::PTB. Usually, the Destruct
function is called at the end of your main()
. See cds::gc::ptb for example.
|
inlinestatic |
Returns pointer to GarbageCollector instance.
If PTB GC is not initialized, PTBManagerEmpty
exception is thrown
|
protected |
Liberate function.
The main function of Pass The Buck algorithm. It tries to free retired pointers if they are not trapped by any guard.


Thai court bars opposition party leader from Parliament
BANGKOK : Thailand's Constitutional Court yesterday disqualified outspoken opposition party leader Thanathorn Juangroongruangkit as a Member of Parliament after finding him guilty of violating election law.
Mr Thanathorn, 40, has emerged as the most prominent opponent of a government headed by former junta chief Prayut Chan-o-cha, 65, after the progressive Future Forward Party came a surprise third in an election in March.
The Constitutional Court found Mr Thanathorn guilty of holding shares in a media company on the date his candidacy was registered for the election to formally end five years of military rule.
ASSUMPTIONS
In its ruling, the court said the evidence against Mr Thanathorn outweighed that in his favour. The opposition leader had argued that he had disposed of the shares in time.
After the ruling, Mr Thanathorn said the court had ruled based on assumptions rather than facts.
"I'm still the leader of the Future Forward party and the party is the journey. The journey never ends," Mr Thanathorn said.
"The people will move forward together and I'll continue to work on amending the constitution."
Mr Thanathorn's party had won 80 out of 500 available seats in the Lower House of Parliament in the election.
After the court ruling, #RIPThailand and #StandWithThanathorn were among the hashtags trending on Twitter in Thailand, along with his name and the party's name in Thai.
Mr Thanathorn also faces two criminal charges, one for computer crimes for a speech he posted on Facebook criticising the junta last year, and another for sedition for allegedly aiding anti-junta protesters in 2015.
In all, nearly 30 cases have been brought against Future Forward leaders. - REUTERS


| 1 | /* | |
| 2 | * Copyright 2001-2010 Stephen Colebourne | |
| 3 | * | |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); | |
| 5 | * you may not use this file except in compliance with the License. | |
| 6 | * You may obtain a copy of the License at | |
| 7 | * | |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 9 | * | |
| 10 | * Unless required by applicable law or agreed to in writing, software | |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 13 | * See the License for the specific language governing permissions and | |
| 14 | * limitations under the License. | |
| 15 | */ | |
| 16 | package org.joda.time; | |
| 17 | ||
| 18 | import java.io.Serializable; | |
| 19 | import java.util.Calendar; | |
| 20 | import java.util.Date; | |
| 21 | import java.util.Locale; | |
| 22 | ||
| 23 | import org.joda.convert.FromString; | |
| 24 | import org.joda.convert.ToString; | |
| 25 | import org.joda.time.base.BasePartial; | |
| 26 | import org.joda.time.chrono.ISOChronology; | |
| 27 | import org.joda.time.field.AbstractPartialFieldProperty; | |
| 28 | import org.joda.time.field.FieldUtils; | |
| 29 | import org.joda.time.format.DateTimeFormat; | |
| 30 | import org.joda.time.format.DateTimeFormatter; | |
| 31 | import org.joda.time.format.ISODateTimeFormat; | |
| 32 | ||
| 33 | /** | |
| 34 | * YearMonth is an immutable partial supporting the year and monthOfYear fields. | |
| 35 | *
 | |
| 36 | * NOTE: This class only supports the two fields listed above. | |
| 37 | * It is impossible to query any other fields, such as dayOfWeek or centuryOfEra. | |
| 38 | *
 | |
| 39 | * Calculations on YearMonth are performed using a {@link Chronology}. | |
| 40 | * This chronology is set to be in the UTC time zone for all calculations. | |
| 41 | *
 | |
| 42 | * One use case for this class is to store a credit card expiry date, as that only | |
| 43 | * references the year and month. | |
| 44 | * This class can be used as the gYearMonth type in XML Schema. | |
| 45 | *
 | |
| 46 | * Each individual field can be queried in two ways: | |
| 47 | *
 | |
| 48 | *
getMonthOfYear() | |
| 49 | *
monthOfYear().get() | |
| 50 | *
 | |
| 51 | * The second technique also provides access to other useful methods on the | |
| 52 | * field: | |
| 53 | *
 | |
| 54 | *
numeric value - monthOfYear().get() | |
| 55 | *
text value - monthOfYear().getAsText() | |
| 56 | *
short text value - monthOfYear().getAsShortText() | |
| 57 | *
maximum/minimum values - monthOfYear().getMaximumValue() | |
| 58 | *
add/subtract - monthOfYear().addToCopy() | |
| 59 | *
set - monthOfYear().setCopy() | |
| 60 | *
 | |
| 61 | *
 | |
| 62 | * YearMonth is thread-safe and immutable, provided that the Chronology is as well. | |
| 63 | * All standard Chronology classes supplied are thread-safe and immutable. | |
| 64 | * | |
| 65 | * @author Stephen Colebourne | |
| 66 | * @since 2.0 | |
| 67 | */ | |
| 68 | public final class YearMonth | |
| 69 | extends BasePartial | |
| 70 | implements ReadablePartial, Serializable { | |
| 71 | ||
| 72 | /** Serialization version */ | |
| 73 | private static final long serialVersionUID =<PHONE_NUMBER>96179L; | |
| 74 | /** The singleton set of field types */ | |
| 75 | private static final DateTimeFieldType[] FIELD_TYPES = new DateTimeFieldType[] { | |
| 76 | DateTimeFieldType.year(), | |
| 77 | DateTimeFieldType.monthOfYear(), | |
| 78 | }; | |
| 79 | ||
| 80 | /** The index of the year field in the field array */ | |
| 81 | public static final int YEAR = 0; | |
| 82 | /** The index of the monthOfYear field in the field array */ | |
| 83 | public static final int MONTH_OF_YEAR = 1; | |
| 84 | ||
| 85 | //----------------------------------------------------------------------- | |
| 86 | /** | |
| 87 | * Obtains a {@code YearMonth} set to the current system millisecond time | |
| 88 | * using ISOChronology in the default time zone. | |
| 89 | * The resulting object does not use the zone. | |
| 90 | * | |
| 91 | * @return the current year-month, not null | |
| 92 | * @since 2.0 | |
| 93 | */ | |
| 94 | public static YearMonth now() { | |
| 95 |
1
1. now : mutated return of Object value for org/joda/time/YearMonth::now to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(); |
| 96 | } | |
| 97 | ||
| 98 | /** | |
| 99 | * Obtains a {@code YearMonth} set to the current system millisecond time | |
| 100 | * using ISOChronology in the specified time zone. | |
| 101 | * The resulting object does not use the zone. | |
| 102 | * | |
| 103 | * @param zone the time zone, not null | |
| 104 | * @return the current year-month, not null | |
| 105 | * @since 2.0 | |
| 106 | */ | |
| 107 | public static YearMonth now(DateTimeZone zone) { | |
| 108 |
1
1. now : negated conditional → NO_COVERAGE |
if (zone == null) { |
| 109 | throw new NullPointerException("Zone must not be null"); | |
| 110 | } | |
| 111 |
1
1. now : mutated return of Object value for org/joda/time/YearMonth::now to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(zone); |
| 112 | } | |
| 113 | ||
| 114 | /** | |
| 115 | * Obtains a {@code YearMonth} set to the current system millisecond time | |
| 116 | * using the specified chronology. | |
| 117 | * The resulting object does not use the zone. | |
| 118 | * | |
| 119 | * @param chronology the chronology, not null | |
| 120 | * @return the current year-month, not null | |
| 121 | * @since 2.0 | |
| 122 | */ | |
| 123 | public static YearMonth now(Chronology chronology) { | |
| 124 |
1
1. now : negated conditional → NO_COVERAGE |
if (chronology == null) { |
| 125 | throw new NullPointerException("Chronology must not be null"); | |
| 126 | } | |
| 127 |
1
1. now : mutated return of Object value for org/joda/time/YearMonth::now to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(chronology); |
| 128 | } | |
| 129 | ||
| 130 | //----------------------------------------------------------------------- | |
| 131 | /** | |
| 132 | * Parses a {@code YearMonth} from the specified string. | |
| 133 | *
 | |
| 134 | * This uses {@link ISODateTimeFormat#localDateParser()}. | |
| 135 | * | |
| 136 | * @param str the string to parse, not null | |
| 137 | * @since 2.0 | |
| 138 | */ | |
| 139 | @FromString | |
| 140 | public static YearMonth parse(String str) { | |
| 141 |
1
1. parse : mutated return of Object value for org/joda/time/YearMonth::parse to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return parse(str, ISODateTimeFormat.localDateParser()); |
| 142 | } | |
| 143 | ||
| 144 | /** | |
| 145 | * Parses a {@code YearMonth} from the specified string using a formatter. | |
| 146 | * | |
| 147 | * @param str the string to parse, not null | |
| 148 | * @param formatter the formatter to use, not null | |
| 149 | * @since 2.0 | |
| 150 | */ | |
| 151 | public static YearMonth parse(String str, DateTimeFormatter formatter) { | |
| 152 | LocalDate date = formatter.parseLocalDate(str); | |
| 153 |
1
1. parse : mutated return of Object value for org/joda/time/YearMonth::parse to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(date.getYear(), date.getMonthOfYear()); |
| 154 | } | |
| 155 | ||
| 156 | //----------------------------------------------------------------------- | |
| 157 | /** | |
| 158 | * Constructs a YearMonth from a java.util.Calendar | |
| 159 | * using exactly the same field values avoiding any time zone effects. | |
| 160 | *
 | |
| 161 | * Each field is queried from the Calendar and assigned to the YearMonth. | |
| 162 | *
 | |
| 163 | * This factory method ignores the type of the calendar and always | |
| 164 | * creates a YearMonth with ISO chronology. It is expected that you | |
| 165 | * will only pass in instances of GregorianCalendar however | |
| 166 | * this is not validated. | |
| 167 | * | |
| 168 | * @param calendar the Calendar to extract fields from | |
| 169 | * @return the created YearMonth, never null | |
| 170 | * @throws IllegalArgumentException if the calendar is null | |
| 171 | * @throws IllegalArgumentException if the year or month is invalid for the ISO chronology | |
| 172 | */ | |
| 173 | public static YearMonth fromCalendarFields(Calendar calendar) { | |
| 174 |
1
1. fromCalendarFields : negated conditional → NO_COVERAGE |
if (calendar == null) { |
| 175 | throw new IllegalArgumentException("The calendar must not be null"); | |
| 176 | } | |
| 177 |
2
1. fromCalendarFields : Replaced integer addition with subtraction → NO_COVERAGE 2. fromCalendarFields : mutated return of Object value for org/joda/time/YearMonth::fromCalendarFields to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) + 1); |
| 178 | } | |
| 179 | ||
| 180 | /** | |
| 181 | * Constructs a YearMonth from a java.util.Date | |
| 182 | * using exactly the same field values avoiding any time zone effects. | |
| 183 | *
 | |
| 184 | * Each field is queried from the Date and assigned to the YearMonth. | |
| 185 | *
 | |
| 186 | * This factory method always creates a YearMonth with ISO chronology. | |
| 187 | * | |
| 188 | * @param date the Date to extract fields from | |
| 189 | * @return the created YearMonth, never null | |
| 190 | * @throws IllegalArgumentException if the calendar is null | |
| 191 | * @throws IllegalArgumentException if the year or month is invalid for the ISO chronology | |
| 192 | */ | |
| 193 | @SuppressWarnings("deprecation") | |
| 194 | public static YearMonth fromDateFields(Date date) { | |
| 195 |
1
1. fromDateFields : negated conditional → NO_COVERAGE |
if (date == null) { |
| 196 | throw new IllegalArgumentException("The date must not be null"); | |
| 197 | } | |
| 198 |
3
1. fromDateFields : Replaced integer addition with subtraction → NO_COVERAGE 2. fromDateFields : Replaced integer addition with subtraction → NO_COVERAGE 3. fromDateFields : mutated return of Object value for org/joda/time/YearMonth::fromDateFields to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(date.getYear() + 1900, date.getMonth() + 1); |
| 199 | } | |
| 200 | ||
| 201 | //----------------------------------------------------------------------- | |
| 202 | /** | |
| 203 | * Constructs a YearMonth with the current year-month, using ISOChronology in | |
| 204 | * the default zone to extract the fields. | |
| 205 | *
 | |
| 206 | * The constructor uses the default time zone, resulting in the local time | |
| 207 | * being initialised. Once the constructor is complete, all further calculations | |
| 208 | * are performed without reference to a time-zone (by switching to UTC). | |
| 209 | * | |
| 210 | * @see #now() | |
| 211 | */ | |
| 212 | public YearMonth() { | |
| 213 | super(); | |
| 214 | } | |
| 215 | ||
| 216 | /** | |
| 217 | * Constructs a YearMonth with the current year-month, using ISOChronology in | |
| 218 | * the specified zone to extract the fields. | |
| 219 | *
 | |
| 220 | * The constructor uses the specified time zone to obtain the current year-month. | |
| 221 | * Once the constructor is complete, all further calculations | |
| 222 | * are performed without reference to a time-zone (by switching to UTC). | |
| 223 | * | |
| 224 | * @param zone the zone to use, null means default zone | |
| 225 | * @see #now(DateTimeZone) | |
| 226 | */ | |
| 227 | public YearMonth(DateTimeZone zone) { | |
| 228 | super(ISOChronology.getInstance(zone)); | |
| 229 | } | |
| 230 | ||
| 231 | /** | |
| 232 | * Constructs a YearMonth with the current year-month, using the specified chronology | |
| 233 | * and zone to extract the fields. | |
| 234 | *
 | |
| 235 | * The constructor uses the time zone of the chronology specified. | |
| 236 | * Once the constructor is complete, all further calculations are performed | |
| 237 | * without reference to a time-zone (by switching to UTC). | |
| 238 | * | |
| 239 | * @param chronology the chronology, null means ISOChronology in the default zone | |
| 240 | * @see #now(Chronology) | |
| 241 | */ | |
| 242 | public YearMonth(Chronology chronology) { | |
| 243 | super(chronology); | |
| 244 | } | |
| 245 | ||
| 246 | /** | |
| 247 | * Constructs a YearMonth extracting the partial fields from the specified | |
| 248 | * milliseconds using the ISOChronology in the default zone. | |
| 249 | *
 | |
| 250 | * The constructor uses the default time zone, resulting in the local time | |
| 251 | * being initialised. Once the constructor is complete, all further calculations | |
| 252 | * are performed without reference to a time-zone (by switching to UTC). | |
| 253 | * | |
| 254 | * @param instant the milliseconds from 1970-01-01T00:00:00Z | |
| 255 | */ | |
| 256 | public YearMonth(long instant) { | |
| 257 | super(instant); | |
| 258 | } | |
| 259 | ||
| 260 | /** | |
| 261 | * Constructs a YearMonth extracting the partial fields from the specified | |
| 262 | * milliseconds using the chronology provided. | |
| 263 | *
 | |
| 264 | * The constructor uses the time zone of the chronology specified. | |
| 265 | * Once the constructor is complete, all further calculations are performed | |
| 266 | * without reference to a time-zone (by switching to UTC). | |
| 267 | * | |
| 268 | * @param instant the milliseconds from 1970-01-01T00:00:00Z | |
| 269 | * @param chronology the chronology, null means ISOChronology in the default zone | |
| 270 | */ | |
| 271 | public YearMonth(long instant, Chronology chronology) { | |
| 272 | super(instant, chronology); | |
| 273 | } | |
| 274 | ||
| 275 | /** | |
| 276 | * Constructs a YearMonth from an Object that represents some form of time. | |
| 277 | *
 | |
| 278 | * The recognised object types are defined in | |
| 279 | * {@link org.joda.time.convert.ConverterManager ConverterManager} and | |
| 280 | * include ReadableInstant, String, Calendar and Date. | |
| 281 | * The String formats are described by {@link ISODateTimeFormat#localDateParser()}. | |
| 282 | *
 | |
| 283 | * The chronology used will be derived from the object, defaulting to ISO. | |
| 284 | * | |
| 285 | * @param instant the date-time object, null means now | |
| 286 | * @throws IllegalArgumentException if the instant is invalid | |
| 287 | */ | |
| 288 | public YearMonth(Object instant) { | |
| 289 | super(instant, null, ISODateTimeFormat.localDateParser()); | |
| 290 | } | |
| 291 | ||
| 292 | /** | |
| 293 | * Constructs a YearMonth from an Object that represents some form of time, | |
| 294 | * using the specified chronology. | |
| 295 | *
 | |
| 296 | * The recognised object types are defined in | |
| 297 | * {@link org.joda.time.convert.ConverterManager ConverterManager} and | |
| 298 | * include ReadableInstant, String, Calendar and Date. | |
| 299 | * The String formats are described by {@link ISODateTimeFormat#localDateParser()}. | |
| 300 | *
 | |
| 301 | * The constructor uses the time zone of the chronology specified. | |
| 302 | * Once the constructor is complete, all further calculations are performed | |
| 303 | * without reference to a time-zone (by switching to UTC). | |
| 304 | * The specified chronology overrides that of the object. | |
| 305 | * | |
| 306 | * @param instant the date-time object, null means now | |
| 307 | * @param chronology the chronology, null means ISO default | |
| 308 | * @throws IllegalArgumentException if the instant is invalid | |
| 309 | */ | |
| 310 | public YearMonth(Object instant, Chronology chronology) { | |
| 311 | super(instant, DateTimeUtils.getChronology(chronology), ISODateTimeFormat.localDateParser()); | |
| 312 | } | |
| 313 | ||
| 314 | /** | |
| 315 | * Constructs a YearMonth with specified year and month | |
| 316 | * using ISOChronology. | |
| 317 | *
 | |
| 318 | * The constructor uses the no time zone initialising the fields as provided. | |
| 319 | * Once the constructor is complete, all further calculations | |
| 320 | * are performed without reference to a time-zone (by switching to UTC). | |
| 321 | * | |
| 322 | * @param year the year | |
| 323 | * @param monthOfYear the month of the year | |
| 324 | */ | |
| 325 | public YearMonth(int year, int monthOfYear) { | |
| 326 | this(year, monthOfYear, null); | |
| 327 | } | |
| 328 | ||
| 329 | /** | |
| 330 | * Constructs an instance set to the specified year and month | |
| 331 | * using the specified chronology, whose zone is ignored. | |
| 332 | *
 | |
| 333 | * If the chronology is null, ISOChronology is used. | |
| 334 | *
 | |
| 335 | * The constructor uses the time zone of the chronology specified. | |
| 336 | * Once the constructor is complete, all further calculations are performed | |
| 337 | * without reference to a time-zone (by switching to UTC). | |
| 338 | * | |
| 339 | * @param year the year | |
| 340 | * @param monthOfYear the month of the year | |
| 341 | * @param chronology the chronology, null means ISOChronology in the default zone | |
| 342 | */ | |
| 343 | public YearMonth(int year, int monthOfYear, Chronology chronology) { | |
| 344 | super(new int[] {year, monthOfYear}, chronology); | |
| 345 | } | |
| 346 | ||
| 347 | /** | |
| 348 | * Constructs a YearMonth with chronology from this instance and new values. | |
| 349 | * | |
| 350 | * @param partial the partial to base this new instance on | |
| 351 | * @param values the new set of values | |
| 352 | */ | |
| 353 | YearMonth(YearMonth partial, int[] values) { | |
| 354 | super(partial, values); | |
| 355 | } | |
| 356 | ||
| 357 | /** | |
| 358 | * Constructs a YearMonth with values from this instance and a new chronology. | |
| 359 | * | |
| 360 | * @param partial the partial to base this new instance on | |
| 361 | * @param chrono the new chronology | |
| 362 | */ | |
| 363 | YearMonth(YearMonth partial, Chronology chrono) { | |
| 364 | super(partial, chrono); | |
| 365 | } | |
| 366 | ||
| 367 | /** | |
| 368 | * Handle broken serialization from other tools. | |
| 369 | * @return the resolved object, not null | |
| 370 | */ | |
| 371 | private Object readResolve() { | |
| 372 |
1
1. readResolve : negated conditional → NO_COVERAGE |
if (DateTimeZone.UTC.equals(getChronology().getZone()) == false) { |
| 373 |
1
1. readResolve : mutated return of Object value for org/joda/time/YearMonth::readResolve to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(this, getChronology().withUTC()); |
| 374 | } | |
| 375 |
1
1. readResolve : mutated return of Object value for org/joda/time/YearMonth::readResolve to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this; |
| 376 | } | |
| 377 | ||
| 378 | //----------------------------------------------------------------------- | |
| 379 | /** | |
| 380 | * Gets the number of fields in this partial, which is two. | |
| 381 | * The supported fields are Year and MonthOfYear. | |
| 382 | * Note that only these fields may be queried. | |
| 383 | * | |
| 384 | * @return the field count, two | |
| 385 | */ | |
| 386 | public int size() { | |
| 387 |
1
1. size : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return 2; |
| 388 | } | |
| 389 | ||
| 390 | /** | |
| 391 | * Gets the field for a specific index in the chronology specified. | |
| 392 | *
 | |
| 393 | * This method must not use any instance variables. | |
| 394 | * | |
| 395 | * @param index the index to retrieve | |
| 396 | * @param chrono the chronology to use | |
| 397 | * @return the field, never null | |
| 398 | */ | |
| 399 | protected DateTimeField getField(int index, Chronology chrono) { | |
| 400 | switch (index) { | |
| 401 | case YEAR: | |
| 402 |
1
1. getField : mutated return of Object value for org/joda/time/YearMonth::getField to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return chrono.year(); |
| 403 | case MONTH_OF_YEAR: | |
| 404 |
1
1. getField : mutated return of Object value for org/joda/time/YearMonth::getField to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return chrono.monthOfYear(); |
| 405 | default: | |
| 406 | throw new IndexOutOfBoundsException("Invalid index: " + index); | |
| 407 | } | |
| 408 | } | |
| 409 | ||
| 410 | /** | |
| 411 | * Gets the field type at the specified index. | |
| 412 | * | |
| 413 | * @param index the index to retrieve | |
| 414 | * @return the field at the specified index, never null | |
| 415 | * @throws IndexOutOfBoundsException if the index is invalid | |
| 416 | */ | |
| 417 | public DateTimeFieldType getFieldType(int index) { | |
| 418 |
1
1. getFieldType : mutated return of Object value for org/joda/time/YearMonth::getFieldType to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return FIELD_TYPES[index]; |
| 419 | } | |
| 420 | ||
| 421 | /** | |
| 422 | * Gets an array of the field type of each of the fields that this partial supports. | |
| 423 | *
 | |
| 424 | * The fields are returned largest to smallest, Year, Month. | |
| 425 | * | |
| 426 | * @return the array of field types (cloned), largest to smallest, never null | |
| 427 | */ | |
| 428 | public DateTimeFieldType[] getFieldTypes() { | |
| 429 |
1
1. getFieldTypes : mutated return of Object value for org/joda/time/YearMonth::getFieldTypes to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return (DateTimeFieldType[]) FIELD_TYPES.clone(); |
| 430 | } | |
| 431 | ||
| 432 | //----------------------------------------------------------------------- | |
| 433 | /** | |
| 434 | * Returns a copy of this year-month with the specified chronology. | |
| 435 | * This instance is immutable and unaffected by this method call. | |
| 436 | *
 | |
| 437 | * This method retains the values of the fields, thus the result will | |
| 438 | * typically refer to a different instant. | |
| 439 | *
 | |
| 440 | * The time zone of the specified chronology is ignored, as YearMonth | |
| 441 | * operates without a time zone. | |
| 442 | * | |
| 443 | * @param newChronology the new chronology, null means ISO | |
| 444 | * @return a copy of this year-month with a different chronology, never null | |
| 445 | * @throws IllegalArgumentException if the values are invalid for the new chronology | |
| 446 | */ | |
| 447 | public YearMonth withChronologyRetainFields(Chronology newChronology) { | |
| 448 | newChronology = DateTimeUtils.getChronology(newChronology); | |
| 449 | newChronology = newChronology.withUTC(); | |
| 450 |
1
1. withChronologyRetainFields : negated conditional → NO_COVERAGE |
if (newChronology == getChronology()) { |
| 451 |
1
1. withChronologyRetainFields : mutated return of Object value for org/joda/time/YearMonth::withChronologyRetainFields to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this; |
| 452 | } else { | |
| 453 | YearMonth newYearMonth = new YearMonth(this, newChronology); | |
| 454 |
1
1. withChronologyRetainFields : removed call to org/joda/time/Chronology::validate → NO_COVERAGE |
newChronology.validate(newYearMonth, getValues()); |
| 455 |
1
1. withChronologyRetainFields : mutated return of Object value for org/joda/time/YearMonth::withChronologyRetainFields to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return newYearMonth; |
| 456 | } | |
| 457 | } | |
| 458 | ||
| 459 | /** | |
| 460 | * Returns a copy of this year-month with the specified field set to a new value. | |
| 461 | *
 | |
| 462 | * For example, if the field type is monthOfYear then the month | |
| 463 | * would be changed in the returned instance. | |
| 464 | *
 | |
| 465 | * These three lines are equivalent: | |
| 466 | *
 | |
| 467 | * YearMonth updated = ym.withField(DateTimeFieldType.monthOfYear(), 6); | |
| 468 | * YearMonth updated = ym.monthOfYear().setCopy(6); | |
| 469 | * YearMonth updated = ym.property(DateTimeFieldType.monthOfYear()).setCopy(6); | |
| 470 | *
 | |
| 471 | * | |
| 472 | * @param fieldType the field type to set, not null | |
| 473 | * @param value the value to set | |
| 474 | * @return a copy of this instance with the field set, never null | |
| 475 | * @throws IllegalArgumentException if the value is null or invalid | |
| 476 | */ | |
| 477 | public YearMonth withField(DateTimeFieldType fieldType, int value) { | |
| 478 | int index = indexOfSupported(fieldType); | |
| 479 |
1
1. withField : negated conditional → NO_COVERAGE |
if (value == getValue(index)) { |
| 480 |
1
1. withField : mutated return of Object value for org/joda/time/YearMonth::withField to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this; |
| 481 | } | |
| 482 | int[] newValues = getValues(); | |
| 483 | newValues = getField(index).set(this, index, newValues, value); | |
| 484 |
1
1. withField : mutated return of Object value for org/joda/time/YearMonth::withField to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(this, newValues); |
| 485 | } | |
| 486 | ||
| 487 | /** | |
| 488 | * Returns a copy of this year-month with the value of the specified field increased. | |
| 489 | *
 | |
| 490 | * If the addition is zero, then this is returned. | |
| 491 | *
 | |
| 492 | * These three lines are equivalent: | |
| 493 | *
 | |
| 494 | * YearMonth added = ym.withFieldAdded(DurationFieldType.months(), 6); | |
| 495 | * YearMonth added = ym.plusMonths(6); | |
| 496 | * YearMonth added = ym.monthOfYear().addToCopy(6); | |
| 497 | *
 | |
| 498 | * | |
| 499 | * @param fieldType the field type to add to, not null | |
| 500 | * @param amount the amount to add | |
| 501 | * @return a copy of this instance with the field updated, never null | |
| 502 | * @throws IllegalArgumentException if the value is null or invalid | |
| 503 | * @throws ArithmeticException if the new date-time exceeds the capacity | |
| 504 | */ | |
| 505 | public YearMonth withFieldAdded(DurationFieldType fieldType, int amount) { | |
| 506 | int index = indexOfSupported(fieldType); | |
| 507 |
1
1. withFieldAdded : negated conditional → NO_COVERAGE |
if (amount == 0) { |
| 508 |
1
1. withFieldAdded : mutated return of Object value for org/joda/time/YearMonth::withFieldAdded to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this; |
| 509 | } | |
| 510 | int[] newValues = getValues(); | |
| 511 | newValues = getField(index).add(this, index, newValues, amount); | |
| 512 |
1
1. withFieldAdded : mutated return of Object value for org/joda/time/YearMonth::withFieldAdded to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(this, newValues); |
| 513 | } | |
| 514 | ||
| 515 | /** | |
| 516 | * Returns a copy of this year-month with the specified period added. | |
| 517 | *
 | |
| 518 | * If the addition is zero, then this is returned. | |
| 519 | * Fields in the period that aren't present in the partial are ignored. | |
| 520 | *
 | |
| 521 | * This method is typically used to add multiple copies of complex | |
| 522 | * period instances. Adding one field is best achieved using methods | |
| 523 | * like {@link #withFieldAdded(DurationFieldType, int)} | |
| 524 | * or {@link #plusYears(int)}. | |
| 525 | * | |
| 526 | * @param period the period to add to this one, null means zero | |
| 527 | * @param scalar the amount of times to add, such as -1 to subtract once | |
| 528 | * @return a copy of this instance with the period added, never null | |
| 529 | * @throws ArithmeticException if the new date-time exceeds the capacity | |
| 530 | */ | |
| 531 | public YearMonth withPeriodAdded(ReadablePeriod period, int scalar) { | |
| 532 |
2
1. withPeriodAdded : negated conditional → NO_COVERAGE 2. withPeriodAdded : negated conditional → NO_COVERAGE |
if (period == null || scalar == 0) { |
| 533 |
1
1. withPeriodAdded : mutated return of Object value for org/joda/time/YearMonth::withPeriodAdded to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this; |
| 534 | } | |
| 535 | int[] newValues = getValues(); | |
| 536 |
3
1. withPeriodAdded : changed conditional boundary → NO_COVERAGE 2. withPeriodAdded : Changed increment from 1 to -1 → NO_COVERAGE 3. withPeriodAdded : negated conditional → NO_COVERAGE |
for (int i = 0; i < period.size(); i++) { |
| 537 | DurationFieldType fieldType = period.getFieldType(i); | |
| 538 | int index = indexOf(fieldType); | |
| 539 |
2
1. withPeriodAdded : changed conditional boundary → NO_COVERAGE 2. withPeriodAdded : negated conditional → NO_COVERAGE |
if (index >= 0) { |
| 540 | newValues = getField(index).add(this, index, newValues, | |
| 541 | FieldUtils.safeMultiply(period.getValue(i), scalar)); | |
| 542 | } | |
| 543 | } | |
| 544 |
1
1. withPeriodAdded : mutated return of Object value for org/joda/time/YearMonth::withPeriodAdded to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(this, newValues); |
| 545 | } | |
| 546 | ||
| 547 | //----------------------------------------------------------------------- | |
| 548 | /** | |
| 549 | * Returns a copy of this year-month with the specified period added. | |
| 550 | *
 | |
| 551 | * If the amount is zero or null, then this is returned. | |
| 552 | *
 | |
| 553 | * This method is typically used to add complex period instances. | |
| 554 | * Adding one field is best achieved using methods | |
| 555 | * like {@link #plusYears(int)}. | |
| 556 | * | |
| 557 | * @param period the duration to add to this one, null means zero | |
| 558 | * @return a copy of this instance with the period added, never null | |
| 559 | * @throws ArithmeticException if the new year-month exceeds the capacity | |
| 560 | */ | |
| 561 | public YearMonth plus(ReadablePeriod period) { | |
| 562 |
1
1. plus : mutated return of Object value for org/joda/time/YearMonth::plus to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return withPeriodAdded(period, 1); |
| 563 | } | |
| 564 | ||
| 565 | //----------------------------------------------------------------------- | |
| 566 | /** | |
| 567 | * Returns a copy of this year-month plus the specified number of years. | |
| 568 | *
 | |
| 569 | * This year-month instance is immutable and unaffected by this method call. | |
| 570 | *
 | |
| 571 | * The following three lines are identical in effect: | |
| 572 | *
 | |
| 573 | * YearMonth added = ym.plusYears(6); | |
| 574 | * YearMonth added = ym.plus(Period.years(6)); | |
| 575 | * YearMonth added = ym.withFieldAdded(DurationFieldType.years(), 6); | |
| 576 | *
 | |
| 577 | * | |
| 578 | * @param years the amount of years to add, may be negative | |
| 579 | * @return the new year-month plus the increased years, never null | |
| 580 | */ | |
| 581 | public YearMonth plusYears(int years) { | |
| 582 |
1
1. plusYears : mutated return of Object value for org/joda/time/YearMonth::plusYears to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return withFieldAdded(DurationFieldType.years(), years); |
| 583 | } | |
| 584 | ||
| 585 | /** | |
| 586 | * Returns a copy of this year-month plus the specified number of months. | |
| 587 | *
 | |
| 588 | * This year-month instance is immutable and unaffected by this method call. | |
| 589 | *
 | |
| 590 | * The following three lines are identical in effect: | |
| 591 | *
 | |
| 592 | * YearMonth added = ym.plusMonths(6); | |
| 593 | * YearMonth added = ym.plus(Period.months(6)); | |
| 594 | * YearMonth added = ym.withFieldAdded(DurationFieldType.months(), 6); | |
| 595 | *
 | |
| 596 | * | |
| 597 | * @param months the amount of months to add, may be negative | |
| 598 | * @return the new year-month plus the increased months, never null | |
| 599 | */ | |
| 600 | public YearMonth plusMonths(int months) { | |
| 601 |
1
1. plusMonths : mutated return of Object value for org/joda/time/YearMonth::plusMonths to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return withFieldAdded(DurationFieldType.months(), months); |
| 602 | } | |
| 603 | ||
| 604 | //----------------------------------------------------------------------- | |
| 605 | /** | |
| 606 | * Returns a copy of this year-month with the specified period taken away. | |
| 607 | *
 | |
| 608 | * If the amount is zero or null, then this is returned. | |
| 609 | *
 | |
| 610 | * This method is typically used to subtract complex period instances. | |
| 611 | * Subtracting one field is best achieved using methods | |
| 612 | * like {@link #minusYears(int)}. | |
| 613 | * | |
| 614 | * @param period the period to reduce this instant by | |
| 615 | * @return a copy of this instance with the period taken away, never null | |
| 616 | * @throws ArithmeticException if the new year-month exceeds the capacity | |
| 617 | */ | |
| 618 | public YearMonth minus(ReadablePeriod period) { | |
| 619 |
1
1. minus : mutated return of Object value for org/joda/time/YearMonth::minus to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return withPeriodAdded(period, -1); |
| 620 | } | |
| 621 | ||
| 622 | //----------------------------------------------------------------------- | |
| 623 | /** | |
| 624 | * Returns a copy of this year-month minus the specified number of years. | |
| 625 | *
 | |
| 626 | * This year-month instance is immutable and unaffected by this method call. | |
| 627 | *
 | |
| 628 | * The following three lines are identical in effect: | |
| 629 | *
 | |
| 630 | * YearMonth subtracted = ym.minusYears(6); | |
| 631 | * YearMonth subtracted = ym.minus(Period.years(6)); | |
| 632 | * YearMonth subtracted = ym.withFieldAdded(DurationFieldType.years(), -6); | |
| 633 | *
 | |
| 634 | * | |
| 635 | * @param years the amount of years to subtract, may be negative | |
| 636 | * @return the new year-month minus the increased years, never null | |
| 637 | */ | |
| 638 | public YearMonth minusYears(int years) { | |
| 639 |
1
1. minusYears : mutated return of Object value for org/joda/time/YearMonth::minusYears to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return withFieldAdded(DurationFieldType.years(), FieldUtils.safeNegate(years)); |
| 640 | } | |
| 641 | ||
| 642 | /** | |
| 643 | * Returns a copy of this year-month minus the specified number of months. | |
| 644 | *
 | |
| 645 | * This year-month instance is immutable and unaffected by this method call. | |
| 646 | *
 | |
| 647 | * The following three lines are identical in effect: | |
| 648 | *
 | |
| 649 | * YearMonth subtracted = ym.minusMonths(6); | |
| 650 | * YearMonth subtracted = ym.minus(Period.months(6)); | |
| 651 | * YearMonth subtracted = ym.withFieldAdded(DurationFieldType.months(), -6); | |
| 652 | *
 | |
| 653 | * | |
| 654 | * @param months the amount of months to subtract, may be negative | |
| 655 | * @return the new year-month minus the increased months, never null | |
| 656 | */ | |
| 657 | public YearMonth minusMonths(int months) { | |
| 658 |
1
1. minusMonths : mutated return of Object value for org/joda/time/YearMonth::minusMonths to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return withFieldAdded(DurationFieldType.months(), FieldUtils.safeNegate(months)); |
| 659 | } | |
| 660 | ||
| 661 | //----------------------------------------------------------------------- | |
| 662 | /** | |
| 663 | * Converts this object to a LocalDate with the same year-month and chronology. | |
| 664 | * | |
| 665 | * @param dayOfMonth the day of month to use, valid for chronology, such as 1-31 for ISO | |
| 666 | * @return a LocalDate with the same year-month and chronology, never null | |
| 667 | */ | |
| 668 | public LocalDate toLocalDate(int dayOfMonth) { | |
| 669 |
1
1. toLocalDate : mutated return of Object value for org/joda/time/YearMonth::toLocalDate to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new LocalDate(getYear(), getMonthOfYear(), dayOfMonth, getChronology()); |
| 670 | } | |
| 671 | ||
| 672 | //----------------------------------------------------------------------- | |
| 673 | /** | |
| 674 | * Converts this object to an Interval representing the whole month. | |
| 675 | *
 | |
| 676 | * The interval will use the chronology of the year-month in the default zone. | |
| 677 | *
 | |
| 678 | * This instance is immutable and unaffected by this method call. | |
| 679 | * | |
| 680 | * @return an interval over the month, never null | |
| 681 | */ | |
| 682 | public Interval toInterval() { | |
| 683 |
1
1. toInterval : mutated return of Object value for org/joda/time/YearMonth::toInterval to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return toInterval(null); |
| 684 | } | |
| 685 | ||
| 686 | /** | |
| 687 | * Converts this object to an Interval representing the whole month. | |
| 688 | *
 | |
| 689 | * The interval will use the chronology of the year-month in the specified zone. | |
| 690 | *
 | |
| 691 | * This instance is immutable and unaffected by this method call. | |
| 692 | * | |
| 693 | * @param zone the zone to get the Interval in, null means default | |
| 694 | * @return an interval over the month, never null | |
| 695 | */ | |
| 696 | public Interval toInterval(DateTimeZone zone) { | |
| 697 | zone = DateTimeUtils.getZone(zone); | |
| 698 | DateTime start = toLocalDate(1).toDateTimeAtStartOfDay(zone); | |
| 699 | DateTime end = plusMonths(1).toLocalDate(1).toDateTimeAtStartOfDay(zone); | |
| 700 |
1
1. toInterval : mutated return of Object value for org/joda/time/YearMonth::toInterval to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new Interval(start, end); |
| 701 | } | |
| 702 | ||
| 703 | //----------------------------------------------------------------------- | |
| 704 | /** | |
| 705 | * Get the year field value. | |
| 706 | * | |
| 707 | * @return the year | |
| 708 | */ | |
| 709 | public int getYear() { | |
| 710 |
1
1. getYear : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return getValue(YEAR); |
| 711 | } | |
| 712 | ||
| 713 | /** | |
| 714 | * Get the month of year field value. | |
| 715 | * | |
| 716 | * @return the month of year | |
| 717 | */ | |
| 718 | public int getMonthOfYear() { | |
| 719 |
1
1. getMonthOfYear : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return getValue(MONTH_OF_YEAR); |
| 720 | } | |
| 721 | ||
| 722 | //----------------------------------------------------------------------- | |
| 723 | /** | |
| 724 | * Returns a copy of this year-month with the year field updated. | |
| 725 | *
 | |
| 726 | * YearMonth is immutable, so there are no set methods. | |
| 727 | * Instead, this method returns a new instance with the value of | |
| 728 | * year changed. | |
| 729 | * | |
| 730 | * @param year the year to set | |
| 731 | * @return a copy of this object with the field set, never null | |
| 732 | * @throws IllegalArgumentException if the value is invalid | |
| 733 | */ | |
| 734 | public YearMonth withYear(int year) { | |
| 735 | int[] newValues = getValues(); | |
| 736 | newValues = getChronology().year().set(this, YEAR, newValues, year); | |
| 737 |
1
1. withYear : mutated return of Object value for org/joda/time/YearMonth::withYear to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(this, newValues); |
| 738 | } | |
| 739 | ||
| 740 | /** | |
| 741 | * Returns a copy of this year-month with the month of year field updated. | |
| 742 | *
 | |
| 743 | * YearMonth is immutable, so there are no set methods. | |
| 744 | * Instead, this method returns a new instance with the value of | |
| 745 | * month of year changed. | |
| 746 | * | |
| 747 | * @param monthOfYear the month of year to set | |
| 748 | * @return a copy of this object with the field set, never null | |
| 749 | * @throws IllegalArgumentException if the value is invalid | |
| 750 | */ | |
| 751 | public YearMonth withMonthOfYear(int monthOfYear) { | |
| 752 | int[] newValues = getValues(); | |
| 753 | newValues = getChronology().monthOfYear().set(this, MONTH_OF_YEAR, newValues, monthOfYear); | |
| 754 |
1
1. withMonthOfYear : mutated return of Object value for org/joda/time/YearMonth::withMonthOfYear to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(this, newValues); |
| 755 | } | |
| 756 | ||
| 757 | //----------------------------------------------------------------------- | |
| 758 | /** | |
| 759 | * Gets the property object for the specified type, which contains | |
| 760 | * many useful methods. | |
| 761 | * | |
| 762 | * @param type the field type to get the property for | |
| 763 | * @return the property object | |
| 764 | * @throws IllegalArgumentException if the field is null or unsupported | |
| 765 | */ | |
| 766 | public Property property(DateTimeFieldType type) { | |
| 767 |
1
1. property : mutated return of Object value for org/joda/time/YearMonth::property to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new Property(this, indexOfSupported(type)); |
| 768 | } | |
| 769 | ||
| 770 | //----------------------------------------------------------------------- | |
| 771 | /** | |
| 772 | * Get the year field property which provides access to advanced functionality. | |
| 773 | * | |
| 774 | * @return the year property | |
| 775 | */ | |
| 776 | public Property year() { | |
| 777 |
1
1. year : mutated return of Object value for org/joda/time/YearMonth::year to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new Property(this, YEAR); |
| 778 | } | |
| 779 | ||
| 780 | /** | |
| 781 | * Get the month of year field property which provides access to advanced functionality. | |
| 782 | * | |
| 783 | * @return the month of year property | |
| 784 | */ | |
| 785 | public Property monthOfYear() { | |
| 786 |
1
1. monthOfYear : mutated return of Object value for org/joda/time/YearMonth::monthOfYear to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new Property(this, MONTH_OF_YEAR); |
| 787 | } | |
| 788 | ||
| 789 | //----------------------------------------------------------------------- | |
| 790 | /** | |
| 791 | * Output the year-month in ISO8601 format (yyyy-MM). | |
| 792 | * | |
| 793 | * @return ISO8601 time formatted string. | |
| 794 | */ | |
| 795 | @ToString | |
| 796 | public String toString() { | |
| 797 |
1
1. toString : mutated return of Object value for org/joda/time/YearMonth::toString to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return ISODateTimeFormat.yearMonth().print(this); |
| 798 | } | |
| 799 | ||
| 800 | /** | |
| 801 | * Output the year-month using the specified format pattern. | |
| 802 | * | |
| 803 | * @param pattern the pattern specification, null means use toString | |
| 804 | * @see org.joda.time.format.DateTimeFormat | |
| 805 | */ | |
| 806 | public String toString(String pattern) { | |
| 807 |
1
1. toString : negated conditional → NO_COVERAGE |
if (pattern == null) { |
| 808 |
1
1. toString : mutated return of Object value for org/joda/time/YearMonth::toString to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return toString(); |
| 809 | } | |
| 810 |
1
1. toString : mutated return of Object value for org/joda/time/YearMonth::toString to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return DateTimeFormat.forPattern(pattern).print(this); |
| 811 | } | |
| 812 | ||
| 813 | /** | |
| 814 | * Output the year-month using the specified format pattern. | |
| 815 | * | |
| 816 | * @param pattern the pattern specification, null means use toString | |
| 817 | * @param locale Locale to use, null means default | |
| 818 | * @see org.joda.time.format.DateTimeFormat | |
| 819 | */ | |
| 820 | public String toString(String pattern, Locale locale) throws IllegalArgumentException { | |
| 821 |
1
1. toString : negated conditional → NO_COVERAGE |
if (pattern == null) { |
| 822 |
1
1. toString : mutated return of Object value for org/joda/time/YearMonth::toString to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return toString(); |
| 823 | } | |
| 824 |
1
1. toString : mutated return of Object value for org/joda/time/YearMonth::toString to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return DateTimeFormat.forPattern(pattern).withLocale(locale).print(this); |
| 825 | } | |
| 826 | ||
| 827 | //----------------------------------------------------------------------- | |
| 828 | /** | |
| 829 | * The property class for YearMonth. | |
| 830 | *
 | |
| 831 | * This class binds a YearMonth to a DateTimeField. | |
| 832 | * | |
| 833 | * @author Stephen Colebourne | |
| 834 | * @since 2.0 | |
| 835 | */ | |
| 836 | public static class Property extends AbstractPartialFieldProperty implements Serializable { | |
| 837 | ||
| 838 | /** Serialization version */ | |
| 839 | private static final long serialVersionUID =<PHONE_NUMBER>190224363L; | |
| 840 | ||
| 841 | /** The partial */ | |
| 842 | private final YearMonth iBase; | |
| 843 | /** The field index */ | |
| 844 | private final int iFieldIndex; | |
| 845 | ||
| 846 | /** | |
| 847 | * Constructs a property. | |
| 848 | * | |
| 849 | * @param partial the partial instance | |
| 850 | * @param fieldIndex the index in the partial | |
| 851 | */ | |
| 852 | Property(YearMonth partial, int fieldIndex) { | |
| 853 | super(); | |
| 854 | iBase = partial; | |
| 855 | iFieldIndex = fieldIndex; | |
| 856 | } | |
| 857 | ||
| 858 | /** | |
| 859 | * Gets the field that this property uses. | |
| 860 | * | |
| 861 | * @return the field | |
| 862 | */ | |
| 863 | public DateTimeField getField() { | |
| 864 |
1
1. getField : mutated return of Object value for org/joda/time/YearMonth$Property::getField to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return iBase.getField(iFieldIndex); |
| 865 | } | |
| 866 | ||
| 867 | /** | |
| 868 | * Gets the partial that this property belongs to. | |
| 869 | * | |
| 870 | * @return the partial | |
| 871 | */ | |
| 872 | protected ReadablePartial getReadablePartial() { | |
| 873 |
1
1. getReadablePartial : mutated return of Object value for org/joda/time/YearMonth$Property::getReadablePartial to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return iBase; |
| 874 | } | |
| 875 | ||
| 876 | /** | |
| 877 | * Gets the partial that this property belongs to. | |
| 878 | * | |
| 879 | * @return the partial | |
| 880 | */ | |
| 881 | public YearMonth getYearMonth() { | |
| 882 |
1
1. getYearMonth : mutated return of Object value for org/joda/time/YearMonth$Property::getYearMonth to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return iBase; |
| 883 | } | |
| 884 | ||
| 885 | /** | |
| 886 | * Gets the value of this field. | |
| 887 | * | |
| 888 | * @return the field value | |
| 889 | */ | |
| 890 | public int get() { | |
| 891 |
1
1. get : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return iBase.getValue(iFieldIndex); |
| 892 | } | |
| 893 | ||
| 894 | //----------------------------------------------------------------------- | |
| 895 | /** | |
| 896 | * Adds to the value of this field in a copy of this YearMonth. | |
| 897 | *
 | |
| 898 | * The value will be added to this field. If the value is too large to be | |
| 899 | * added solely to this field then it will affect larger fields. | |
| 900 | * Smaller fields are unaffected. | |
| 901 | *
 | |
| 902 | * If the result would be too large, beyond the maximum year, then an | |
| 903 | * IllegalArgumentException is thrown. | |
| 904 | *
 | |
| 905 | * The YearMonth attached to this property is unchanged by this call. | |
| 906 | * Instead, a new instance is returned. | |
| 907 | * | |
| 908 | * @param valueToAdd the value to add to the field in the copy | |
| 909 | * @return a copy of the YearMonth with the field value changed | |
| 910 | * @throws IllegalArgumentException if the value isn't valid | |
| 911 | */ | |
| 912 | public YearMonth addToCopy(int valueToAdd) { | |
| 913 | int[] newValues = iBase.getValues(); | |
| 914 | newValues = getField().add(iBase, iFieldIndex, newValues, valueToAdd); | |
| 915 |
1
1. addToCopy : mutated return of Object value for org/joda/time/YearMonth$Property::addToCopy to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(iBase, newValues); |
| 916 | } | |
| 917 | ||
| 918 | /** | |
| 919 | * Adds to the value of this field in a copy of this YearMonth wrapping | |
| 920 | * within this field if the maximum value is reached. | |
| 921 | *
 | |
| 922 | * The value will be added to this field. If the value is too large to be | |
| 923 | * added solely to this field then it wraps within this field. | |
| 924 | * Other fields are unaffected. | |
| 925 | *
 | |
| 926 | * For example, | |
| 927 | * 2004-12 addWrapField one month returns 2004-01. | |
| 928 | *
 | |
| 929 | * The YearMonth attached to this property is unchanged by this call. | |
| 930 | * Instead, a new instance is returned. | |
| 931 | * | |
| 932 | * @param valueToAdd the value to add to the field in the copy | |
| 933 | * @return a copy of the YearMonth with the field value changed | |
| 934 | * @throws IllegalArgumentException if the value isn't valid | |
| 935 | */ | |
| 936 | public YearMonth addWrapFieldToCopy(int valueToAdd) { | |
| 937 | int[] newValues = iBase.getValues(); | |
| 938 | newValues = getField().addWrapField(iBase, iFieldIndex, newValues, valueToAdd); | |
| 939 |
1
1. addWrapFieldToCopy : mutated return of Object value for org/joda/time/YearMonth$Property::addWrapFieldToCopy to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(iBase, newValues); |
| 940 | } | |
| 941 | ||
| 942 | //----------------------------------------------------------------------- | |
| 943 | /** | |
| 944 | * Sets this field in a copy of the YearMonth. | |
| 945 | *
 | |
| 946 | * The YearMonth attached to this property is unchanged by this call. | |
| 947 | * Instead, a new instance is returned. | |
| 948 | * | |
| 949 | * @param value the value to set the field in the copy to | |
| 950 | * @return a copy of the YearMonth with the field value changed | |
| 951 | * @throws IllegalArgumentException if the value isn't valid | |
| 952 | */ | |
| 953 | public YearMonth setCopy(int value) { | |
| 954 | int[] newValues = iBase.getValues(); | |
| 955 | newValues = getField().set(iBase, iFieldIndex, newValues, value); | |
| 956 |
1
1. setCopy : mutated return of Object value for org/joda/time/YearMonth$Property::setCopy to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(iBase, newValues); |
| 957 | } | |
| 958 | ||
| 959 | /** | |
| 960 | * Sets this field in a copy of the YearMonth to a parsed text value. | |
| 961 | *
 | |
| 962 | * The YearMonth attached to this property is unchanged by this call. | |
| 963 | * Instead, a new instance is returned. | |
| 964 | * | |
| 965 | * @param text the text value to set | |
| 966 | * @param locale optional locale to use for selecting a text symbol | |
| 967 | * @return a copy of the YearMonth with the field value changed | |
| 968 | * @throws IllegalArgumentException if the text value isn't valid | |
| 969 | */ | |
| 970 | public YearMonth setCopy(String text, Locale locale) { | |
| 971 | int[] newValues = iBase.getValues(); | |
| 972 | newValues = getField().set(iBase, iFieldIndex, newValues, text, locale); | |
| 973 |
1
1. setCopy : mutated return of Object value for org/joda/time/YearMonth$Property::setCopy to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new YearMonth(iBase, newValues); |
| 974 | } | |
| 975 | ||
| 976 | /** | |
| 977 | * Sets this field in a copy of the YearMonth to a parsed text value. | |
| 978 | *
 | |
| 979 | * The YearMonth attached to this property is unchanged by this call. | |
| 980 | * Instead, a new instance is returned. | |
| 981 | * | |
| 982 | * @param text the text value to set | |
| 983 | * @return a copy of the YearMonth with the field value changed | |
| 984 | * @throws IllegalArgumentException if the text value isn't valid | |
| 985 | */ | |
| 986 | public YearMonth setCopy(String text) { | |
| 987 |
1
1. setCopy : mutated return of Object value for org/joda/time/YearMonth$Property::setCopy to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return setCopy(text, null); |
| 988 | } | |
| 989 | } | |
| 990 | ||
| 991 | } | |
Mutations | ||
| 95 |
1.1 |
|
| 108 |
1.1 |
|
| 111 |
1.1 |
|
| 124 |
1.1 |
|
| 127 |
1.1 |
|
| 141 |
1.1 |
|
| 153 |
1.1 |
|
| 174 |
1.1 |
|
| 177 |
1.1 2.2 |
|
| 195 |
1.1 |
|
| 198 |
1.1 2.2 3.3 |
|
| 372 |
1.1 |
|
| 373 |
1.1 |
|
| 375 |
1.1 |
|
| 387 |
1.1 |
|
| 402 |
1.1 |
|
| 404 |
1.1 |
|
| 418 |
1.1 |
|
| 429 |
1.1 |
|
| 450 |
1.1 |
|
| 451 |
1.1 |
|
| 454 |
1.1 |
|
| 455 |
1.1 |
|
| 479 |
1.1 |
|
| 480 |
1.1 |
|
| 484 |
1.1 |
|
| 507 |
1.1 |
|
| 508 |
1.1 |
|
| 512 |
1.1 |
|
| 532 |
1.1 2.2 |
|
| 533 |
1.1 |
|
| 536 |
1.1 2.2 3.3 |
|
| 539 |
1.1 2.2 |
|
| 544 |
1.1 |
|
| 562 |
1.1 |
|
| 582 |
1.1 |
|
| 601 |
1.1 |
|
| 619 |
1.1 |
|
| 639 |
1.1 |
|
| 658 |
1.1 |
|
| 669 |
1.1 |
|
| 683 |
1.1 |
|
| 700 |
1.1 |
|
| 710 |
1.1 |
|
| 719 |
1.1 |
|
| 737 |
1.1 |
|
| 754 |
1.1 |
|
| 767 |
1.1 |
|
| 777 |
1.1 |
|
| 786 |
1.1 |
|
| 797 |
1.1 |
|
| 807 |
1.1 |
|
| 808 |
1.1 |
|
| 810 |
1.1 |
|
| 821 |
1.1 |
|
| 822 |
1.1 |
|
| 824 |
1.1 |
|
| 864 |
1.1 |
|
| 873 |
1.1 |
|
| 882 |
1.1 |
|
| 891 |
1.1 |
|
| 915 |
1.1 |
|
| 939 |
1.1 |
|
| 956 |
1.1 |
|
| 973 |
1.1 |
|
| 987 |
1.1 |


Users API
The Users API provides full access to manage the users which exist on your account.
Action
The following actions are available. Choose from the list below to view full details of how to access them.
-
List all users
/api/v1/users/list
-
Get unit information
/api/v1/users/show
-
Create a new user
/api/v1/users/create
-
Update an existing user
/api/v1/users/update


Harry Kane not happy at England hat-trick vs Montenegro - he should have scored more
Harry Kane scored a hat-trick in back-to-back England matches at Wembley against minnows Montenegro but the Tottenham striker thinks that he should have bagged more
by Andy Dunn, https://www.mirror.co.uk/authors/andy-dunn/Harry Kane probably had a restless night following his exploits at Wembley … and not because he was reliving another England treble.
The captain now has back-to-back Wembley hat-tricks, having claimed the match ball after the 4-0 win over Bulgaria.
But he returned to squad base on Thursday night, believing he should have had more in the rout of Montenegro.
Kane said: “I had a chance in the second half and the keeper saved it just before I came off.
“That is the one I will probably think about more than anything.”
While that gives an insight into Kane’s focus and perfectionism, the England skipper did accept this hat-trick - coming on the occasion of England’s 1000th game - was particularly significant.
He said: “It was a special night and a big occasion for our nation.
“I was itching to get on and score and the boys put a few on a plate for me and I was able to put them away.
“I am always excited to put on a shirt.
Kane now has 31 international goals and only Wayne Rooney (53), Bobby Charlton (49), Gary Lineker (48), Jimmy Greaves (44) and Michael Owen (40) lie ahead of him in the England chart.


Waste management in Symbiosis Campus
DATE: January 30, 2020
EVENT: Waste management in Symbiosis campus.
ORGANIZATION: Symbiosis Centre for Waste Resource Management
LOCATION: SIT
A guest lecture on “Waste Management in Symbiosis Campus” was held on 30th January 2020. The guest lecture has been organized by the department of Civil Engineering (CESS) and V@rSITy-care to provide the students with an opportunity to learn about the techniques of water management in the campus. The guest lecture began with welcome address by the President of CESS, Ashwini Kumar. He introduced and welcomed Dr. Manikprabhu Dhanorkar, to deliver the lecture Dr. Manikprabhu Dhanorkar, Deputy Head, Symbiosis Centre for Waste Resource Management (SCWRM) has been recognized as a 'Member of Expert Committee' for Solid Waste Management by Mumbai Agricultural Produce Market Committee (MAPMC), Mumbai, a Corporate body, constituted by Govt. of Maharashtra. The session was then continued by Dr Manikprabhu Dhanorkar, who began with an introduction about his research centre and aim of SCWRM following which, he shed light on the ways in which one wastes the resources which are available around us or are in nature. He gave various examples as wastage of food on a daily basis and how can we reduce it. He emphasized on the mentality of people before wasting the resources. He introduced us to the waste management system in the Symbiosis campus(Hill base and Hill top).He further gave the details of the Septic tank, the biogas plant which converts the waste into CNG and usage of bio trucks for recycling plastic bottle. The session ended with a hearty thanks and presenting of a memento to Dr Manikprabhu Dhanorkar by Sachin Jha in appreciation for taking the time out to educate the students on Waste Management. He thanked the Management for providing the platform to organize guest lectures on innovative technologies.


Startup Weekend is a 3-day hackaton for people who want to turn startup ideas into successful companies.
In 2012 I was part of the organizing team who brought Startup Weekend to Verona, for the first time ever in the city. Apart from taking care of my share of organizational tasks, I was in charge of the event's visual identity and communication.
Colors & typography
-
#009e18
-
#e6d2b6
-
#fcf2e1
-
#4f5151
Other visuals
Full-page ad for local newspaper
View full-size
Banner 01
Banner 02
Banner 03
Banner 04
Banner 05
Startup Weekend is a 3-day hackaton for people who want to turn startup ideas into successful companies.


BlackOnion WebSocket Client
Data
Time
Disconnect
WebSocket connection URL:
Authorization (optional, uses the header "Sec-WebSocket-Protocol"):
Couldn't connect to the WebSocket server. Please make sure to input a correct URL and have your server running.
Connect


However, their player had tons of unnecessary HW (just kidding ;-)
Anyway, I rationalized the HW a bit and left out a few of the chips they had
on their player. The leftout circuits are then compensated by software.
The 8515, 74HC573 and 65256 SRAM, forms a "standard" block, common for Atmel
and 8051 circuits.
The decoder and D/A converter is controlled via an 400
kbps I2C bus interface, and the MPEG data is streamed from the CPU to the
decoder through the 2 MHz SPI interface.
An I2S bus carries data from the
decoder to the D/A converter.
The LCD display is hooked onto the databus. R/W
and RS is controlled by 2 address lines and the enable line is controlled by an
I/O pin.
What's unique here is the way the IDE interface is connected,
without the use of buffers or latches. Here's how it's controlled (this also to
some extent applies to the LCD) : The external RAM interface on the Atmel CPU
can be enabled/disabled in a register. When the interface is enabled, the RD and
WR signals as well as the data and address bus works "normally". When the
interface is disabled, the port pins (PORTA [D0-8], PORTC [A8-15], RD and WR),
will hold their assigned state from the port registers. Also, the ALE pin will
be disabled.
This, together with the way the ALE pin handles address
latching, means that we can latch an address on A0-A7 by doing a dummy read at
the specified address. We can then disable the RAM interface, and the address
will still be held at A0-A7. But PORTA and PORTC is now available for I/O, and
we now use them as a 16-bit interface to the IDE interface.
more to come


When a {_program} is copied into a virtual {_instrument} for playing, several attributes of the program file are remembered in the instrument:
The program also has a timestamp that indicates when the program data was last modified, and is recorded as part of the program. If a file doesn't exist, it has no timestamp, and loading the file produces a {_scratch_program}. The timestamp of the program in an instrument is set to the present whenever a parameter is changed. When a program is stored, the Bank and Number are changed according to where the program is stored, and the timestamp is written to the file along with its parameters.
The comparison between the timestamp of the program in the instrument and the file corresponding to the Program Number and Bank determines the bottom two bits of the Program Flags attribute, which can have three values:
| 0 | Scratch | The program in the instrument has no timestamp. This means it was loaded from a non-existent file, and no parameters have been modified since, so all parameter have their default values. | |
| 1 | Unmodified | The program in the instrument has a valid timestamp which matches the file it is associated with. This means the program was loaded from (or stored into) the file identified by the Program Number and Bank attributes, and no parameters have been modified since. | |
| 2 | Modified | The program in the instrument has a valid timestamp that doesn't match the file it is associated with. This means that at least one parameter in the program has been modified (or that the program file itself was independently modified). |
Changing a parameter sets these two bits to Modified because it bumps the timestamp on the program in the player to the present, so that it no longer matches the timestamp on the file. Loading a program sets them to Unmodified (or Scratch) because it receives the same timestamp as the file. And storing a modified program sets them to Unmodified because the file is given the same timestamp.
Bit 2 of the Program Flags attribute is set if the program has any text metadata. This is text appended to a program by an external editor to hold additional information about the program. The Digital Chroma preserves this, but never changes it.


Topic summary
Title
{{topic.title}}
Document finalised on
{{topic.vote.createdAt | amDateFormat:'L'}}
|
view final document
Voting ended on
{{topic.vote.endsAt | amDateFormat:'L'}}
|
view vote results
Create a milestone
2ND MILESTONE
{{event.createdAt | amDateFormat: 'LLL'}}
delete
This is what we will do in our second step of our 5-year plan
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an
unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic
typesetting, remaining essentially unchanged.

When Hard-ID is the chosen method of voting, delegation is not allowed.
Step 4: End of voting system
Deadline
{{voteForm.endsAt | amDateFormat:'L'}}
0 days left
Categories:
Poliitika | none add categories
Authors: {{topic.creator.name}}{{topic.creator.name}}
Activity: 0 arguments | 0 social mentions | add hashtag #{{topic.hashtag}}
Arguments
Social mentions


This module contains auxiliary simulation classes and methods along with results processing.
| Function | initialSinrGenerator |
Auxiliary method for SINR generation. This method is used to generate initial UE SINR. Later, during the simulation SINR will have small variations with time. |
| Class | UEgroup |
This class is used to describe traffic profile and requirements of group of UE which the simulation will run for. It is assumed that all UEs shares the same traffic profile and service requirements, and will be served by the same slice. |
| Function | printResults |
This method prints main simulation results on the terminal |
| Function | getKPIs |
This method gets the intra slice kpi from the statistic files |
| Function | getKPIsInter |
This method gets the inter Slice kpi from the statistic files |
| Function | makeTimePlot |
This method makes basic time plots. Labels deppend on which kpi is being plotted. |
| Function | makeIntraSlicePlot |
This method makes and stores any Intra Slice plot |
| Function | makeInterSlicePlot |
This method makes and stores any Inter Slice plot |
| Function | makePlotsIntra |
This method makes all Intra Slice kpi plots |
| Function | makePlotsInter |
This method makes all Inter Slice kpi plots |
Auxiliary method for SINR generation. This method is used to generate initial UE SINR. Later, during the simulation SINR will have small variations with time.
This method prints main simulation results on the terminal
This method gets the intra slice kpi from the statistic files
This method gets the inter Slice kpi from the statistic files
This method makes basic time plots. Labels deppend on which kpi is being plotted.
This method makes and stores any Intra Slice plot
This method makes and stores any Inter Slice plot