HolidayDatabase.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.kolmafia.persistence |
 |
 |
KoLmafia |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| JAVA0076 | JAVA0076 Use of magic number |  |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| LINE_COMMENT | Number of line comments | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| CYCLOMATIC | Cyclomatic complexity | |
| LOOPS | Number of loops | |
| RETURNS | Number of return points from functions | |
| SIZE | Size of the file in bytes | |
| LOC | Lines of code | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| LINES | Number of lines in the source file | |
| OPERATORS | Number of operators | |
| PROGRAM_LENGTH | Halstead program length | |
| OPERANDS | Number of operands | |
| COMPARISONS | Number of comparison operators | |
| LOGICAL_LINES | Number of statements | |
| BLOCKS | Number of blocks | |
| ELOC | Effective lines of code | |
| PARAMS | Number of formal parameter declarations | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| UNIQUE_OPERANDS | Number of unique operands | |
| DECL_COMMENTS | Comments in declarations | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| FUNCTIONS | Number of function declarations | |
| WHITESPACE | Number of whitespace lines | |
| EXEC_COMMENTS | Comments in executable code | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0119 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0084 | JAVA0084 Should use compound assignment operator | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
| JAVA0166 | JAVA0166 Generic exception caught | |
| COMMENTS | Comment lines | |
| JAVA0116 | JAVA0116 Missing javadoc: field 'field' | |
| UNIQUE_OPERATORS | Number of unique operators | |
| DOC_COMMENT | Number of javadoc comment lines | |
| EXITS | Procedure exits | |
| JAVA0144 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0128 | JAVA0128 Public constructor in non-public class | |
| NEST_DEPTH | Maximum nesting depth | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0032 | JAVA0032 Switch statement missing default | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0100 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0270 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
/**
* Copyright (c) 2005-2008, KoLmafia development team
* http://kolmafia.sourceforge.net/
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* [1] Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* [2] Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* [3] Neither the name "KoLmafia" nor the names of its contributors may
* be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
package net.sourceforge.kolmafia.persistence;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
import net.sourceforge.kolmafia.KoLConstants;
import net.sourceforge.kolmafia.StaticEntity;
import net.sourceforge.kolmafia.utilities.StringUtilities;
public class HolidayDatabase
extends StaticEntity
{
private static long NEWYEAR = 0;
private static long BOUNDARY = 0;
private static long COLLISION = 0;
static
{
try
{
// Change it so that it doesn't recognize daylight savings in order
// to ensure different localizations work.
Calendar myCalendar = Calendar.getInstance( TimeZone.getTimeZone( "GMT-5" ) );
myCalendar.set( 2005, 8, 17, 0, 0, 0 );
HolidayDatabase.NEWYEAR = myCalendar.getTimeInMillis();
myCalendar.set( 2005, 9, 27, 0, 0, 0 );
HolidayDatabase.BOUNDARY = myCalendar.getTimeInMillis();
myCalendar.set( 2006, 5, 3, 0, 0, 0 );
HolidayDatabase.COLLISION = myCalendar.getTimeInMillis();
}
catch ( Exception e )
{
// This should not happen. Therefore, print
// a stack trace for debug purposes.
StaticEntity.printStackTrace( e );
}
}
private static int RONALD_PHASE = -1;
private static int GRIMACE_PHASE = -1;
private static int HAMBURGLAR_POSITION = -1;
static
{
try
{
int calendarDay = HolidayDatabase.getCalendarDay( new Date() );
int phaseStep = ( calendarDay % 16 + 16 ) % 16;
HolidayDatabase.RONALD_PHASE = phaseStep % 8;
HolidayDatabase.GRIMACE_PHASE = phaseStep / 2;
HolidayDatabase.HAMBURGLAR_POSITION = HolidayDatabase.getHamburglarPosition( new Date() );
}
catch ( Exception e )
{
// This should not happen. Therefore, print
// a stack trace for debug purposes.
StaticEntity.printStackTrace( e );
}
}
// static final array of status effect day predictions
// within the KoL lunar calendar.
private static final String[] STAT_EFFECT =
{
"Moxie bonus today and yesterday.",
"3 days until Mysticism.",
"2 days until Mysticism.",
"Mysticism bonus tomorrow (not today).",
"Mysticism bonus today (not tomorrow).",
"3 days until Muscle.",
"2 days until Muscle.",
"Muscle bonus tomorrow (not today).",
"Muscle bonus today and tomorrow.",
"Muscle bonus today and yesterday.",
"2 days until Mysticism.",
"Mysticism bonus tomorrow (not today).",
"Mysticism bonus today (not tomorrow).",
"2 days until Moxie.",
"Moxie bonus tomorrow (not today).",
"Moxie bonus today and tomorrow."
};
// static final array of month names, as they exist within
// the KoL calendar.
private static final String[] MONTH_NAMES =
{
"",
"Jarlsuary",
"Frankruary",
"Starch",
"April",
"Martinus",
"Bill",
"Bor",
"Petember",
"Carlvember",
"Porktober",
"Boozember",
"Dougtember"
};
// static final array of HOLIDAYS. This holiday is filled with the
// name of the holiday which occurs on the given KoL month and
// given KoL day.
private static final String[][] HOLIDAYS = new String[ 13 ][ 9 ];
static
{
for ( int i = 0; i < 13; ++i )
{
for ( int j = 0; j < 9; ++j )
{
HolidayDatabase.HOLIDAYS[ i ][ j ] = null;
}
}
// Initialize all the known HOLIDAYS here so that
// they can be used in later initializers.
HolidayDatabase.HOLIDAYS[ 1 ][ 1 ] = "Festival of Jarlsberg"; // Jarlsuary 1
HolidayDatabase.HOLIDAYS[ 2 ][ 4 ] = "Valentine's Day"; // Frankuary 4
HolidayDatabase.HOLIDAYS[ 3 ][ 3 ] = "St. Sneaky Pete's Day"; // Starch 3
HolidayDatabase.HOLIDAYS[ 4 ][ 2 ] = "Oyster Egg Day"; // April 2
HolidayDatabase.HOLIDAYS[ 5 ][ 2 ] = "El Dia De Los Muertos Borrachos"; // Martinus 2
HolidayDatabase.HOLIDAYS[ 6 ][ 3 ] = "Generic Summer Holiday"; // Bill 3
HolidayDatabase.HOLIDAYS[ 7 ][ 4 ] = "Dependence Day"; // Bor 4
HolidayDatabase.HOLIDAYS[ 8 ][ 4 ] = "Arrrbor Day"; // Petember 4
HolidayDatabase.HOLIDAYS[ 9 ][ 6 ] = "Labór Day"; // Carlvember 6
HolidayDatabase.HOLIDAYS[ 10 ][ 8 ] = "Halloween"; // Porktober 8
HolidayDatabase.HOLIDAYS[ 11 ][ 7 ] = "Feast of Boris"; // Boozember 7
HolidayDatabase.HOLIDAYS[ 12 ][ 4 ] = "Yuletide"; // Dougtember
}
// static final array of when the special events in KoL occur, including
// stat days, HOLIDAYS and all that jazz. Values are false where
// there is no special occasion, and true where there is.
private static final int[] SPECIAL = new int[ 96 ];
public static final int SP_NOTHING = 0;
public static final int SP_HOLIDAY = 1;
public static final int SP_MUSDAY = 2;
public static final int SP_MYSDAY = 3;
public static final int SP_MOXDAY = 4;
static
{
// Assume there are no special days at all, and then
// fill them in once they're encountered.
for ( int i = 0; i < 96; ++i )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_NOTHING;
}
// Muscle days occur every phase 8 and phase 9 on the
// KoL calendar.
for ( int i = 8; i < 96; i += 16 )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_MUSDAY;
}
for ( int i = 9; i < 96; i += 16 )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_MUSDAY;
}
// Mysticism days occur every phase 4 and phase 12 on the
// KoL calendar.
for ( int i = 4; i < 96; i += 16 )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_MYSDAY;
}
for ( int i = 12; i < 96; i += 16 )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_MYSDAY;
}
// Moxie days occur every phase 0 and phase 15 on the
// KoL calendar.
for ( int i = 0; i < 96; i += 16 )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_MOXDAY;
}
for ( int i = 15; i < 96; i += 16 )
{
HolidayDatabase.SPECIAL[ i ] = HolidayDatabase.SP_MOXDAY;
}
// Next, fill in the HOLIDAYS. These are manually
// computed based on the recurring day in the year
// at which these occur.
for ( int i = 0; i < 13; ++i )
{
for ( int j = 0; j < 9; ++j )
{
if ( HolidayDatabase.HOLIDAYS[ i ][ j ] != null )
{
HolidayDatabase.SPECIAL[ 8 * i + j - 9 ] = HolidayDatabase.SP_HOLIDAY;
}
}
}
}
public static final void setMoonPhases( final int ronaldPhase, final int grimacePhase )
{
// Reset the new year based on the internal
// phase error.
int phaseError = HolidayDatabase.getPhaseStep();
HolidayDatabase.RONALD_PHASE = ronaldPhase;
HolidayDatabase.GRIMACE_PHASE = grimacePhase;
phaseError -= HolidayDatabase.getPhaseStep();
// Adjust the new year by the appropriate
// number of days.
HolidayDatabase.NEWYEAR += phaseError * 86400000L;
HolidayDatabase.BOUNDARY += phaseError * 86400000L;
HolidayDatabase.COLLISION += phaseError * 86400000L;
}
public static final int getRonaldPhase()
{
return HolidayDatabase.RONALD_PHASE + 1;
}
public static final int getGrimacePhase()
{
return HolidayDatabase.GRIMACE_PHASE + 1;
}
public static final int getHamburglarPosition( final Date time )
{
long timeDifference = time.getTime();
if ( timeDifference < HolidayDatabase.COLLISION )
{
return -1;
}
timeDifference -= HolidayDatabase.COLLISION;
int dayDifference = (int) Math.floor( timeDifference / 86400000L );
return ( dayDifference * 2 % 11 + 11 ) % 11;
}
/**
* Method to return which phase of the moon is currently appearing over the Kingdom of Loathing, as a string.
*
* @return The current phase of Ronald
*/
public static final String getRonaldPhaseAsString()
{
return HolidayDatabase.getPhaseName( HolidayDatabase.RONALD_PHASE );
}
/**
* Method to return which phase of the moon is currently appearing over the Kingdom of Loathing, as a string.
*
* @return The current phase of Ronald
*/
public static final String getGrimacePhaseAsString()
{
return HolidayDatabase.getPhaseName( HolidayDatabase.GRIMACE_PHASE );
}
public static final String getPhaseName( final int phase )
{
switch ( phase )
{
case 0:
return "new moon";
case 1:
return "waxing crescent";
case 2:
return "first quarter";
case 3:
return "waxing gibbous";
case 4:
return "full moon";
case 5:
return "waning gibbous";
case 6:
return "third quarter";
case 7:
return "waning crescent";
default:
return "unknown";
}
}
/**
* Returns the moon effect applicable today, or the amount of time until the next moon effect becomes applicable if
* today is not a moon effect day.
*/
public static final String getMoonEffect()
{
return HolidayDatabase.getMoonEffect( HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE );
}
/**
* Returns the moon effect applicable at the given phase step, or the amount of time until the next moon effect,
* given the phase value.
*/
public static final String getMoonEffect( final int ronaldPhase, final int grimacePhase )
{
int phaseStep = HolidayDatabase.getPhaseStep( ronaldPhase, grimacePhase );
return phaseStep == -1 ? "Could not determine moon phase." : HolidayDatabase.STAT_EFFECT[ phaseStep ];
}
public static final int getRonaldMoonlight( final int ronaldPhase )
{
return ronaldPhase > 4 ? 8 - ronaldPhase : ronaldPhase;
}
public static final int getGrimaceMoonlight( final int grimacePhase )
{
return grimacePhase > 4 ? 8 - grimacePhase : grimacePhase;
}
/**
* Returns the "phase step" currently recognized by the KoL calendar. This corresponds to the day within the KoL
* lunar calendar, which has a cycle of 16 days.
*/
public static final int getPhaseStep()
{
return HolidayDatabase.getPhaseStep( HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE );
}
/**
* Returns the "phase step" currently recognized by the KoL calendar, corresponding to the given phases. This
* corresponds to the day within the KoL lunar calendar, which has a cycle of 16 days.
*/
public static final int getPhaseStep( final int ronaldPhase, final int grimacePhase )
{
return grimacePhase >= 4 ? 8 + ronaldPhase : ronaldPhase;
}
/**
* Returns whether or not the grue will fight during the current moon phase.
*/
public static final boolean getGrueEffect()
{
return HolidayDatabase.getGrueEffect(
HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE, HolidayDatabase.HAMBURGLAR_POSITION );
}
/**
* Returns whether or not the grue will fight during the given moon phases.
*/
public static final boolean getGrueEffect( final int ronaldPhase, final int grimacePhase,
final int hamburglarPosition )
{
return HolidayDatabase.getMoonlight( ronaldPhase, grimacePhase, hamburglarPosition ) < 5;
}
/**
* Returns the effect percentage (as a whole number integer) of Blood of the Wereseal for today.
*/
public static final int getBloodEffect()
{
return HolidayDatabase.getBloodEffect(
HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE, HolidayDatabase.HAMBURGLAR_POSITION );
}
/**
* Returns the effect percentage (as a whole number integer) of Blood of the Wereseal for the given moon phase.
*/
public static final int getBloodEffect( final int ronaldPhase, final int grimacePhase, final int hamburglarPosition )
{
return 50 + ( HolidayDatabase.getMoonlight( ronaldPhase, grimacePhase, hamburglarPosition ) - 4 ) * 5;
}
/**
* Returns the effect percentage (as a whole number integer) of the Talisman of Baio for today.
*/
public static final int getBaioEffect()
{
return HolidayDatabase.getBaioEffect(
HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE, HolidayDatabase.HAMBURGLAR_POSITION );
}
/**
* Returns the effect percentage (as a whole number integer) of the Talisman of Baio for the given moon phases.
*/
public static final int getBaioEffect( final int ronaldPhase, final int grimacePhase, final int hamburglarPosition )
{
return HolidayDatabase.getMoonlight( ronaldPhase, grimacePhase, hamburglarPosition ) * 10;
}
public static final int getGrimaciteEffect()
{
return HolidayDatabase.getGrimaciteEffect(
HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE, HolidayDatabase.HAMBURGLAR_POSITION );
}
public static final int getGrimaciteEffect( final int ronaldPhase, final int grimacePhase,
final int hamburglarPosition )
{
int grimaceEffect = 4 - HolidayDatabase.getGrimaceMoonlight( grimacePhase );
if ( HolidayDatabase.getHamburglarLight( ronaldPhase, grimacePhase, hamburglarPosition ) != 1 )
{
++grimaceEffect;
}
return grimaceEffect * 10;
}
/**
* Returns the effect of the Jekyllin, based on the current moon phase information.
*/
public static final String getJekyllinEffect()
{
return HolidayDatabase.getJekyllinEffect(
HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE, HolidayDatabase.HAMBURGLAR_POSITION );
}
/**
* Returns the effect of the Jekyllin for the given moon phases
*/
public static final String getJekyllinEffect( final int ronaldPhase, final int grimacePhase,
final int hamburglarPosition )
{
int moonlight = HolidayDatabase.getMoonlight( ronaldPhase, grimacePhase, hamburglarPosition );
return "+" + ( 9 - moonlight ) + " stats, " + ( 15 + moonlight * 5 ) + "% items";
}
/**
* Utility method which determines the moonlight available, given the current moon phases.
*/
public static final int getMoonlight()
{
return HolidayDatabase.getMoonlight(
HolidayDatabase.RONALD_PHASE, HolidayDatabase.GRIMACE_PHASE, HolidayDatabase.HAMBURGLAR_POSITION );
}
/**
* Utility method which determines the moonlight available, given the moon phases as stated.
*/
private static final int getMoonlight( final int ronaldPhase, final int grimacePhase, final int hamburglarPosition )
{
int ronaldLight = HolidayDatabase.getRonaldMoonlight( ronaldPhase );
int grimaceLight = HolidayDatabase.getGrimaceMoonlight( grimacePhase );
int hamburglarLight = HolidayDatabase.getHamburglarLight( ronaldPhase, grimacePhase, hamburglarPosition );
return ronaldLight + grimaceLight + hamburglarLight;
}
public static final int getHamburglarLight( final int ronaldPhase, final int grimacePhase,
final int hamburglarPosition )
{
// 6 5 4 3
//
// /---\ /---\
// 7 | R | | G | 2
// \___/ \___/
//
// 8 9 10 0 1
switch ( hamburglarPosition )
{
case 0:
if ( grimacePhase > 0 && grimacePhase < 5 )
{
return -1;
}
return 1;
case 1:
if ( grimacePhase < 4 )
{
return 1;
}
return -1;
case 2:
if ( grimacePhase > 3 )
{
return 1;
}
return 0;
case 4:
if ( grimacePhase > 0 && grimacePhase < 5 )
{
return 1;
}
return 0;
case 5:
if ( ronaldPhase > 3 )
{
return 1;
}
return 0;
case 7:
if ( ronaldPhase > 0 && ronaldPhase < 5 )
{
return 1;
}
return 0;
case 8:
if ( ronaldPhase > 0 && ronaldPhase < 5 )
{
return -1;
}
return 1;
case 9:
if ( ronaldPhase < 4 )
{
return 1;
}
return -1;
case 10:
int totalEffect = 0;
if ( ronaldPhase > 3 )
{
++totalEffect;
}
if ( grimacePhase > 0 && grimacePhase < 5 )
{
++totalEffect;
}
return totalEffect;
default:
return 0;
}
}
/**
* Computes the difference in days based on the given millisecond counts since January 1, 1970.
*/
public static final int getCalendarDay( final Date time )
{
try
{
long timeDifference =
KoLConstants.DAILY_FORMAT.parse( KoLConstants.DAILY_FORMAT.format( time ) ).getTime() - HolidayDatabase.NEWYEAR;
if ( timeDifference > HolidayDatabase.BOUNDARY )
{
timeDifference -= 86400000L;
}
int dayDifference = (int) Math.floor( timeDifference / 86400000L );
return ( dayDifference % 96 + 96 ) % 96;
}
catch ( Exception e )
{
StaticEntity.printStackTrace( e );
return 0;
}
}
/**
* Utility method which calculates which day of the KoL calendar you're currently on, based on the number of
* milliseconds since January 1, 1970.
*/
public static final String getCalendarDayAsString( final Date time )
{
int[] calendarDayAsArray =
HolidayDatabase.convertCalendarDayToArray( HolidayDatabase.getCalendarDay( time ) );
return HolidayDatabase.MONTH_NAMES[ calendarDayAsArray[ 0 ] ] + " " + calendarDayAsArray[ 1 ];
}
/**
* Utility method which decomposes a given calendar day into its actual calendar components.
*/
private static final int[] convertCalendarDayToArray( final int calendarDay )
{
return new int[] { calendarDay / 8 % 12 + 1, calendarDay % 8 + 1 };
}
/**
* Utility method which returns the given day count as an easily-understood string (today, tomorrow) instead of just
* "x days".
*/
public static final String getDayCountAsString( final int dayCount )
{
return dayCount == 0 ? "today" : dayCount == 1 ? "tomorrow" : dayCount + " days";
}
/**
* Returns the KoL calendar month associated with the given date in the real world.
*/
public static final int getCalendarMonth( final Date time )
{
return HolidayDatabase.convertCalendarDayToArray( HolidayDatabase.getCalendarDay( time ) )[ 0 ];
}
/**
* Returns whether or not the given day's most important attribute is being a holiday.
*/
public static final boolean isHoliday( final Date time )
{
return HolidayDatabase.SPECIAL[ HolidayDatabase.getCalendarDay( time ) ] == HolidayDatabase.SP_HOLIDAY;
}
public static final boolean isRealLifeHoliday( final Date time )
{
return HolidayDatabase.getRealLifeHoliday( KoLConstants.DAILY_FORMAT.format( time ) ) != null;
}
/**
* Returns whether or not the given day's most important attribute is being a muscle day. Note that this ranks
* behind being a holiday, so HOLIDAYS which are also stat days (Halloween and Oyster Egg Day, for example), will
* not be recognized as "stat days" in this method.
*/
public static final boolean isMuscleDay( final Date time )
{
return HolidayDatabase.SPECIAL[ HolidayDatabase.getCalendarDay( time ) ] == HolidayDatabase.SP_MUSDAY;
}
/**
* Returns whether or not the given day's most important attribute is being a mysticality day. Note that this ranks
* behind being a holiday, so HOLIDAYS which are also stat days (Halloween and Oyster Egg Day, for example), will
* not be recognized as "stat days" in this method.
*/
public static final boolean isMysticalityDay( final Date time )
{
return HolidayDatabase.SPECIAL[ HolidayDatabase.getCalendarDay( time ) ] == HolidayDatabase.SP_MYSDAY;
}
/**
* Returns whether or not the given day's most important attribute is being a moxie day. Note that this ranks behind
* being a holiday, so HOLIDAYS which are also stat days (Halloween and Oyster Egg Day, for example), will not be
* recognized as "stat days" in this method.
*/
public static final boolean isMoxieDay( final Date time )
{
return HolidayDatabase.SPECIAL[ HolidayDatabase.getCalendarDay( time ) ] == HolidayDatabase.SP_MOXDAY;
}
/**
* Returns a complete list of all holiday predictions for the given day, as an array.
*/
public static final String[] getHolidayPredictions( final Date time )
{
List holidayList = new ArrayList();
int currentCalendarDay = HolidayDatabase.getCalendarDay( time );
int[] calendarDayAsArray;
for ( int i = 0; i < 96; ++i )
{
if ( HolidayDatabase.SPECIAL[ i ] == HolidayDatabase.SP_HOLIDAY )
{
calendarDayAsArray = HolidayDatabase.convertCalendarDayToArray( i );
int currentEstimate = ( i - currentCalendarDay + 96 ) % 96;
String holiday = HolidayDatabase.HOLIDAYS[ calendarDayAsArray[ 0 ] ][ calendarDayAsArray[ 1 ] ];
String testDate = null;
String testResult = null;
Calendar holidayTester = Calendar.getInstance();
holidayTester.setTime( time );
for ( int j = 0; j < currentEstimate; ++j )
{
testDate = KoLConstants.DAILY_FORMAT.format( holidayTester.getTime() );
testResult = HolidayDatabase.getRealLifeHoliday( testDate );
if ( holiday != null && testResult != null && testResult.equals( holiday ) )
{
currentEstimate = j;
}
holidayTester.add( Calendar.DATE, 1 );
}
holidayList.add( new HolidayEntry( currentEstimate, HolidayDatabase.HOLIDAYS[ calendarDayAsArray[ 0 ] ][ calendarDayAsArray[ 1 ] ] ) );
}
}
// If today is a real life holiday that doesn't map to a KoL
// holiday, list it here.
if ( HolidayDatabase.SPECIAL[ HolidayDatabase.getCalendarDay( time ) ] != HolidayDatabase.SP_HOLIDAY )
{
String holiday = HolidayDatabase.getRealLifeOnlyHoliday( KoLConstants.DAILY_FORMAT.format( time ) );
if ( holiday != null )
{
holidayList.add( new HolidayEntry( 0, holiday ) );
}
}
Collections.sort( holidayList );
HolidayEntry[] holidayArray = new HolidayEntry[ holidayList.size() ];
holidayList.toArray( holidayArray );
String[] predictionsArray = new String[ holidayList.size() ];
for ( int i = 0; i < holidayArray.length; ++i )
{
predictionsArray[i] = holidayArray[i].toString();
}
return predictionsArray;
}
private static class HolidayEntry
implements Comparable
{
private final int offset;
private final String name;
public HolidayEntry( final int offset, final String name )
{
this.offset = offset;
this.name = name;
}
public int compareTo( final Object o )
{
if ( o == null || !( o instanceof HolidayEntry ) )
{
return -1;
}
HolidayEntry other = (HolidayEntry) o;
if ( this.offset != other.offset )
{
return this.offset - other.offset;
}
return this.name.compareTo( other.name );
}
public boolean equals( final Object o )
{
if ( o == null || !( o instanceof HolidayEntry ) )
{
return false;
}
HolidayEntry other = (HolidayEntry) o;
return ( this.offset == other.offset ) && this.name.equals( other.name );
}
public String toString()
{
return this.name + ": " + getDayCountAsString( offset );
}
}
public static final String getHoliday()
{
return HolidayDatabase.getHoliday( new Date(), false );
}
public static final String getHoliday( final Date time )
{
return HolidayDatabase.getHoliday( time, false );
}
/**
* Returns the KoL holiday associated with the given date in the real world.
*/
public static final String getHoliday( final Date time, final boolean showPrediction )
{
int calendarDay = HolidayDatabase.getCalendarDay( time );
int[] calendarDayAsArray = HolidayDatabase.convertCalendarDayToArray( calendarDay );
String gameHoliday = HolidayDatabase.HOLIDAYS[ calendarDayAsArray[ 0 ] ][ calendarDayAsArray[ 1 ] ];
String realHoliday = HolidayDatabase.getRealLifeHoliday( KoLConstants.DAILY_FORMAT.format( time ) );
if ( showPrediction && realHoliday == null )
{
if ( gameHoliday != null )
{
gameHoliday = gameHoliday + " today";
}
else
{
calendarDayAsArray = HolidayDatabase.convertCalendarDayToArray( ( calendarDay + 1 ) % 96 );
gameHoliday = HolidayDatabase.HOLIDAYS[ calendarDayAsArray[ 0 ] ][ calendarDayAsArray[ 1 ] ];
if ( gameHoliday != null )
{
gameHoliday = gameHoliday + " tomorrow";
}
else
{
for ( int i = 2; i < 96 && gameHoliday == null; ++i )
{
calendarDayAsArray = HolidayDatabase.convertCalendarDayToArray( ( calendarDay + i ) % 96 );
gameHoliday = HolidayDatabase.HOLIDAYS[ calendarDayAsArray[ 0 ] ][ calendarDayAsArray[ 1 ] ];
if ( gameHoliday != null )
{
gameHoliday = HolidayDatabase.getDayCountAsString( i ) + " until " + gameHoliday;
}
}
}
}
}
return gameHoliday == null && realHoliday == null ? "" : gameHoliday == null ? realHoliday : realHoliday == null ? gameHoliday : realHoliday + " / " + gameHoliday;
}
private static String cachedYear = "";
private static String easter = "";
private static String thanksgiving = "";
public static final String getRealLifeHoliday( final String stringDate )
{
String currentYear = stringDate.substring( 0, 4 );
if ( !currentYear.equals( HolidayDatabase.cachedYear ) )
{
HolidayDatabase.cachedYear = currentYear;
Calendar holidayFinder = Calendar.getInstance( TimeZone.getTimeZone( "GMT-5" ) );
// Apparently, Easter isn't the second Sunday in April;
// it actually depends on the occurrence of the first
// ecclesiastical full moon after the Spring Equinox
// (http://aa.usno.navy.mil/faq/docs/easter.html)
int y = StringUtilities.parseInt( currentYear );
int c = y / 100;
int n = y - 19 * y / 19;
int k = ( c - 17 ) / 25;
int i = c - c / 4 - ( c - k ) / 3 + 19 * n + 15;
i = i - 30 * i / 30;
i = i - i / 28 * ( 1 - i / 28 * 29 / ( i + 1 ) * ( 21 - n ) / 11 );
int j = y + y / 4 + i + 2 - c + c / 4;
j = j - 7 * j / 7;
int l = i - j;
int m = 3 + ( l + 40 ) / 44;
int d = l + 28 - 31 * m / 4;
holidayFinder.set( Calendar.YEAR, y );
holidayFinder.set( Calendar.MONTH, m - 1 );
holidayFinder.set( Calendar.DAY_OF_MONTH, d );
HolidayDatabase.easter = KoLConstants.DAILY_FORMAT.format( holidayFinder.getTime() );
holidayFinder.set( Calendar.MONTH, Calendar.NOVEMBER );
switch ( holidayFinder.get( Calendar.DAY_OF_WEEK ) )
{
case Calendar.FRIDAY:
HolidayDatabase.thanksgiving = "1128";
break;
case Calendar.SATURDAY:
HolidayDatabase.thanksgiving = "1127";
break;
case Calendar.SUNDAY:
HolidayDatabase.thanksgiving = "1126";
break;
case Calendar.MONDAY:
HolidayDatabase.thanksgiving = "1125";
break;
case Calendar.TUESDAY:
HolidayDatabase.thanksgiving = "1124";
break;
case Calendar.WEDNESDAY:
HolidayDatabase.thanksgiving = "1123";
break;
case Calendar.THURSDAY:
HolidayDatabase.thanksgiving = "1122";
break;
}
}
// Real-life holiday list borrowed from JRSiebz's
// variables for HOLIDAYS on the KoL JS Almanac
// (http://home.cinci.rr.com/jrsiebz/KoL/almanac.html)
if ( stringDate.endsWith( "0214" ) )
{
return "Valentine's Day";
}
if ( stringDate.endsWith( "0317" ) )
{
return "St. Sneaky Pete's Day";
}
if ( stringDate.equals( HolidayDatabase.easter ) )
{
return "Oyster Egg Day";
}
if ( stringDate.endsWith( HolidayDatabase.thanksgiving ) )
{
return "Feast of Boris";
}
if ( stringDate.endsWith( "1031" ) )
{
return "Halloween";
}
return HolidayDatabase.getRealLifeOnlyHoliday( stringDate );
}
public static final String getRealLifeOnlyHoliday( final String stringDate )
{
if ( stringDate.endsWith( "0202" ) )
{
return "Groundhog Day";
}
if ( stringDate.endsWith( "0401" ) )
{
return "April Fool's Day";
}
if ( stringDate.endsWith( "0919" ) )
{
return "Talk Like a Pirate Day";
}
if ( stringDate.endsWith( "1225" ) )
{
return "Crimbo";
}
if ( stringDate.endsWith( "1022" ) )
{
return "Holatuwol's Birthday";
}
if ( stringDate.endsWith( "0923" ) )
{
return "Veracity's Birthday";
}
return null;
}
public static final void addPredictionHTML( final StringBuffer displayHTML, final Date today, final int phaseStep )
{
HolidayDatabase.addPredictionHTML( displayHTML, today, phaseStep, true );
}
public static final void addPredictionHTML( final StringBuffer displayHTML, final Date today, final int phaseStep,
final boolean addStatDays )
{
// Next display the upcoming stat days.
if ( addStatDays )
{
displayHTML.append( "<nobr><b>Muscle Day</b>: " );
displayHTML.append( HolidayDatabase.getDayCountAsString( Math.min(
( 24 - phaseStep ) % 16, ( 25 - phaseStep ) % 16 ) ) );
displayHTML.append( "</nobr><br>" );
displayHTML.append( "<nobr><b>Mysticality Day</b>: " );
displayHTML.append( HolidayDatabase.getDayCountAsString( Math.min(
( 20 - phaseStep ) % 16, ( 28 - phaseStep ) % 16 ) ) );
displayHTML.append( "</nobr><br>" );
displayHTML.append( "<nobr><b>Moxie Day</b>: " );
displayHTML.append( HolidayDatabase.getDayCountAsString( Math.min(
( 16 - phaseStep ) % 16, ( 31 - phaseStep ) % 16 ) ) );
displayHTML.append( "</nobr><br> <br>" );
}
// Next display the upcoming holidays. This is done
// through loop calculations in order to minimize the
// amount of code done to handle individual holidays.
String[] holidayPredictions = HolidayDatabase.getHolidayPredictions( today );
for ( int i = 0; i < holidayPredictions.length; ++i )
{
displayHTML.append( "<nobr><b>" );
displayHTML.append( holidayPredictions[ i ].replaceAll( ":", ":</b> " ) );
displayHTML.append( "</nobr><br>" );
}
}
}
The table below shows all metrics for HolidayDatabase.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 114.00 | Number of blocks | |
| BLOCK_COMMENT | 0.00 | Number of block comment lines | |
| COMMENTS | 182.00 | Comment lines | |
| COMMENT_DENSITY | 0.40 | Comment density | |
| COMPARISONS | 85.00 | Number of comparison operators | |
| CYCLOMATIC | 153.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 32.00 | Comments in declarations | |
| DOC_COMMENT | 129.00 | Number of javadoc comment lines | |
| ELOC | 454.00 | Effective lines of code | |
| EXEC_COMMENTS | 17.00 | Comments in executable code | |
| EXITS | 50.00 | Procedure exits | |
| FUNCTIONS | 48.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 107.25 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 147.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 0.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 1.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 1.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 0.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 1.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 2.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 101.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 0.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 5.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 1.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 31.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 25.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 0.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 0.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 5.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 18.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 1.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 3.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 1.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 0.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 1.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 2.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 1747.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 0.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 3.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 0.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 1.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 0.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 0.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 1.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 1057.00 | Number of lines in the source file | |
| LINE_COMMENT | 53.00 | Number of line comments | |
| LOC | 694.00 | Lines of code | |
| LOGICAL_LINES | 292.00 | Number of statements | |
| LOOPS | 16.00 | Number of loops | |
| NEST_DEPTH | 6.00 | Maximum nesting depth | |
| OPERANDS | 1445.00 | Number of operands | |
| OPERATORS | 2691.00 | Number of operators | |
| PARAMS | 58.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 4136.00 | Halstead program length | |
| PROGRAM_VOCAB | 441.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 89.00 | Number of return points from functions | |
| SIZE | 31233.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 384.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 57.00 | Number of unique operators | |
| WHITESPACE | 181.00 | Number of whitespace lines | |