| Game Win Condition(s) |
The player gets any of the three final endings,
the lawful ending, the neutral ending (true
ending), the chaotic ending.
|
| Game Lose Condition (s) |
The player dies and fails to beat the game. |
| Other important gameplay objectives |
Depending on which ending the player choses NPCs
can become enemies or allies and the player will
lose the ability to control certain demons.
|
| What the player can do and interact with |
The player can explore, talk to NPCs and
enemies, spend money on enemies and most in game
places, level up human party members and fuse
demons to make stronger ones.
|
| What the game can do and interact with |
The game affects the shops and prices and how
characters change after certain story events.
The game can attack the player using enemies.
|
| Important Game Actors |
Demons, party members, items/equipment. |
| Core Gameplay Situation(s) |
The player chooses to fight or run or talk
during combat.
|
| Primary Gameplay Loop |
The player will spam an attacking action unless
they need a specific item/mechanic to beat the
enemy
|
| Core Gameplay Punishments |
If the player party dies, they will be returned
to the main menu and have to start from their
last save point. If the player doesn’t think
about how to fight the enemy they could end up
losing to a special mechanic that enemy has.
|
| Core Gameplay Rewards |
The player can acquire new demons, money, items
and level up as they play through the game all
depending on how well they play and the choices
they make.
|
|
Game Environment (what kind of environment is
present)
|
The game is mostly a dungeon crawler in first
person with the beginning of the game in the
present and the middle and end in a
post-apocalyptic future that ruined my nuclear
war.
|


White label your website by removing references to the generator in the source code using "Menu > Site > Site Settings".


Inverted Index
File Uploaded
Upload File
Search Index
Clear Search
Choose a Valid Json File
Click the 'Upload' button
Click the 'Create Index' button
To Search Enter your search term(s)
Click the 'Search' button
Word
{{title}}
{{ key }}
Word
{{title}}
{{ key }}


TABLE OF CONTENTS
A. GS1 Related B. GS2 Related POLITY 1. Rajasthan to shield public servants from probes 2. PUCL demands repeal of ordinance on immunity to public servants INTERNATIONAL AFFAIRS/BILATERAL RELATIONS 1. Rex Tillerson to have big regional agenda during India visit HEALTH ISSUES 1. Hungry for publicity C. GS3 Related ECONOMICS 1. Must link all bank accounts with Aadhaar: RBI 2. Govt permits banks to sell more small savings schemes D. GS4 Related E. Prelims Fact F. UPSC Prelims Practice Questions G. UPSC Mains Practice Questions
Nothing here for Today!!!
1. Rajasthan to shield public servants from probes
Context:
- The government in Rajasthan has promulgated an ordinance providing for prior sanction for investigation against public servants, judges and magistrates for acts done “in discharge of official duties”.
- Though the ordinance was promulgated last month and published in the official gazette, it came to light on Friday.
- The State government may initiate a move to convert it into an Act during the Assembly session beginning on October 23.
The Ordinance:
- The ordinance has virtually shielded public servants from police investigations
- It gone a step ahead by restraining the public and the media from disclosing the identity of government officials until the sanction to proceed with the probe is obtained.
- The sanctioning authority may take up to six months for taking a decision.
- While amending Sections 156 and 190 of the Criminal Procedure Code, the ordinance lays down that if the sanctioning authority does not take a decision within six months, the prosecution sanction would be deemed to have been issued.
- Anyone found violating the restriction on printing, publishing or publicising the names, photographs and details of public servants, judges and magistrates for whom the sanction is yet to be granted, will be punished with two years’ imprisonment and fine, according to Section 5 of the ordinance.
The issues with the ordinance:
- According to the opposition this ordinance will protect criminal and corrupt officials.
- It would create a cover for wrongdoing by government officials and encourage others to indulge in corruption.
- But the government has reiterated that the new provisions had been made to protect honest public servants acting in good faith.
2. PUCL demands repeal of ordinance on immunity to public servants
Context:
- Rajasthan has promulgated an ordinance providing for prior sanction for investigation against public servants, judges and magistrates for acts done “in discharge of official duties
In news:
- The People’s Union for Civil Liberties demanded repeal of a controversial ordinance which has made public servants immune against investigation and barred the media from disclosing their names until prior sanction is granted for their prosecution.
- The PUCL has also decided to challenge the ordinance in the Rajasthan High Court.
PUCL remarks on the ordinance passed:
- The ordinance is an attempt to silence the media and prevent the judiciary from exercising its function of setting the criminal law in motion.
- The amendments to the Criminal Procedure Code and Indian Penal Code brought through the ordinance went against the Supreme Court’s ruling in Lalita Kumari’s case, 2014. The judgment had dealt with both cognisable and non-cognisable offences committed by public servants. The apex court’s Constitution Bench had held that an FIR has to be lodged and investigation initiated by the police officer on the complaint about a cognisable offence. In the cases of non-cognisable offences, the investigating officer is empowered to initiate a preliminary enquiry and seek the court’s direction to obtain sanction for prosecution.
- The amendments, were superfluous and unnecessary as Section 197 of Cr.P.C. already provides protection to public servants by making it mandatory for a court to take cognisance against them after getting the government’s sanction. Instead of cognisance, the amendment refers to the word “investigate”.
Category: INTERNATIONAL AFFAIRS/BILATERAL RELATIONS
1. Rex Tillerson to have big regional agenda during India visit
Context:
- Rex Tillerson visit to India.
- The Afghan-Pakistan situation and Indo-Pacific cooperation could eclipse bilateral concerns
In news:
Expected matters to be discussed:
- Regional issues could take precedence over bilateral ones
- Washington’s new South Asia policy with respect to Pakistan and Afghanistan and prospects for more cooperation in the Indo-Pacific.
- The possibility of an India-Pakistan dialogue will be discussed
- Tillerson will also brief his Indian counterparts on the outcome of the Quadrilateral Coordination Group [U.S.-China-Afghanistan-Pakistan] meeting on talks with Taliban that took place in Oman on October 16
- Pending bilateral issues to be discussed: enhancing trade, the U.S.’s pitch to sell India UAV drones, F-16s and F-18s, and the outstanding decisions on the “foundational agreements” in defence.
Context:
- India ranks 100th out of 119 countries on the global hunger index – behind North Korea, Bangladesh, and Iraq but ahead of Pakistan
- The report ranked 119 countries in the developing world, nearly half of which have ‘extremely alarming’, ‘alarming’ or ‘serious’ hunger levels
Key Stats:
- Absolute poverty in India in 2011/12 came out to be around 12 percent, not 23 percent as officially reported (Tendulkar poverty line)
- The difference between 23 and 12 percent is the difference in measurement of consumption measured on a 30-day recall basis for food rather than the more accurate seven-day recall basis
IFPRI’s Hunger Index
- IFPRI hunger index is not a hunger index at all
- It is an index about child mortality, and stunting, and wasting, and undernourishment of children
Addressing hunger:
- A definition of hunger is needed to evaluate policies to alleviate hunger
- The conventional approach is to measure hunger via calorie consumption
- However, the caloric equation (poverty means low consumption of calories) has long been given up as an indicator of hunger, or much else
Problem in India:
- Malnutrition affects stunting and weight and despite having considerably higher per capita income, India has the same IFPRI nutrition (reported as hunger) status as sub-Saharan Africa
- There is a genuine nutrition absorption problem in India
- The most likely cause of this is bad sanitation, a large component of which is open-defecation
- In the Indian environment, access to water and toilets, breastfeeding (to impart immunity in an unhealthy environment), access to sound health advice/treatment, the prevalence of vaccination and availability of vitamin supplements” are indicators of bad health, malnutrition etc.
Strategy to address the issue:
- In 2014, Prime Minister Narendra Modi started the drive to stop open defecation and said that we needed to do so from the ramparts of the Red Fort
- A few years from now, the large role played by toilet construction, and adoption, in increasing nutrition efficacy in India to East Asian levels will be visible
1. Must link all bank accounts with Aadhaar: RBI
Context:
- The government had earlier this year made Aadhaar mandatory for opening bank accounts as well as for any financial transaction, including mutual fund investments.
- Finance Minister Arun Jaitley, in Budget 2017, had mandated seeding of Aadhaar number with Permanent Account Number (PAN) to avoid individuals using multiple PANs to evade taxes.
In News:
- RBI clarification: Millions of bank account holders across the country will have to compulsorily link their accounts to their Aadhaar number by December 31, 2017 under the Prevention of Money-laundering (Maintenance of Records) Second Amendment Rules, 2017 published in the Official Gazette on June 1, 2017.
- The union government has said it would extend until December 31 the deadline to furnish Aadhaar to avail benefits of social welfare schemes.
- Petition before Supreme Court: A petition before the court argues that the directive to link Aadhaar violates the fundamental right to privacy and equates citizens with money launderers.
- World Bank report says the dormancy rate in India is quite high, at 43 per cent.
Prevention of Money-laundering:
- The Prevention of Money Laundering (Maintenance of Records) Rules, 2005, mandated quoting of Aadhaar along with PAN or Form 60 by individuals, companies and partnership firms for all financial transactions of Rs 50,000 or above.
2. Govt permits banks to sell more small savings schemes
In news:
- In order to encourage savings, the government has allowed banks, including top three private sector lenders, to accept deposits under various small savings schemes like National Savings Certificate (NSC), recurring deposits and monthly income plan
- Until now, most of the small savings schemes were sold through post offices
Key Points:
- According to a recent government notification, banks can also sell National Savings Time Deposit Scheme 1981, National Savings (Monthly Income Account) Scheme 1987, National Savings Recurring Deposit Scheme 1981 and NSC VIII issue
- So far, these banks were allowed to receive subscription under Public Provident Fund, Kisan Vikas Patra-2014, Sukanya Samriddhi Account, Senior Citizen Savings Scheme-2004
- On the basis of the decision of the government, interest rates for small savings schemes are to be notified on a quarterly basis since April 1, 2016
- These schemes have a higher interest rate than that offered by banks on normal savings account
- Increased outlets for selling small savings scheme would result in higher mobilization under the scheme
Nothing here for Today!!!
|
Nothing here for Today!!! |
F. Practice Questions for UPSC Prelims Exam
Question 1. How do District Rural Development Agencies (DRDAs) help in the reduction
of rural poverty in India?
- DRDAs act as Panchayati Raj Institutions in certain specified backward regions of the country.
- DRDAs undertake area-specific scientific study of the causes of poverty and malnutrition and prepare detailed remedial measures.
- DRDAs secure inter-sectoral and interdepartmental coordination and cooperation for effective implementation of anti-poverty programmes.
- DRDAs watch over and ensure effective utilization of the funds intended for antipoverty programmes.
Which of the statements given above is/are correct?
- 3 and 4 only
- 1, 2, 3 and 4
- 4 only
- 1, 2 and 3 only
See
Question 2. Zero defect zero effect scheme is associated with which sector
- Agriculture
- MSME (Micro, Small and Medium Enterprises)
- Heavy Industries
- Service sector
See
Question 3. Consider the following statements with reference to The National Company
Law Tribunal
- NCLT is a quasi judicial body
- NCLT is a constitutional organization
- NCLT is a statutory organization.
- The NCLT was established under the Companies Act 2013.
Choose the correct statement
- 1 only
- 1, 3 and 4 only
- 1, 2 and 4 only
- None of the above
Question 4. Shanghai cooperation organization (SCO) is headquartered in which city?
- Shanghai
- Beijing
- Xinxiang
- Kabul
Question 5. Identify the correct statement
- Raja Ampat is known for one of the world’s most biodiverse marine habitats.
- Raja Ampat lies in eastern part of Indonesian group of archipelago.
Choose the correct statement
- Only a
- Only b
- Both a and b
- Neither a nor b
G. UPSC Mains Practice Questions
GS Paper I
- How do the Indian debates on Secularism differ from the debates in the West?
GS Paper II
- Why does Constitution of India provide different forms of Oaths for the President, the Ministers, the legislators and the member of the judiciary? Discuss their significance.
Also, check previous Daily News Analysis
“Proper Current Affairs preparation is the key to success in the UPSC- Civil Services Examination. We have now launched a comprehensive ‘Current Affairs Webinar’. Limited seats available. Click here to Know More.”
Enroll for India’s Largest All-India Test Series


Sentosa is an island resort off the southern coast of Singapore, connected to the city by road, cable car, pedestrian boardwalk and monorail. As an iconic leisure destination, Sentosa had the pleasure of welcoming 19.5 million guests last year. With that many guests, having a strong operations team would come in handy.
As a general rule of thumb, the effort required to streamline operations is only 1/4 that of external activities. What this implies is the need to prioritise operations as it is controllable and results in cost savings that can be quite substantial. In the world of service processes (like an island resort), it also results in a positive customer experience.
With any supply or service chain, the ability to predict demand within a given error bound is useful as it will drive decisions throughout. For the case of Sentosa, these predictions are in the form of visitorship, i.e., the number of people visiting the island at different entrances and attractions.
Why is visitorship important?
Visitorships are touch points and touch points present an opportunity to engage and interact with guests. This is an important part of the visitor journey and experience. Having the capability to predict visitorship adds on to this experience by being able to ascertain how crowds will form. With that, we can:
-
mobilise customer service ambassadors to redirect guests to less crowded entrances or attractions (aiding with operational efficiency)
-
inform guests of crowded areas so they can plan their itinerary better (contributing to the guest experience)
Interestingly, depending on the time of year, guest satisfaction is both proportional and inversely proportional to crowdedness, i.e., it has a time-variant property.
Are crowds forming?
We built QSenseTM to predict and simulate crowd movement. For Sentosa, it provides insights into when and where crowds will form across several entrances and attractions.
The figure below shows predicted hourly crowd levels at the following entrances:
-
gantry
-
Sentosa Express at Vivocity
-
the cable car
and the following attractions:
-
Tiger Sky Tower
-
Skyline Luge
-
Butterfly Park and
-
Wings of Time.
Indicators for crowd levels are:
On to Part 2 of 3.


Toggle navigation
Get Started
IDE
Development
Platforms
Frameworks
Boards / MCUs
Continuous Integration
IDE Integration
Libraries
Docs
Community
Plus


{% extends 'website/base.html' %}
{% block title %}Media Notice - ECSS{% endblock title %}
{% block content %}
Please note that photography and filming might be taking place at our events. The photographs/film might be published on our website, social media and other promotional materials. You have the option of coming to our events but opting out of being photographed/filmed. If you do not wish to appear in any images captured please notify us before the events or talk to us at the events. If you do not wish us to use any of your images anymore, please contact us. However, be aware that it might not always be possible to recall documents in which your images already appeared.Media Notice


NOTE: This test does upload,
but the server scripts are renamed to tests/UploadFile.php.disabled
and
tests/cLOG.php.disabled
to prevent security attacks on hosted servers.
You should rename these files (removing .disabled
) in your local copy to conduct tests.
The Flash feature will use a SWF to upload in non-HTML5 browsers. All other browsers will use the HTML5 plugin,
unless force="flash"
is used, then Flash will be used in all browsers. force="flash"
is provided because Flash has some features that HTML5 does not yet have. But it is still not
recommended because of the many problems that Firefox and Webkit have with the Flash plugin.
When HTML5 feature is in use, drag & drop of files to the fieldset is supported.


'Go!' (1999)
A movie review by Walter Frith
<EMAIL_ADDRESS>Member of the 'Online Film Critics Society' http://www.ofcs.org
How many of you have attended a high school or college production of a famous piece or work previously produced or published by some other form of medium? Perhaps you attended your children's Shakespearean productions when they were in high school, or even grade school. Did you like an amateur production of 'Julius Caesar' or 'Hamlet' better than renderings by Marlon Brando or the great Lord Laurence Olivier? I hope not. 'Go!' looks and feels like an amateur production of 'Pulp Fiction'. I assume that for all of you who are sports fans, that you also like the major leagues rather than the minors. Now, it's true that filmmakers, musicians and artists draw influences from others who lived before them or put out stupendous work in their lifetime based on advice from others who have worked along similar lines, but there is a huge difference between drawing a variation of someone's work in contrast to deliberately ripping it off. Further illustrating this point is that critics everywhere are comparing 'Go!' to Quentin Tarantino's 1994 masterpiece 'Pulp Fiction' which probably has some of the most memorable dialogue and repeated quotations since 1942's 'Casablanca'. It certainly ranks up there with any memorable film script you can think of.
Set in Los Angeles like 'Pulp Fiction' was (do they have to be that obvious about it?) 'Go!' basically centres itself around four major characters. There is Ronna (Sarah Polley), a supermarket clerk who hates her job. She works long hours for little pay and is facing eviction if she can't pay her rent. She has a plan to deal some drugs on the side and winds up double crossing a drug dealer after losing her stash which could cost her her life. There is Simon (Desmond Askew), who embarks on a trip to Las Vegas with three friends and upon doing so they get mixed up with dancing girls, prostitutes and a nasty bouncer and his criminal father. There are Zack and Adam (Jay Mohr and Scott Wolf). They are facing criminal charges unless they can help the police nab a suspect in which case the charges against them will be dropped. Other notable members of the cast Timothy Olyphant as Todd, the drug dealer involved in Ronna's life. Taye Diggs as Marcus, Simon's main companion on the trip to Vegas and a cop named Burke (William Fichtner) breathing down Zack and Adam's neck. All of these stories take place in conjunction with one another just like 'Pulp Fiction'.
In fairness, as I've said many times, a film should be judged on its own merit but there are exceptions to the rule. You can't help but compare 'Go!' to 'Pulp Fiction'. What I really didn't like about 'Go!' was the fact that while creating such a stark and obvious film, there is no development on making the characters likable. Many of the characters in 'Pulp Fiction' were likable even though they were scum bags. Tarantino had an uncanny way of transmitting his vision to make it not only memorable but also separated the good guys from the bad guys even though these were all wretched people. You basically want to dismiss almost every character in 'Go!' as not likable and the film gives you no one to root for.
The film is directed by Doug Liman who did 'Swingers' in 1996 and 'Getting In' in 1994. His style looks and feels a lot of Steven Soderbergh, George Armitage and David Fincher. Directors whose styles are better suited to a technical job rather than as the man calling the shots on the set of a movie in a very shallow and protracted manner. It also seemed pretty clear that 'Go!' was trying to act as valid social commentary as well as entertainment. It succeeds somewhat in doing so and the performances in the film are good but the rest of the film and its attempt to put forward an original idea just isn't there and the film comes off as aloof and totally forgettable.
OUT OF 5 > * *
Visit FILM FOLLOW-UP by Walter Frith http://www.cgocable.net/~wfrith/movies.htm
* * * * * - a must see * * * * 1/2 - don't miss it * * * * - an excellent film * * * 1/2 - a marginal recommendation * * * - can't quite recommend it * * 1/2 - don't recommend it * * - avoid it * 1/2 - avoid it seriously * - avoid it AT ALL COSTS 1/2 - see it at your own risk zero - may be hazardous to your health
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- date: 2011-08-31T00:00:00Z published: true title: Anti-nuclear policies leave Germany scrambling for power | And it's only going to get worse. url: /2011/08/31/anti-nuclear-policies-leave-germany-scrambling-for-power-and-it-s-only-going-to-get-worse-/ ---
Germany was all in a lather to shut down its nuclear reactors after the disaster at Fukushima panicked the country’s leaders.
What if a similar tsunami and earthquake hit Germany? Nevermind that Germany, unlike Japan, isn’t located on an ocean coastline prone to tsunamis. The point was to make a public show of devotion to alternatives (even if that might mean coal), and please Euro envirozealots.
So Berlin declared that it would shut down eight of its 17 reactors immediately, and the rest within a decade or so. Great celebration. Hurray for the far-seeing legislators and their deep appreciation of environmental concerns.
Except now Europe’s economic powerhouse is worried about brownouts, and is busily importing energy from countries with working rectors and pollution-spewing coal plants.


The form below contains three radio buttons. The first option is checked by default, and the last option is disabled:
The form below contains three inline radio buttons. The first option is checked by default, and the last option is disabled:


{% extends "cyano/base.html" %} {% comment %} Cyanodesign index page Copyright (c) 2013 Gabriel Kind Hochschule Mittweida, University of Applied Sciences Released under the MIT license {% endcomment %} {% load static %} {% load staticfiles %} {% load templatetags %} {% load filters %} {% load crispy_forms_tags %} {% block head_title %}{{ block.super }} :: CyanoDesign{% endblock %} {% block page_title %}CyanoDesign – {{ name }}{% endblock %} {% block head %} {{ block.super }} {% endblock %} {% block extrastyles %} span.cyano-external-metabolite { color: green } #cyano-metabolite-list tr td:first-child, #cyano-enzyme-list tr td:first-child { font-weight: bold; } .hoverable, #cyano-metabolite-list .cyano-enzyme, #cyano-metabolite-list tr td:first-child, #cyano-enzyme-list tr td:first-child, #cyano-enzyme-list .cyano-metabolite, svg g.node, svg text { cursor: pointer; } .hoverable:hover, #cyano-metabolite-list .cyano-enzyme:hover, #cyano-metabolite-list tr td:first-child:hover, #cyano-enzyme-list tr.odd td:first-child:hover, #cyano-enzyme-list tr.even td:first-child:hover, #cyano-enzyme-list .cyano-metabolite:hover { color: blue; } .cyano-enzyme-disabled { color: grey; } #submit-form { display: none; } .tab-content { margin-top: 5px; margin-bottom: 5px; } {% endblock %} {% block content %} {% if not request.user.is_authenticated %} Info:You are not logged in. Making permanent changes to models or uploading new ones is disabled. {% endif %} {% if revision %} Viewing old model from {{ revision.date }}. Simulating and saving will be based on this old version of the model. {% endif %} Reactions Metabolites Settings Simulation Name Reaction Constraint Active Create new reaction Create new metabolite Name Consumed by Produced by Is External Create new reaction Create new metabolite Delete unused metabolites Main objective Maximize objective Minimize objective The main objective is always displayed in the simulation. Display reactions with highest flux connected to the objective Display selected reactions Select visible reactions Run simulation Export As flux list As image As vector graphic × Edit Reaction Name Pathway Substrates Products Enabled Reversible Constrained Min Max × Create Metabolite Name External × Edit Metabolite The metabolite is modified in all reactions. Name External × Delete Do you really want to delete reaction ? Delete unused metabolites × Delete unused metabolites Do you really want to delete all unused metabolites? {% crispy save_form %} {% crispy saveas_form %} {% if request.user.is_authenticated %} {% endif %} {% csrf_token %} {% endblock %}
The metabolite is modified in all reactions.


Lesson overview
- Using CSS to assign color
- Different ways of assigning color
The color & background-color properties
- The color property allows you to specify the color of text inside an element.
- The background-color property sets the color of the background for the element box.
- You can specify any color in CSS in one of three ways:
- rgb values
- These express colors in terms of how much red, green and blue are used to make it up. For example: rgb(100,100,90)
- hex codes
- These are six-digit codes that represent the amount of red, green and blue in a color, preceded by a pound or hash # sign. For example: #ee3e80
- color names
/* rgb value */
p {
color: rgb(100,100,90);
}
/* hex code */
h2 {
color: #ee3e80;
}
/* color name */
h1 {
color: DarkCyan;
}
The opacity & rgba properties
- CSS3 introduces the opacity property which allows you to specify the opacity of an element and any of its child elements.
- The value is a number between 0.0 and 1.0 (so a value of 0.5 is 50% opacity and 0.15 is 15% opacity).
- The CSS3 rgba allows you to specify a color, just like you would with an RGB value, but adds a fourth value to indicate opacity.
/* rgba value */
p {
color: rgba(100,100,90,0.5);
}
CSS3: HSL & HSLA Colors
- CSS3 introduces an entirely new and intuitive way to specify colors using hue, saturation, and lightness values.
- HSL - Hue, Saturation, Lightness
body {
background-color: #C8C8C8;
background-color: hsl(0,0%,78%);
}
p {
background-color: #ffffff;
background-color: hsla(0,100%,100%,0.5);
}


China says ‘firmly supports’ Hong Kong police after US criticises shooting of protester
HONG KONG: China issued its "firm support" for Hong Kong's police on Tuesday (Nov 12), a day after a local officer shot a protester at close range and a man was doused with petrol as chaotic and violent clashes spread across the former British colony.
Protesters are angry about what they see as police brutality and meddling by Beijing in the freedoms guaranteed under the "one country, two systems" formula put in place when the territory returned to China in 1997.
Speaking at a regular news conference in Beijing, Chinese foreign ministry spokesman Geng Shuang defended the actions of the Hong Kong police officer involved in the shooting on Monday and urged officials in the US and the UK not to interfere in China's affairs.
READ: US condemns latest Hong Kong violence, UK says escalation 'deeply disturbing'
READ: Timeline - Fresh violence erupts in Hong Kong on Tuesday
"No matter which country you are in, seizing a police officer's gun, attacking a police officer who is on duty, threatening the life and safety of an on duty police officer, is certainly not allowed and will definitely be forcefully countered by the local police.
"I would like to ask officials in the US or the UK, if such a case were to occur in their countries how would their police deal with it?"
The United States on Monday had condemned "unjustified use of deadly force" in Hong Kong, and urged police and civilians alike to de-escalate the situation.
The Hong Kong Police Force also addressed the shooting incident on Tuesday as it described how the city's rule of law had reached "the brink of total collapse".
Senior superintendent of organised crime and triad bureau Li Kwai-wah said the officer in question had been confronted by a group of people.
READ: Hong Kong spirals into rare working-hour violence as police shoot protester
READ: Chinese state media praises Hong Kong police 'restraint'
"As we gathered the statement from the man who was injured (by gun shot), we found out that our colleague did not only face threat from one person, instead it was a group of people with organised plan attempting to steal the gun.
"In a situation like this, we believe our police is reacting according to the guideline, to protect themselves as well as the people around them,” he said.
Regarding the burning of a man in Ma On Shan on Monday, senior superintendent of police public relations Kong Wing-Cheungsaid the incident was yet another example of rioters using “random and indiscriminate violence” against innocent people.
READ: Hong Kong leader says protesters 'paralysing' the city are selfish
READ: Key dates in Hong Kong's anti-government protests
“The victim got into a dispute with rioters over (different) political wills and was then beaten up brutally.
He added that the victim was now in "critical condition" after suffering severe burns to his head and upper body. The case has been classified as attempted murder.
READ: Hong Kong police watchdog unequipped to probe protest response: Experts
READ: Hong Kong falls into first recession in 10 years as protests, trade war weigh
A flash mob of more than 1,000 Hong Kong protesters rallied in the city’s central business district for a second day on Tuesday, prompting the police to fire volleys of tear gas and arrest more than a dozen people.
Police also fired tear gas at City University in Kowloon Tong, beneath the Lion Rock, and at Chinese University on the other side of the mountain, where protesters threw petrol bombs and bricks at police.
MORE: Our coverage of the Hong Kong protests
Follow us on Telegram for the latest on Hong Kong: https://cna.asia/telegram


Provides somewhat high-level interfaces to specific commands sent over a FLAP connection, as well as a default FLAP command factory to convert raw FLAP packets to
FlapCommand
s. @see net.kano.joscar.flap


Message in confidence
Your report is ready to download, Catherine :)
Download report
Need assistance?
If there's anything you need help with or have any general inquiries then contact us on
+612 9700 9707
or send us an
email
.


Contents:
machina.prepro.base.
BasePrePro
Bases: object
object
Preprocess for observations.
prepro
Applying preprocess to observations.
prepro_with_update
Applying preprocess to observations with update.
update_ob_rms
Updating running mean and running variance.


I am a Third Year ECE Undergrad at NSIT (Expected grad. year 2022).
I have worked on various machine learning algorithms ranging from linear regression to CNN and RNN
Chekout my projects :-
I enjoy solving algorithm problems. I have been into competitive programming for a while.
Just drop a "hi" and you're good to go!
CONTACT ME


Verify Payload Checksum with Streaming Reader
Contents
Sometimes you may find yourself working with an API that gives you the opportunity to validate the integrity of a payload provided through a checksum. There are a few different ways that you could go about validating the integrity of the payload.
The library and exact method of computing the checksum may differ based on your use case, but the resulting logic most likely will be similar to the examples here. For these examples we’ll use Go’s hash/crc32 package with the common polynomial IEEE.
Preprocess payload validation
One way to do this would be to read the full payload into memory. Then before consuming the payload, your application would compute the checksum of the payload and compare it against the expected value. Once the payload is validated your application would be free to process the payload.
The following example validates the payload checksum after it has been read into memory.
// import "fmt"
// import "hash/crc32"
// import "io/ioutil"
payload, err := ioutil.ReadAll(reader)
actual := crc32.ChecksumIEEE(payload)
if expect != actual {
return fmt.Errorf("expect %08X checksum, got %08X", expect, actual)
}
This approach has the benefit of validating the integrity of the payload before it is consumed. But comes with the downside that if the payload is too large, this approach could put significant pressure on the application’s memory.
Stream payload validation
Instead of requiring the payload to be read into memory before it can be validated, our application could compute the checksum as the payload is read downstream. This approach will allow our application to operate on the payload as an stream, (i.e. io.Reader) while also compute and validate the checksum. Very little additional memory is needed to compute the checksum this way.
This is a good approach when the upstream processing in transactional and will not operate on the payload until its been fully read. If this is not the case, streaming checksum validation can lead to unexpected errors, because the integrity of the payload cannot be validated until after the entire payload has been read.
The following is an example of wrapping the payload with a type that will
compute the checksum and proxy the Read
method calls.
// import "hash/crc32"
// import "encoding/csv"
wrapped := NewValidateCRC32Reader(expectCRC32, payload)
rows, err := csv.NewReader(wrapped).ReadAll()
In the above example a StreamValidateCRC32
function takes the expected
CRC32 checksum, the payload, and returns the payload wrapped with CRC32
checksum validation. This function wraps the payload with a type that
implements the io.Reader interface. This type will iteratively compute
the checksum of the payload as the downstream consumer reads from it. When
the payload has been fully read, the wrapper will compare the computed
checksum with the expected value. If the values are not equal a relevant
error can be returned. Otherwise the wrapper will return io.EOF
when the
payload is valid and has been fully read.
// import "io"
// import "hash/crc32"
// ValidateCRC32Reader provides a wrapper for an io.Reader that computes a
// running checksum as the wrapped reader is read. When the underlying reader
// returns EOF, the validator will compare the checksums.
type ValidateCRC32Reader struct {
io.Reader
expect uint32
actual uint32
}
// NewValidateCRC32Reader initializes a new ValidateCRC32Reader wrapping the
// reader provided.
func NewValidateCRC32Reader(expect uint32, reader io.Reader) *ValidateCRC32Reader {
return &ValidateCRC32Reader{
expect: expect,
Reader: reader,
}
}
// Read reads from the wrapped reader, and updates the checksum. When the
// wrapped reader returns EOF, the expected checksum will be compared against
// the computed value. If they differ and error will be returned.
func (v *ValidateCRC32Reader) Read(p []byte) (int, error) {
n, err := v.Reader.Read(p)
v.actual = crc32.Update(v.actual, crc32.IEEETable, p[:n])
if err == io.EOF && v.actual != v.expect {
return n, fmt.Errorf("invalid checksum %08X does not match %08X",
v.actual, v.expect)
}
return n, err
}
The ValidateCRC32Reader
type wraps the io.Reader it is initialized
with, and computes the checksum of the wrapped reader as its content is
read. When the wrapped reader returns io.EOF the ValidateCRC32Reader
will return an error if the actual checksum of the content doesn’t match
the expected value.
Checkout the full example On Github


|
Prismic.io PHP kit
3.0.0
|
Public Member Functions | |
| __construct ($main, $views=array()) | |
| asHtml ($linkResolver=null) | |
| asText () | |
| getView ($key) | |
| getMain () | |
| getViews () | |
| getUrl () | |
| getAlt () | |
| getCopyright () | |
| getWidth () | |
| getHeight () | |
| getLink () | |
This class embodies an Image fragment. An image in prismic.io is made of views: a main unnamed one, and optional named ones. Typically, views are different sizes of the same image ("icon", "large", ...), but not necessarily.
| Prismic\Fragment\Image::__construct | ( | $main, | |
$views = array() |
|||
| ) |
Constructs an image fragment.
| \Prismic\Fragment\ImageView | $main | the main view of the image |
| array | $views | the associative array of objects |
| Prismic\Fragment\Image::asHtml | ( | $linkResolver = null | ) |
Builds a HTML version of the Image fragment (using just the main view)
| \Prismic\LinkResolver | $linkResolver | the link resolver |
Implements Prismic\Fragment\FragmentInterface.
| Prismic\Fragment\Image::asText | ( | ) |
Builds a text version of the Image fragment (simply returns its URL)
Implements Prismic\Fragment\FragmentInterface.
| Prismic\Fragment\Image::getAlt | ( | ) |
Returns the alternative text of the main view.
| Prismic\Fragment\Image::getCopyright | ( | ) |
Returns the copyright text of the image view.
| Prismic\Fragment\Image::getHeight | ( | ) |
Returns the height of the image view.
| Prismic\Fragment\Image::getLink | ( | ) |
Returns the link to point to
| Prismic\Fragment\Image::getMain | ( | ) |
Returns the main image view
| Prismic\Fragment\Image::getUrl | ( | ) |
Returns the URL of the main view.
| Prismic\Fragment\Image::getView | ( | $key | ) |
Returns an image view from its name (for instance, "icon", "large", ...)
| string | $key | the name of the view |
| Prismic\Fragment\Image::getViews | ( | ) |
Returns an associative array of all the views for this image but the main one.
| Prismic\Fragment\Image::getWidth | ( | ) |
Returns the width of the image view.


#import <Foundation/Foundation.h>
#import "CPDefinitions.h"
Go to the source code of this file.
Classes | |
| struct | _CPGradientElement |
| A structure representing one node in a linked list of RGBA colors. More... | |
| class | CPGradient |
| Draws color gradient fills. More... | |
Typedefs | |
| typedef struct _CPGradientElement | CPGradientElement |
| A structure representing one node in a linked list of RGBA colors. | |
| typedef enum _CPBlendingMode | CPGradientBlendingMode |
| Enumeration of blending modes. | |
| typedef enum _CPGradientType | CPGradientType |
| Enumeration of gradient types. | |
Enumerations | |
| enum | _CPBlendingMode { CPLinearBlendingMode, CPChromaticBlendingMode, CPInverseChromaticBlendingMode } |
Enumeration of blending modes. More... | |
| enum | _CPGradientType { CPGradientTypeAxial, CPGradientTypeRadial } |
Enumeration of gradient types. More... |
| enum _CPBlendingMode |
| enum _CPGradientType |


Solar Watts Contour Plot
API Documentation
Choose your location to see solar panel wattage outputs at various tilts & azimuths.
Select location...
{{ site.city }}, {{ site.state }}
{{ this.maxEnergy.toLocaleString() }}
annual kWh / DC kW maximum
Loading...
An error occurred. Please try again later.
Hover over the graph to see energy & % efficiency levels for each azimuth/tilt combination


1.2 The Java Virtual Machine
- P-Code machine of UCSD Pascal
- knows nothing of Java programming language , only of a particular binary format, the class file format.
2.1 The class File Format
2.2 Data TYPE - primittve type - need not be tagged - range? - signed? - default value? - two’s complement - reference type - variables: - argument - returned value - jvm expect type checking before prior to run time, by compiler
2.4 Reference Types and Values
There are three kinds of reference types: class types, array types, and interface types. 1 what is type? -> variables ?
2 Person p , Person is Class Type 3 ``` public interface Relatable {
// this (object calling isLargerThan)
// and other must be instances of
// the same class returns 1, 0, -1
// if this is greater than,
// equal to, or less than other
public int isLargerThan(Relatable other); }
```
4 modifier keyword
5 Stack , Heap , Method area
6 Access Modifier: public , protected , default , private
7 static, final, abstract
- static :
- abstract :
-
|| | public | protected | default | private | final | abstract | static | volatile | synchronized |
8 || class | √ | - | √ | - | √ | √ | - |
|| member | √ | √ | - | ✔ | √ | - | √ |
|| method | √ | | | |
|| interface | √ | | | | | |
final : subclass can not inherits from parent class , and can not modify field with final modifier
abstract: Abstract classes may or may not include abstract methods. 1)it cannot be instantiated, but they can be subclassed. 2)abstract method : can not have method body
private : subclass can access parent class 's private member
static:
static method(class method): a method that is invokd without reference to a particular object . class method
Class as whole, not a particular instance of class.
synchronized: A keyword in the Java programming language that, when applied to a method or code block, guarantees that at most one thread at a time executes that code.
9 how compiler control modifier 's access permission? Their values are references to dynamically created class instances, arrays, or class instances or arrays that implement interfaces, respectively.
An array type consists of a component type with a single dimension (whose length is not given by the type). The component type of an array type may itself be an array type. If, starting from any array type, one considers its component type, and then (if that is also an array type) the component type of that type, and so on, eventually one must reach a component type that is not an array type; this is called the element type of the array type. The element type of an array type is necessarily either a primitive type, or a class type, or an interface type. A reference value may also be the special null reference, a reference to no object, which will be denoted here by null. The null reference initially has no run-time type, but may be cast to any type. The default value of a reference type is null. This specification does not mandate a concrete value encoding null.
The Java® Virtual Machine Specification 4.1 The ClassFile Structure
A class file consists of a single ClassFile structure:
ClassFile {
u4 magic;
u2 minor_version;
u2 major_version;
u2 constant_pool_count;
cp_info constant_pool[constant_pool_count-1];
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count;
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];
u2 attributes_count;
attribute_info attributes[attributes_count];
constant_pool_count
- constant_pool table
- Java Virtual Machine instructions
do not rely on run-time layout of classes
- constant_pool entries format:
cp_info {
ul tag; (1 bit indicating the kind of constant.
there are 17 kinds of constant)
u2 info[];
}
- valid index range
- exception: long and double


Columns:
Rows:
Note: Artwork with an odd amount of columns cannot be saved in Binary Text format
Cancel
Resize


6 references to Property
Microsoft.PowerShell.Commands.Utility (6)
commands\utility\Measure-Object.cs (6)
489
if (
Property
== null)
510
foreach (var expression in
Property
)
793
Diagnostics.Assert(
Property
!= null, "no property and no InputObject should have been addressed");
813
if (_totalRecordCount == 0 &&
Property
== null)
821
if (stat.count == 0 &&
Property
!= null)
847
if (
Property
!= null)


public final class LocalDate extends Object implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable
2007-12-03
.
LocalDate
is an immutable date-time object that represents a date,
often viewed as year-month-day. Other date fields, such as day-of-year,
day-of-week and week-of-year, can also be accessed.
For example, the value "2nd October 2007" can be stored in a LocalDate
.
This class does not store or represent a time or time-zone. Instead, it is a description of the date, as used for birthdays. It cannot represent an instant on the time-line without additional information such as an offset or time-zone.
The ISO-8601 calendar system is the modern civil calendar system used today in most of the world. It is equivalent to the proleptic Gregorian calendar system, in which today's rules for leap years are applied for all time. For most applications written today, the ISO-8601 rules are entirely suitable. However, any application that makes use of historical dates, and requires them to be accurate will find the ISO-8601 approach unsuitable.
This is a value-based
class; use of identity-sensitive operations (including reference equality
(==
), identity hash code, or synchronization) on instances of
LocalDate
may have unpredictable results and should be avoided.
The equals
method should be used for comparisons.
| Modifier and Type | Field and Description |
|---|---|
static LocalDate |
MAX
The maximum supported
LocalDate , '+999999999-12-31'. |
static LocalDate |
MIN
The minimum supported
LocalDate , '-999999999-01-01'. |
| Modifier and Type | Method and Description |
|---|---|
Temporal |
adjustInto(Temporal temporal)
Adjusts the specified temporal object to have the same date as this object.
|
LocalDateTime |
atStartOfDay()
Combines this date with the time of midnight to create a
LocalDateTime
at the start of this date. |
ZonedDateTime |
atStartOfDay(ZoneId zone)
Returns a zoned date-time from this date at the earliest valid time according
to the rules in the time-zone.
|
LocalDateTime |
atTime(int hour,
int minute)
Combines this date with a time to create a
LocalDateTime . |
LocalDateTime |
atTime(int hour,
int minute,
int second)
Combines this date with a time to create a
LocalDateTime . |
LocalDateTime |
atTime(int hour,
int minute,
int second,
int nanoOfSecond)
Combines this date with a time to create a
LocalDateTime . |
LocalDateTime |
atTime(LocalTime time)
Combines this date with a time to create a
LocalDateTime . |
OffsetDateTime |
atTime(OffsetTime time)
Combines this date with an offset time to create an
OffsetDateTime . |
int |
compareTo(ChronoLocalDate other)
Compares this date to another date.
|
boolean |
equals(Object obj)
Checks if this date is equal to another date.
|
String |
format(DateTimeFormatter formatter)
Formats this date using the specified formatter.
|
static LocalDate |
from(TemporalAccessor temporal)
Obtains an instance of
LocalDate from a temporal object. |
int |
get(TemporalField field)
Gets the value of the specified field from this date as an
int . |
IsoChronology |
getChronology()
Gets the chronology of this date, which is the ISO calendar system.
|
int |
getDayOfMonth()
Gets the day-of-month field.
|
DayOfWeek |
getDayOfWeek()
Gets the day-of-week field, which is an enum
DayOfWeek . |
int |
getDayOfYear()
Gets the day-of-year field.
|
Era |
getEra()
Gets the era applicable at this date.
|
long |
getLong(TemporalField field)
Gets the value of the specified field from this date as a
long . |
Month |
getMonth()
Gets the month-of-year field using the
Month enum. |
int |
getMonthValue()
Gets the month-of-year field from 1 to 12.
|
int |
getYear()
Gets the year field.
|
int |
hashCode()
A hash code for this date.
|
boolean |
isAfter(ChronoLocalDate other)
Checks if this date is after the specified date.
|
boolean |
isBefore(ChronoLocalDate other)
Checks if this date is before the specified date.
|
boolean |
isEqual(ChronoLocalDate other)
Checks if this date is equal to the specified date.
|
boolean |
isLeapYear()
Checks if the year is a leap year, according to the ISO proleptic
calendar system rules.
|
boolean |
isSupported(TemporalField field)
Checks if the specified field is supported.
|
boolean |
isSupported(TemporalUnit unit)
Checks if the specified unit is supported.
|
int |
lengthOfMonth()
Returns the length of the month represented by this date.
|
int |
lengthOfYear()
Returns the length of the year represented by this date.
|
LocalDate |
minus(long amountToSubtract,
TemporalUnit unit)
Returns a copy of this date with the specified amount subtracted.
|
LocalDate |
minus(TemporalAmount amountToSubtract)
Returns a copy of this date with the specified amount subtracted.
|
LocalDate |
minusDays(long daysToSubtract)
Returns a copy of this
LocalDate with the specified number of days subtracted. |
LocalDate |
minusMonths(long monthsToSubtract)
Returns a copy of this
LocalDate with the specified number of months subtracted. |
LocalDate |
minusWeeks(long weeksToSubtract)
Returns a copy of this
LocalDate with the specified number of weeks subtracted. |
LocalDate |
minusYears(long yearsToSubtract)
Returns a copy of this
LocalDate with the specified number of years subtracted. |
static LocalDate |
now()
Obtains the current date from the system clock in the default time-zone.
|
static LocalDate |
now(Clock clock)
Obtains the current date from the specified clock.
|
static LocalDate |
now(ZoneId zone)
Obtains the current date from the system clock in the specified time-zone.
|
static LocalDate |
of(int year,
int month,
int dayOfMonth)
Obtains an instance of
LocalDate from a year, month and day. |
static LocalDate |
of(int year,
Month month,
int dayOfMonth)
Obtains an instance of
LocalDate from a year, month and day. |
static LocalDate |
ofEpochDay(long epochDay)
Obtains an instance of
LocalDate from the epoch day count. |
static LocalDate |
ofYearDay(int year,
int dayOfYear)
Obtains an instance of
LocalDate from a year and day-of-year. |
static LocalDate |
parse(CharSequence text)
Obtains an instance of
LocalDate from a text string such as 2007-12-03 . |
static LocalDate |
parse(CharSequence text,
DateTimeFormatter formatter)
Obtains an instance of
LocalDate from a text string using a specific formatter. |
LocalDate |
plus(long amountToAdd,
TemporalUnit unit)
Returns a copy of this date with the specified amount added.
|
LocalDate |
plus(TemporalAmount amountToAdd)
Returns a copy of this date with the specified amount added.
|
LocalDate |
plusDays(long daysToAdd)
Returns a copy of this
LocalDate with the specified number of days added. |
LocalDate |
plusMonths(long monthsToAdd)
Returns a copy of this
LocalDate with the specified number of months added. |
LocalDate |
plusWeeks(long weeksToAdd)
Returns a copy of this
LocalDate with the specified number of weeks added. |
LocalDate |
plusYears(long yearsToAdd)
Returns a copy of this
LocalDate with the specified number of years added. |
<R> R |
query(TemporalQuery<R> query)
Queries this date using the specified query.
|
ValueRange |
range(TemporalField field)
Gets the range of valid values for the specified field.
|
long |
toEpochDay()
Converts this date to the Epoch Day.
|
String |
toString()
Outputs this date as a
String , such as 2007-12-03 . |
Period |
until(ChronoLocalDate endDateExclusive)
Calculates the period between this date and another date as a
Period . |
long |
until(Temporal endExclusive,
TemporalUnit unit)
Calculates the amount of time until another date in terms of the specified unit.
|
LocalDate |
with(TemporalAdjuster adjuster)
Returns an adjusted copy of this date.
|
LocalDate |
with(TemporalField field,
long newValue)
Returns a copy of this date with the specified field set to a new value.
|
LocalDate |
withDayOfMonth(int dayOfMonth)
Returns a copy of this
LocalDate with the day-of-month altered. |
LocalDate |
withDayOfYear(int dayOfYear)
Returns a copy of this
LocalDate with the day-of-year altered. |
LocalDate |
withMonth(int month)
Returns a copy of this
LocalDate with the month-of-year altered. |
LocalDate |
withYear(int year)
Returns a copy of this
LocalDate with the year altered. |
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
timeLineOrder
public static final LocalDate MIN
LocalDate
, '-999999999-01-01'.
This could be used by an application as a "far past" date.public static final LocalDate MAX
LocalDate
, '+999999999-12-31'.
This could be used by an application as a "far future" date.public static LocalDate now()
This will query the system clock
in the default
time-zone to obtain the current date.
Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
public static LocalDate now(ZoneId zone)
This will query the system clock
to obtain the current date.
Specifying the time-zone avoids dependence on the default time-zone.
Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
zone
- the zone ID to use, not nullpublic static LocalDate now(Clock clock)
This will query the specified clock to obtain the current date - today.
Using this method allows the use of an alternate clock for testing.
The alternate clock may be introduced using dependency injection
.
clock
- the clock to use, not nullpublic static LocalDate of(int year, Month month, int dayOfMonth)
LocalDate
from a year, month and day.
This returns a LocalDate
with the specified year, month and day-of-month.
The day must be valid for the year and month, otherwise an exception will be thrown.
year
- the year to represent, from MIN_YEAR to MAX_YEARmonth
- the month-of-year to represent, not nulldayOfMonth
- the day-of-month to represent, from 1 to 31DateTimeException
- if the value of any field is out of range,
or if the day-of-month is invalid for the month-yearpublic static LocalDate of(int year, int month, int dayOfMonth)
LocalDate
from a year, month and day.
This returns a LocalDate
with the specified year, month and day-of-month.
The day must be valid for the year and month, otherwise an exception will be thrown.
year
- the year to represent, from MIN_YEAR to MAX_YEARmonth
- the month-of-year to represent, from 1 (January) to 12 (December)dayOfMonth
- the day-of-month to represent, from 1 to 31DateTimeException
- if the value of any field is out of range,
or if the day-of-month is invalid for the month-yearpublic static LocalDate ofYearDay(int year, int dayOfYear)
LocalDate
from a year and day-of-year.
This returns a LocalDate
with the specified year and day-of-year.
The day-of-year must be valid for the year, otherwise an exception will be thrown.
year
- the year to represent, from MIN_YEAR to MAX_YEARdayOfYear
- the day-of-year to represent, from 1 to 366DateTimeException
- if the value of any field is out of range,
or if the day-of-year is invalid for the yearpublic static LocalDate ofEpochDay(long epochDay)
LocalDate
from the epoch day count.
This returns a LocalDate
with the specified epoch-day.
The EPOCH_DAY
is a simple incrementing count
of days where day 0 is 1970-01-01. Negative numbers represent earlier days.
epochDay
- the Epoch Day to convert, based on the epoch 1970-01-01DateTimeException
- if the epoch day exceeds the supported date rangepublic static LocalDate from(TemporalAccessor temporal)
LocalDate
from a temporal object.
This obtains a local date based on the specified temporal.
A TemporalAccessor
represents an arbitrary set of date and time information,
which this factory converts to an instance of LocalDate
.
The conversion uses the TemporalQueries.localDate()
query, which relies
on extracting the EPOCH_DAY
field.
This method matches the signature of the functional interface TemporalQuery
allowing it to be used as a query via method reference, LocalDate::from
.
from
in interface ChronoLocalDate
temporal
- the temporal object to convert, not nullDateTimeException
- if unable to convert to a LocalDate
Chronology.date(TemporalAccessor)
public static LocalDate parse(CharSequence text)
LocalDate
from a text string such as 2007-12-03
.
The string must represent a valid date and is parsed using
DateTimeFormatter.ISO_LOCAL_DATE
.
text
- the text to parse such as "2007-12-03", not nullDateTimeParseException
- if the text cannot be parsedpublic static LocalDate parse(CharSequence text, DateTimeFormatter formatter)
LocalDate
from a text string using a specific formatter.
The text is parsed using the formatter, returning a date.
text
- the text to parse, not nullformatter
- the formatter to use, not nullDateTimeParseException
- if the text cannot be parsedpublic boolean isSupported(TemporalField field)
This checks if this date can be queried for the specified field.
If false, then calling the range
,
get
and with(TemporalField, long)
methods will throw an exception.
If the field is a ChronoField
then the query is implemented here.
The supported fields are:
DAY_OF_WEEK
ALIGNED_DAY_OF_WEEK_IN_MONTH
ALIGNED_DAY_OF_WEEK_IN_YEAR
DAY_OF_MONTH
DAY_OF_YEAR
EPOCH_DAY
ALIGNED_WEEK_OF_MONTH
ALIGNED_WEEK_OF_YEAR
MONTH_OF_YEAR
PROLEPTIC_MONTH
YEAR_OF_ERA
YEAR
ERA
ChronoField
instances will return false.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.isSupportedBy(TemporalAccessor)
passing this
as the argument.
Whether the field is supported is determined by the field.
isSupported
in interface ChronoLocalDate
isSupported
in interface TemporalAccessor
field
- the field to check, null returns falsepublic boolean isSupported(TemporalUnit unit)
This checks if the specified unit can be added to, or subtracted from, this date.
If false, then calling the plus(long, TemporalUnit)
and
minus
methods will throw an exception.
If the unit is a ChronoUnit
then the query is implemented here.
The supported units are:
DAYS
WEEKS
MONTHS
YEARS
DECADES
CENTURIES
MILLENNIA
ERAS
ChronoUnit
instances will return false.
If the unit is not a ChronoUnit
, then the result of this method
is obtained by invoking TemporalUnit.isSupportedBy(Temporal)
passing this
as the argument.
Whether the unit is supported is determined by the unit.
isSupported
in interface ChronoLocalDate
isSupported
in interface Temporal
unit
- the unit to check, null returns falsepublic ValueRange range(TemporalField field)
The range object expresses the minimum and maximum valid values for a field. This date is used to enhance the accuracy of the returned range. If it is not possible to return the range, because the field is not supported or for some other reason, an exception is thrown.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return
appropriate range instances.
All other ChronoField
instances will throw an UnsupportedTemporalTypeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.rangeRefinedBy(TemporalAccessor)
passing this
as the argument.
Whether the range can be obtained is determined by the field.
range
in interface TemporalAccessor
field
- the field to query the range for, not nullDateTimeException
- if the range for the field cannot be obtainedUnsupportedTemporalTypeException
- if the field is not supportedpublic int get(TemporalField field)
int
.
This queries this date for the value of the specified field. The returned value will always be within the valid range of values for the field. If it is not possible to return the value, because the field is not supported or for some other reason, an exception is thrown.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return valid
values based on this date, except EPOCH_DAY
and PROLEPTIC_MONTH
which are too large to fit in an int
and throw a DateTimeException
.
All other ChronoField
instances will throw an UnsupportedTemporalTypeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.getFrom(TemporalAccessor)
passing this
as the argument. Whether the value can be obtained,
and what the value represents, is determined by the field.
get
in interface TemporalAccessor
field
- the field to get, not nullDateTimeException
- if a value for the field cannot be obtained or
the value is outside the range of valid values for the fieldUnsupportedTemporalTypeException
- if the field is not supported or
the range of values exceeds an int
ArithmeticException
- if numeric overflow occurspublic long getLong(TemporalField field)
long
.
This queries this date for the value of the specified field. If it is not possible to return the value, because the field is not supported or for some other reason, an exception is thrown.
If the field is a ChronoField
then the query is implemented here.
The supported fields
will return valid
values based on this date.
All other ChronoField
instances will throw an UnsupportedTemporalTypeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.getFrom(TemporalAccessor)
passing this
as the argument. Whether the value can be obtained,
and what the value represents, is determined by the field.
getLong
in interface TemporalAccessor
field
- the field to get, not nullDateTimeException
- if a value for the field cannot be obtainedUnsupportedTemporalTypeException
- if the field is not supportedArithmeticException
- if numeric overflow occurspublic IsoChronology getChronology()
The Chronology
represents the calendar system in use.
The ISO-8601 calendar system is the modern civil calendar system used today
in most of the world. It is equivalent to the proleptic Gregorian calendar
system, in which today's rules for leap years are applied for all time.
getChronology
in interface ChronoLocalDate
public Era getEra()
The official ISO-8601 standard does not define eras, however IsoChronology
does.
It defines two eras, 'CE' from year one onwards and 'BCE' from year zero backwards.
Since dates before the Julian-Gregorian cutover are not in line with history,
the cutover between 'BCE' and 'CE' is also not aligned with the commonly used
eras, often referred to using 'BC' and 'AD'.
Users of this class should typically ignore this method as it exists primarily
to fulfill the ChronoLocalDate
contract where it is necessary to support
the Japanese calendar system.
The returned era will be a singleton capable of being compared with the constants
in IsoChronology
using the ==
operator.
getEra
in interface ChronoLocalDate
IsoChronology
era constant applicable at this date, not nullpublic int getYear()
This method returns the primitive int
value for the year.
The year returned by this method is proleptic as per get(YEAR)
.
To obtain the year-of-era, use get(YEAR_OF_ERA)
.
public int getMonthValue()
This method returns the month as an int
from 1 to 12.
Application code is frequently clearer if the enum Month
is used by calling getMonth()
.
getMonth()
public Month getMonth()
Month
enum.
This method returns the enum Month
for the month.
This avoids confusion as to what int
values mean.
If you need access to the primitive int
value then the enum
provides the int value
.
getMonthValue()
public int getDayOfMonth()
This method returns the primitive int
value for the day-of-month.
public int getDayOfYear()
This method returns the primitive int
value for the day-of-year.
public DayOfWeek getDayOfWeek()
DayOfWeek
.
This method returns the enum DayOfWeek
for the day-of-week.
This avoids confusion as to what int
values mean.
If you need access to the primitive int
value then the enum
provides the int value
.
Additional information can be obtained from the DayOfWeek
.
This includes textual names of the values.
public boolean isLeapYear()
This method applies the current rules for leap years across the whole time-line. In general, a year is a leap year if it is divisible by four without remainder. However, years divisible by 100, are not leap years, with the exception of years divisible by 400 which are.
For example, 1904 is a leap year it is divisible by 4. 1900 was not a leap year as it is divisible by 100, however 2000 was a leap year as it is divisible by 400.
The calculation is proleptic - applying the same rules into the far future and far past. This is historically inaccurate, but is correct for the ISO-8601 standard.
isLeapYear
in interface ChronoLocalDate
public int lengthOfMonth()
This returns the length of the month in days. For example, a date in January would return 31.
lengthOfMonth
in interface ChronoLocalDate
public int lengthOfYear()
This returns the length of the year in days, either 365 or 366.
lengthOfYear
in interface ChronoLocalDate
public LocalDate with(TemporalAdjuster adjuster)
This returns a LocalDate
, based on this one, with the date adjusted.
The adjustment takes place using the specified adjuster strategy object.
Read the documentation of the adjuster to understand what adjustment will be made.
A simple adjuster might simply set the one of the fields, such as the year field. A more complex adjuster might set the date to the last day of the month.
A selection of common adjustments is provided in
TemporalAdjusters
.
These include finding the "last day of the month" and "next Wednesday".
Key date-time classes also implement the TemporalAdjuster
interface,
such as Month
and MonthDay
.
The adjuster is responsible for handling special cases, such as the varying
lengths of month and leap years.
For example this code returns a date on the last day of July:
import static java.time.Month.*; import static java.time.temporal.TemporalAdjusters.*; result = localDate.with(JULY).with(lastDayOfMonth());
The result of this method is obtained by invoking the
TemporalAdjuster.adjustInto(Temporal)
method on the
specified adjuster passing this
as the argument.
This instance is immutable and unaffected by this method call.
with
in interface ChronoLocalDate
with
in interface Temporal
adjuster
- the adjuster to use, not nullLocalDate
based on this
with the adjustment made, not nullDateTimeException
- if the adjustment cannot be madeArithmeticException
- if numeric overflow occurspublic LocalDate with(TemporalField field, long newValue)
This returns a LocalDate
, based on this one, with the value
for the specified field changed.
This can be used to change any supported field, such as the year, month or day-of-month.
If it is not possible to set the value, because the field is not supported or for
some other reason, an exception is thrown.
In some cases, changing the specified field can cause the resulting date to become invalid, such as changing the month from 31st January to February would make the day-of-month invalid. In cases like this, the field is responsible for resolving the date. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
If the field is a ChronoField
then the adjustment is implemented here.
The supported fields behave as follows:
DAY_OF_WEEK
-
Returns a LocalDate
with the specified day-of-week.
The date is adjusted up to 6 days forward or backward within the boundary
of a Monday to Sunday week.
ALIGNED_DAY_OF_WEEK_IN_MONTH
-
Returns a LocalDate
with the specified aligned-day-of-week.
The date is adjusted to the specified month-based aligned-day-of-week.
Aligned weeks are counted such that the first week of a given month starts
on the first day of that month.
This may cause the date to be moved up to 6 days into the following month.
ALIGNED_DAY_OF_WEEK_IN_YEAR
-
Returns a LocalDate
with the specified aligned-day-of-week.
The date is adjusted to the specified year-based aligned-day-of-week.
Aligned weeks are counted such that the first week of a given year starts
on the first day of that year.
This may cause the date to be moved up to 6 days into the following year.
DAY_OF_MONTH
-
Returns a LocalDate
with the specified day-of-month.
The month and year will be unchanged. If the day-of-month is invalid for the
year and month, then a DateTimeException
is thrown.
DAY_OF_YEAR
-
Returns a LocalDate
with the specified day-of-year.
The year will be unchanged. If the day-of-year is invalid for the
year, then a DateTimeException
is thrown.
EPOCH_DAY
-
Returns a LocalDate
with the specified epoch-day.
This completely replaces the date and is equivalent to ofEpochDay(long)
.
ALIGNED_WEEK_OF_MONTH
-
Returns a LocalDate
with the specified aligned-week-of-month.
Aligned weeks are counted such that the first week of a given month starts
on the first day of that month.
This adjustment moves the date in whole week chunks to match the specified week.
The result will have the same day-of-week as this date.
This may cause the date to be moved into the following month.
ALIGNED_WEEK_OF_YEAR
-
Returns a LocalDate
with the specified aligned-week-of-year.
Aligned weeks are counted such that the first week of a given year starts
on the first day of that year.
This adjustment moves the date in whole week chunks to match the specified week.
The result will have the same day-of-week as this date.
This may cause the date to be moved into the following year.
MONTH_OF_YEAR
-
Returns a LocalDate
with the specified month-of-year.
The year will be unchanged. The day-of-month will also be unchanged,
unless it would be invalid for the new month and year. In that case, the
day-of-month is adjusted to the maximum valid value for the new month and year.
PROLEPTIC_MONTH
-
Returns a LocalDate
with the specified proleptic-month.
The day-of-month will be unchanged, unless it would be invalid for the new month
and year. In that case, the day-of-month is adjusted to the maximum valid value
for the new month and year.
YEAR_OF_ERA
-
Returns a LocalDate
with the specified year-of-era.
The era and month will be unchanged. The day-of-month will also be unchanged,
unless it would be invalid for the new month and year. In that case, the
day-of-month is adjusted to the maximum valid value for the new month and year.
YEAR
-
Returns a LocalDate
with the specified year.
The month will be unchanged. The day-of-month will also be unchanged,
unless it would be invalid for the new month and year. In that case, the
day-of-month is adjusted to the maximum valid value for the new month and year.
ERA
-
Returns a LocalDate
with the specified era.
The year-of-era and month will be unchanged. The day-of-month will also be unchanged,
unless it would be invalid for the new month and year. In that case, the
day-of-month is adjusted to the maximum valid value for the new month and year.
In all cases, if the new value is outside the valid range of values for the field
then a DateTimeException
will be thrown.
All other ChronoField
instances will throw an UnsupportedTemporalTypeException
.
If the field is not a ChronoField
, then the result of this method
is obtained by invoking TemporalField.adjustInto(Temporal, long)
passing this
as the argument. In this case, the field determines
whether and how to adjust the instant.
This instance is immutable and unaffected by this method call.
with
in interface ChronoLocalDate
with
in interface Temporal
field
- the field to set in the result, not nullnewValue
- the new value of the field in the resultLocalDate
based on this
with the specified field set, not nullDateTimeException
- if the field cannot be setUnsupportedTemporalTypeException
- if the field is not supportedArithmeticException
- if numeric overflow occurspublic LocalDate withYear(int year)
LocalDate
with the year altered.
If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
This instance is immutable and unaffected by this method call.
year
- the year to set in the result, from MIN_YEAR to MAX_YEARLocalDate
based on this date with the requested year, not nullDateTimeException
- if the year value is invalidpublic LocalDate withMonth(int month)
LocalDate
with the month-of-year altered.
If the day-of-month is invalid for the year, it will be changed to the last valid day of the month.
This instance is immutable and unaffected by this method call.
month
- the month-of-year to set in the result, from 1 (January) to 12 (December)LocalDate
based on this date with the requested month, not nullDateTimeException
- if the month-of-year value is invalidpublic LocalDate withDayOfMonth(int dayOfMonth)
LocalDate
with the day-of-month altered.
If the resulting date is invalid, an exception is thrown.
This instance is immutable and unaffected by this method call.
dayOfMonth
- the day-of-month to set in the result, from 1 to 28-31LocalDate
based on this date with the requested day, not nullDateTimeException
- if the day-of-month value is invalid,
or if the day-of-month is invalid for the month-yearpublic LocalDate withDayOfYear(int dayOfYear)
LocalDate
with the day-of-year altered.
If the resulting date is invalid, an exception is thrown.
This instance is immutable and unaffected by this method call.
dayOfYear
- the day-of-year to set in the result, from 1 to 365-366LocalDate
based on this date with the requested day, not nullDateTimeException
- if the day-of-year value is invalid,
or if the day-of-year is invalid for the yearpublic LocalDate plus(TemporalAmount amountToAdd)
This returns a LocalDate
, based on this one, with the specified amount added.
The amount is typically Period
but may be any other type implementing
the TemporalAmount
interface.
The calculation is delegated to the amount object by calling
TemporalAmount.addTo(Temporal)
. The amount implementation is free
to implement the addition in any way it wishes, however it typically
calls back to plus(long, TemporalUnit)
. Consult the documentation
of the amount implementation to determine if it can be successfully added.
This instance is immutable and unaffected by this method call.
plus
in interface ChronoLocalDate
plus
in interface Temporal
amountToAdd
- the amount to add, not nullLocalDate
based on this date with the addition made, not nullDateTimeException
- if the addition cannot be madeArithmeticException
- if numeric overflow occurspublic LocalDate plus(long amountToAdd, TemporalUnit unit)
This returns a LocalDate
, based on this one, with the amount
in terms of the unit added. If it is not possible to add the amount, because the
unit is not supported or for some other reason, an exception is thrown.
In some cases, adding the amount can cause the resulting date to become invalid. For example, adding one month to 31st January would result in 31st February. In cases like this, the unit is responsible for resolving the date. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
If the field is a ChronoUnit
then the addition is implemented here.
The supported fields behave as follows:
DAYS
-
Returns a LocalDate
with the specified number of days added.
This is equivalent to plusDays(long)
.
WEEKS
-
Returns a LocalDate
with the specified number of weeks added.
This is equivalent to plusWeeks(long)
and uses a 7 day week.
MONTHS
-
Returns a LocalDate
with the specified number of months added.
This is equivalent to plusMonths(long)
.
The day-of-month will be unchanged unless it would be invalid for the new
month and year. In that case, the day-of-month is adjusted to the maximum
valid value for the new month and year.
YEARS
-
Returns a LocalDate
with the specified number of years added.
This is equivalent to plusYears(long)
.
The day-of-month will be unchanged unless it would be invalid for the new
month and year. In that case, the day-of-month is adjusted to the maximum
valid value for the new month and year.
DECADES
-
Returns a LocalDate
with the specified number of decades added.
This is equivalent to calling plusYears(long)
with the amount
multiplied by 10.
The day-of-month will be unchanged unless it would be invalid for the new
month and year. In that case, the day-of-month is adjusted to the maximum
valid value for the new month and year.
CENTURIES
-
Returns a LocalDate
with the specified number of centuries added.
This is equivalent to calling plusYears(long)
with the amount
multiplied by 100.
The day-of-month will be unchanged unless it would be invalid for the new
month and year. In that case, the day-of-month is adjusted to the maximum
valid value for the new month and year.
MILLENNIA
-
Returns a LocalDate
with the specified number of millennia added.
This is equivalent to calling plusYears(long)
with the amount
multiplied by 1,000.
The day-of-month will be unchanged unless it would be invalid for the new
month and year. In that case, the day-of-month is adjusted to the maximum
valid value for the new month and year.
ERAS
-
Returns a LocalDate
with the specified number of eras added.
Only two eras are supported so the amount must be one, zero or minus one.
If the amount is non-zero then the year is changed such that the year-of-era
is unchanged.
The day-of-month will be unchanged unless it would be invalid for the new
month and year. In that case, the day-of-month is adjusted to the maximum
valid value for the new month and year.
All other ChronoUnit
instances will throw an UnsupportedTemporalTypeException
.
If the field is not a ChronoUnit
, then the result of this method
is obtained by invoking TemporalUnit.addTo(Temporal, long)
passing this
as the argument. In this case, the unit determines
whether and how to perform the addition.
This instance is immutable and unaffected by this method call.
plus
in interface ChronoLocalDate
plus
in interface Temporal
amountToAdd
- the amount of the unit to add to the result, may be negativeunit
- the unit of the amount to add, not nullLocalDate
based on this date with the specified amount added, not nullDateTimeException
- if the addition cannot be madeUnsupportedTemporalTypeException
- if the unit is not supportedArithmeticException
- if numeric overflow occurspublic LocalDate plusYears(long yearsToAdd)
LocalDate
with the specified number of years added.
This method adds the specified amount to the years field in three steps:
For example, 2008-02-29 (leap year) plus one year would result in the invalid date 2009-02-29 (standard year). Instead of returning an invalid result, the last valid day of the month, 2009-02-28, is selected instead.
This instance is immutable and unaffected by this method call.
yearsToAdd
- the years to add, may be negativeLocalDate
based on this date with the years added, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate plusMonths(long monthsToAdd)
LocalDate
with the specified number of months added.
This method adds the specified amount to the months field in three steps:
For example, 2007-03-31 plus one month would result in the invalid date 2007-04-31. Instead of returning an invalid result, the last valid day of the month, 2007-04-30, is selected instead.
This instance is immutable and unaffected by this method call.
monthsToAdd
- the months to add, may be negativeLocalDate
based on this date with the months added, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate plusWeeks(long weeksToAdd)
LocalDate
with the specified number of weeks added.
This method adds the specified amount in weeks to the days field incrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2008-12-31 plus one week would result in 2009-01-07.
This instance is immutable and unaffected by this method call.
weeksToAdd
- the weeks to add, may be negativeLocalDate
based on this date with the weeks added, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate plusDays(long daysToAdd)
LocalDate
with the specified number of days added.
This method adds the specified amount to the days field incrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2008-12-31 plus one day would result in 2009-01-01.
This instance is immutable and unaffected by this method call.
daysToAdd
- the days to add, may be negativeLocalDate
based on this date with the days added, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate minus(TemporalAmount amountToSubtract)
This returns a LocalDate
, based on this one, with the specified amount subtracted.
The amount is typically Period
but may be any other type implementing
the TemporalAmount
interface.
The calculation is delegated to the amount object by calling
TemporalAmount.subtractFrom(Temporal)
. The amount implementation is free
to implement the subtraction in any way it wishes, however it typically
calls back to minus(long, TemporalUnit)
. Consult the documentation
of the amount implementation to determine if it can be successfully subtracted.
This instance is immutable and unaffected by this method call.
minus
in interface ChronoLocalDate
minus
in interface Temporal
amountToSubtract
- the amount to subtract, not nullLocalDate
based on this date with the subtraction made, not nullDateTimeException
- if the subtraction cannot be madeArithmeticException
- if numeric overflow occurspublic LocalDate minus(long amountToSubtract, TemporalUnit unit)
This returns a LocalDate
, based on this one, with the amount
in terms of the unit subtracted. If it is not possible to subtract the amount,
because the unit is not supported or for some other reason, an exception is thrown.
This method is equivalent to plus(long, TemporalUnit)
with the amount negated.
See that method for a full description of how addition, and thus subtraction, works.
This instance is immutable and unaffected by this method call.
minus
in interface ChronoLocalDate
minus
in interface Temporal
amountToSubtract
- the amount of the unit to subtract from the result, may be negativeunit
- the unit of the amount to subtract, not nullLocalDate
based on this date with the specified amount subtracted, not nullDateTimeException
- if the subtraction cannot be madeUnsupportedTemporalTypeException
- if the unit is not supportedArithmeticException
- if numeric overflow occurspublic LocalDate minusYears(long yearsToSubtract)
LocalDate
with the specified number of years subtracted.
This method subtracts the specified amount from the years field in three steps:
For example, 2008-02-29 (leap year) minus one year would result in the invalid date 2007-02-29 (standard year). Instead of returning an invalid result, the last valid day of the month, 2007-02-28, is selected instead.
This instance is immutable and unaffected by this method call.
yearsToSubtract
- the years to subtract, may be negativeLocalDate
based on this date with the years subtracted, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate minusMonths(long monthsToSubtract)
LocalDate
with the specified number of months subtracted.
This method subtracts the specified amount from the months field in three steps:
For example, 2007-03-31 minus one month would result in the invalid date 2007-02-31. Instead of returning an invalid result, the last valid day of the month, 2007-02-28, is selected instead.
This instance is immutable and unaffected by this method call.
monthsToSubtract
- the months to subtract, may be negativeLocalDate
based on this date with the months subtracted, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate minusWeeks(long weeksToSubtract)
LocalDate
with the specified number of weeks subtracted.
This method subtracts the specified amount in weeks from the days field decrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2009-01-07 minus one week would result in 2008-12-31.
This instance is immutable and unaffected by this method call.
weeksToSubtract
- the weeks to subtract, may be negativeLocalDate
based on this date with the weeks subtracted, not nullDateTimeException
- if the result exceeds the supported date rangepublic LocalDate minusDays(long daysToSubtract)
LocalDate
with the specified number of days subtracted.
This method subtracts the specified amount from the days field decrementing the month and year fields as necessary to ensure the result remains valid. The result is only invalid if the maximum/minimum year is exceeded.
For example, 2009-01-01 minus one day would result in 2008-12-31.
This instance is immutable and unaffected by this method call.
daysToSubtract
- the days to subtract, may be negativeLocalDate
based on this date with the days subtracted, not nullDateTimeException
- if the result exceeds the supported date rangepublic <R> R query(TemporalQuery<R> query)
This queries this date using the specified query strategy object.
The 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.
The result of this method is obtained by invoking the
TemporalQuery.queryFrom(TemporalAccessor)
method on the
specified query passing this
as the argument.
query
in interface ChronoLocalDate
query
in interface TemporalAccessor
R
- the type of the resultquery
- the query to invoke, not nullDateTimeException
- if unable to query (defined by the query)ArithmeticException
- if numeric overflow occurs (defined by the query)public Temporal adjustInto(Temporal temporal)
This returns a temporal object of the same observable type as the input with the date changed to be the same as this.
The adjustment is equivalent to using Temporal.with(TemporalField, long)
passing ChronoField.EPOCH_DAY
as the field.
In most cases, it is clearer to reverse the calling pattern by using
Temporal.with(TemporalAdjuster)
:
// these two lines are equivalent, but the second approach is recommended temporal = thisLocalDate.adjustInto(temporal); temporal = temporal.with(thisLocalDate);
This instance is immutable and unaffected by this method call.
adjustInto
in interface ChronoLocalDate
adjustInto
in interface TemporalAdjuster
temporal
- the target object to be adjusted, not nullDateTimeException
- if unable to make the adjustmentArithmeticException
- if numeric overflow occurspublic long until(Temporal endExclusive, TemporalUnit unit)
This calculates the amount of time between two LocalDate
objects in terms of a single TemporalUnit
.
The start and end points are this
and the specified date.
The result will be negative if the end is before the start.
The Temporal
passed to this method is converted to a
LocalDate
using from(TemporalAccessor)
.
For example, the amount in days between two dates can be calculated
using startDate.until(endDate, DAYS)
.
The calculation returns a whole number, representing the number of complete units between the two dates. For example, the amount in months between 2012-06-15 and 2012-08-14 will only be one month as it is one day short of two months.
There are two equivalent ways of using this method.
The first is to invoke this method.
The second is to use TemporalUnit.between(Temporal, Temporal)
:
// these two lines are equivalent amount = start.until(end, MONTHS); amount = MONTHS.between(start, end);The choice should be made based on which makes the code more readable.
The calculation is implemented in this method for ChronoUnit
.
The units DAYS
, WEEKS
, MONTHS
, YEARS
,
DECADES
, CENTURIES
, MILLENNIA
and ERAS
are supported. Other ChronoUnit
values will throw an exception.
If the unit is not a ChronoUnit
, then the result of this method
is obtained by invoking TemporalUnit.between(Temporal, Temporal)
passing this
as the first argument and the converted input temporal
as the second argument.
This instance is immutable and unaffected by this method call.
until
in interface ChronoLocalDate
until
in interface Temporal
endExclusive
- the end date, exclusive, which is converted to a LocalDate
, not nullunit
- the unit to measure the amount in, not nullDateTimeException
- if the amount cannot be calculated, or the end
temporal cannot be converted to a LocalDate
UnsupportedTemporalTypeException
- if the unit is not supportedArithmeticException
- if numeric overflow occurspublic Period until(ChronoLocalDate endDateExclusive)
Period
.
This calculates the period between two dates in terms of years, months and days.
The start and end points are this
and the specified date.
The result will be negative if the end is before the start.
The negative sign will be the same in each of year, month and day.
The calculation is performed using the ISO calendar system. If necessary, the input date will be converted to ISO.
The start date is included, but the end date is not.
The period is calculated by removing complete months, then calculating
the remaining number of days, adjusting to ensure that both have the same sign.
The number of months is then normalized into years and months based on a 12 month year.
A month is considered to be complete if the end day-of-month is greater
than or equal to the start day-of-month.
For example, from 2010-01-15
to 2011-03-18
is "1 year, 2 months and 3 days".
There are two equivalent ways of using this method.
The first is to invoke this method.
The second is to use Period.between(LocalDate, LocalDate)
:
// these two lines are equivalent period = start.until(end); period = Period.between(start, end);The choice should be made based on which makes the code more readable.
until
in interface ChronoLocalDate
endDateExclusive
- the end date, exclusive, which may be in any chronology, not nullpublic String format(DateTimeFormatter formatter)
This date will be passed to the formatter to produce a string.
format
in interface ChronoLocalDate
formatter
- the formatter to use, not nullDateTimeException
- if an error occurs during printingpublic LocalDateTime atTime(LocalTime time)
LocalDateTime
.
This returns a LocalDateTime
formed from this date at the specified time.
All possible combinations of date and time are valid.
atTime
in interface ChronoLocalDate
time
- the time to combine with, not nullpublic LocalDateTime atTime(int hour, int minute)
LocalDateTime
.
This returns a LocalDateTime
formed from this date at the
specified hour and minute.
The seconds and nanosecond fields will be set to zero.
The individual time fields must be within their valid range.
All possible combinations of date and time are valid.
hour
- the hour-of-day to use, from 0 to 23minute
- the minute-of-hour to use, from 0 to 59DateTimeException
- if the value of any field is out of rangepublic LocalDateTime atTime(int hour, int minute, int second)
LocalDateTime
.
This returns a LocalDateTime
formed from this date at the
specified hour, minute and second.
The nanosecond field will be set to zero.
The individual time fields must be within their valid range.
All possible combinations of date and time are valid.
hour
- the hour-of-day to use, from 0 to 23minute
- the minute-of-hour to use, from 0 to 59second
- the second-of-minute to represent, from 0 to 59DateTimeException
- if the value of any field is out of rangepublic LocalDateTime atTime(int hour, int minute, int second, int nanoOfSecond)
LocalDateTime
.
This returns a LocalDateTime
formed from this date at the
specified hour, minute, second and nanosecond.
The individual time fields must be within their valid range.
All possible combinations of date and time are valid.
hour
- the hour-of-day to use, from 0 to 23minute
- the minute-of-hour to use, from 0 to 59second
- the second-of-minute to represent, from 0 to 59nanoOfSecond
- the nano-of-second to represent, from 0 to 999,999,999DateTimeException
- if the value of any field is out of rangepublic OffsetDateTime atTime(OffsetTime time)
OffsetDateTime
.
This returns an OffsetDateTime
formed from this date at the specified time.
All possible combinations of date and time are valid.
time
- the time to combine with, not nullpublic LocalDateTime atStartOfDay()
LocalDateTime
at the start of this date.
This returns a LocalDateTime
formed from this date at the time of
midnight, 00:00, at the start of this date.
public ZonedDateTime atStartOfDay(ZoneId zone)
Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the specified zone, thus the local date-time may not be midnight.
In most cases, there is only one valid offset for a local date-time. In the case of an overlap, there are two valid offsets, and the earlier one is used, corresponding to the first occurrence of midnight on the date. In the case of a gap, the zoned date-time will represent the instant just after the gap.
If the zone ID is a ZoneOffset
, then the result always has a time of midnight.
To convert to a specific time in a given time-zone call atTime(LocalTime)
followed by LocalDateTime.atZone(ZoneId)
.
zone
- the zone ID to use, not nullpublic long toEpochDay()
ChronoLocalDate
The Epoch Day count
is a simple
incrementing count of days where day 0 is 1970-01-01 (ISO).
This definition is the same for all chronologies, enabling conversion.
This default implementation queries the EPOCH_DAY
field.
toEpochDay
in interface ChronoLocalDate
public int compareTo(ChronoLocalDate other)
The comparison is primarily based on the date, from earliest to latest.
It is "consistent with equals", as defined by Comparable
.
If all the dates being compared are instances of LocalDate
,
then the comparison will be entirely based on the date.
If some dates being compared are in different chronologies, then the
chronology is also considered, see ChronoLocalDate.compareTo(java.time.chrono.ChronoLocalDate)
.
compareTo
in interface Comparable<ChronoLocalDate>
compareTo
in interface ChronoLocalDate
other
- the other date to compare to, not nullpublic boolean isAfter(ChronoLocalDate other)
This checks to see if this date represents a point on the local time-line after the other date.
LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1); a.isAfter(b) == false a.isAfter(a) == false b.isAfter(a) == true
This method only considers the position of the two dates on the local time-line.
It does not take into account the chronology, or calendar system.
This is different from the comparison in compareTo(ChronoLocalDate)
,
but is the same approach as ChronoLocalDate.timeLineOrder()
.
isAfter
in interface ChronoLocalDate
other
- the other date to compare to, not nullpublic boolean isBefore(ChronoLocalDate other)
This checks to see if this date represents a point on the local time-line before the other date.
LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1); a.isBefore(b) == true a.isBefore(a) == false b.isBefore(a) == false
This method only considers the position of the two dates on the local time-line.
It does not take into account the chronology, or calendar system.
This is different from the comparison in compareTo(ChronoLocalDate)
,
but is the same approach as ChronoLocalDate.timeLineOrder()
.
isBefore
in interface ChronoLocalDate
other
- the other date to compare to, not nullpublic boolean isEqual(ChronoLocalDate other)
This checks to see if this date represents the same point on the local time-line as the other date.
LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1); a.isEqual(b) == false a.isEqual(a) == true b.isEqual(a) == false
This method only considers the position of the two dates on the local time-line.
It does not take into account the chronology, or calendar system.
This is different from the comparison in compareTo(ChronoLocalDate)
but is the same approach as ChronoLocalDate.timeLineOrder()
.
isEqual
in interface ChronoLocalDate
other
- the other date to compare to, not nullpublic boolean equals(Object obj)
Compares this LocalDate
with another ensuring that the date is the same.
Only objects of type LocalDate
are compared, other types return false.
To compare the dates of two TemporalAccessor
instances, including dates
in two different chronologies, use ChronoField.EPOCH_DAY
as a comparator.
equals
in interface ChronoLocalDate
equals
in class Object
obj
- the object to check, null returns falseObject.hashCode()
,
HashMap
public int hashCode()
hashCode
in interface ChronoLocalDate
hashCode
in class Object
Object.equals(java.lang.Object)
,
System.identityHashCode(java.lang.Object)
public String toString()
String
, such as 2007-12-03
.
The output will be in the ISO-8601 format uuuu-MM-dd
.
toString
in interface ChronoLocalDate
toString
in class Object
Dracula Javadoc Sample, Made with Allan Im.


Toggle navigation
Bootstrap Ocean
About
Services
Contact
Lightweight 4 Columns Portfolio Filter for Bootstrap 3
Secondary Text
All
Icon Design
Identity Design
Web Design
Web Design
Icon Design
Identity Design
Web Design
Icon Design
Identity Design
Web Design
Icon Design
Identity Design
Web Design
Icon Design
Identity Design
«
1
2
3
4
5
»


You can add Items to this cool list!
Left click to change the status of the item to "Done".
Right click to delete an item!