mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-10 20:05:49 +00:00
Renamed several classes that had Julian in front.
Changed them to nsCal.
i.e. Julian_Duration -> nsCalDuration.
JulianRecurrenceID -> nsCalRecurrenceID.
This commit is contained in:
jsun%netscape.com
parent
8ab8bed7e3
commit
ca1414e764
@ -412,19 +412,19 @@ public:
|
||||
* adds a duration amount to this datetime
|
||||
* @param d the duration to add
|
||||
*/
|
||||
void add(Julian_Duration d);
|
||||
void add(nsCalDuration d);
|
||||
|
||||
/**
|
||||
* subtracts a duration amount from this datetime
|
||||
* @param d the duration to subtract
|
||||
*/
|
||||
void subtract(Julian_Duration d);
|
||||
void subtract(nsCalDuration d);
|
||||
|
||||
/**
|
||||
* given two datetimes, return the duration length between them.
|
||||
* if end before start, return an invalid duration.
|
||||
*/
|
||||
static Julian_Duration & getDuration(DateTime start, DateTime end, Julian_Duration & out);
|
||||
static nsCalDuration & getDuration(DateTime start, DateTime end, nsCalDuration & out);
|
||||
|
||||
/**
|
||||
* Clears all fields
|
||||
|
||||
@ -30,18 +30,18 @@
|
||||
#include "nscalutilexp.h"
|
||||
|
||||
/**
|
||||
* The Julian_Duration class implements the "duration" data type.
|
||||
* The nsCalDuration class implements the "duration" data type.
|
||||
* The "duration" data type is used to identify properties that contain
|
||||
* a duration of time.
|
||||
* For example:
|
||||
*
|
||||
* P10Y3M15DT5H30M20S
|
||||
*
|
||||
* The Julian_Duration class models the duration datatype specified in the iCalendar document.
|
||||
* The nsCalDuration class models the duration datatype specified in the iCalendar document.
|
||||
* Assertion: if week value is not equal is zero, then all other values must be zero
|
||||
*
|
||||
*/
|
||||
class NS_CAL_UTIL Julian_Duration
|
||||
class NS_CAL_UTIL nsCalDuration
|
||||
{
|
||||
private:
|
||||
|
||||
@ -80,7 +80,7 @@ private:
|
||||
void setInvalidDuration();
|
||||
|
||||
/**
|
||||
* parse an iCal Julian_Duration string and populate the data members
|
||||
* parse an iCal nsCalDuration string and populate the data members
|
||||
*
|
||||
* @param us the iCal Duraton string
|
||||
*/
|
||||
@ -95,34 +95,34 @@ public:
|
||||
/**
|
||||
* default constrctor, set duration to 5 min.
|
||||
*/
|
||||
Julian_Duration();
|
||||
nsCalDuration();
|
||||
|
||||
/**
|
||||
* Constructs a Julian_Duration object using the grammar
|
||||
* Constructs a nsCalDuration object using the grammar
|
||||
* defined in the iCalendar spec.
|
||||
*
|
||||
* @param s String to parse
|
||||
*/
|
||||
Julian_Duration(UnicodeString & us);
|
||||
nsCalDuration(UnicodeString & us);
|
||||
|
||||
/**
|
||||
* Constructs a copy of a Julian_Duration object.
|
||||
* Constructs a copy of a nsCalDuration object.
|
||||
*
|
||||
* @param d Julian_Duration to copy
|
||||
* @param d nsCalDuration to copy
|
||||
*/
|
||||
Julian_Duration(Julian_Duration & aDuration);
|
||||
nsCalDuration(nsCalDuration & aDuration);
|
||||
|
||||
/**
|
||||
* Constructs a Julian_Duration object with a single value set.
|
||||
* Constructs a nsCalDuration object with a single value set.
|
||||
* Always yields a positive Duration
|
||||
*
|
||||
* @param type the field to set (uses <code>Recurrence</code> type constants)
|
||||
* @param value value to assign the field
|
||||
*/
|
||||
Julian_Duration(t_int32 type, t_int32 value);
|
||||
nsCalDuration(t_int32 type, t_int32 value);
|
||||
|
||||
/**
|
||||
* Constructs a Julian_Duration object with a single value set.
|
||||
* Constructs a nsCalDuration object with a single value set.
|
||||
* Always yields a positive Duration
|
||||
* Setting the week != 0 automatically ignores other param values and sets them to 0.
|
||||
* Setting any param (year,month,day,hour,min,sec) < 0 automatically creates an invalid Duration.
|
||||
@ -136,12 +136,12 @@ public:
|
||||
* @param week intiial week value
|
||||
* @param isNegativeDuration TRUE if duration is negative, FALSE otherwise
|
||||
*/
|
||||
Julian_Duration(t_int32 year, t_int32 month, t_int32 day, t_int32 hour, t_int32 min,
|
||||
nsCalDuration(t_int32 year, t_int32 month, t_int32 day, t_int32 hour, t_int32 min,
|
||||
t_int32 sec, t_int32 week, t_bool bNegativeDuration = FALSE);
|
||||
/**
|
||||
* Destructor.
|
||||
*/
|
||||
~Julian_Duration();
|
||||
~nsCalDuration();
|
||||
|
||||
/*-----------------------------
|
||||
** GETTERS and SETTERS
|
||||
@ -295,12 +295,12 @@ public:
|
||||
|
||||
/**
|
||||
* Comparision method.
|
||||
* @param d Julian_Duration to compare to.
|
||||
* @param d nsCalDuration to compare to.
|
||||
*
|
||||
* @return -1 if this is shorter, 0 if equal, 1 if longer
|
||||
* length of duration
|
||||
*/
|
||||
t_int32 compareTo(const Julian_Duration &d);
|
||||
t_int32 compareTo(const nsCalDuration &d);
|
||||
|
||||
/**
|
||||
* Normalizes the current duration. This means rounding off
|
||||
@ -325,16 +325,16 @@ public:
|
||||
t_bool isZeroLength();
|
||||
|
||||
/**
|
||||
* returns this Julian_Duration object to a UnicodeString
|
||||
* returns this nsCalDuration object to a UnicodeString
|
||||
*
|
||||
* @return a UnicodeString representing the human-readable format of this Julian_Duration
|
||||
* @return a UnicodeString representing the human-readable format of this nsCalDuration
|
||||
*/
|
||||
UnicodeString toString();
|
||||
|
||||
/**
|
||||
* returns this Julian_Duration object to a UnicodeString
|
||||
* returns this nsCalDuration object to a UnicodeString
|
||||
*
|
||||
* @return a UnicodeString representing the iCal format of this Julian_Duration
|
||||
* @return a UnicodeString representing the iCal format of this nsCalDuration
|
||||
*/
|
||||
UnicodeString toICALString();
|
||||
|
||||
@ -353,44 +353,44 @@ public:
|
||||
/**
|
||||
* assignment operator
|
||||
*
|
||||
* @param d Julian_Duration to copy
|
||||
* @return a copy of that Julian_Duration
|
||||
* @param d nsCalDuration to copy
|
||||
* @return a copy of that nsCalDuration
|
||||
*/
|
||||
const Julian_Duration &operator=(const Julian_Duration & d);
|
||||
const nsCalDuration &operator=(const nsCalDuration & d);
|
||||
|
||||
/**
|
||||
* (==) equality operator
|
||||
*
|
||||
* @param d Julian_Duration to copy
|
||||
* @param d nsCalDuration to copy
|
||||
* @return TRUE if this is equal to d, otherwise FALSE
|
||||
*/
|
||||
t_bool operator==(const Julian_Duration & that);
|
||||
t_bool operator==(const nsCalDuration & that);
|
||||
|
||||
/**
|
||||
* (!=) in-equality operator
|
||||
*
|
||||
* @param d Julian_Duration to copy
|
||||
* @param d nsCalDuration to copy
|
||||
* @return TRUE if this NOT equal to d, otherwise FALSE
|
||||
*/
|
||||
t_bool operator!=(const Julian_Duration & that);
|
||||
t_bool operator!=(const nsCalDuration & that);
|
||||
|
||||
/*-- TODO - make normalize work so that >, < will work correctly */
|
||||
|
||||
/**
|
||||
* (>) greater than operator
|
||||
*
|
||||
* @param d Julian_Duration to copy
|
||||
* @param d nsCalDuration to copy
|
||||
* @return TRUE if this is longer duration than d, otherwise FALSE
|
||||
*/
|
||||
t_bool operator>(const Julian_Duration & that);
|
||||
t_bool operator>(const nsCalDuration & that);
|
||||
|
||||
/**
|
||||
* (<) less than operator
|
||||
*
|
||||
* @param d Julian_Duration to copy
|
||||
* @param d nsCalDuration to copy
|
||||
* @return TRUE if this is shorter duration than d, otherwise FALSE
|
||||
*/
|
||||
t_bool operator<(const Julian_Duration & that);
|
||||
t_bool operator<(const nsCalDuration & that);
|
||||
};
|
||||
|
||||
#endif /* __DURATION_H_ */
|
||||
|
||||
@ -22,8 +22,8 @@
|
||||
* 2/3/98 10:12:32 AM
|
||||
*/
|
||||
|
||||
#ifndef __JULIANUTILITY_H_
|
||||
#define __JULIANUTILITY_H_
|
||||
#ifndef __NSCALUTILITY_H_
|
||||
#define __NSCALUTILITY_H_
|
||||
|
||||
#include <unistring.h>
|
||||
#include <calendar.h>
|
||||
@ -36,14 +36,14 @@
|
||||
* Also defines the RecurrenceType, which is used by the
|
||||
* generator and Recurrence classes for defining span and interval lengths.
|
||||
*/
|
||||
class NS_CAL_UTIL JulianUtility
|
||||
class NS_CAL_UTIL nsCalUtility
|
||||
{
|
||||
private:
|
||||
|
||||
/**
|
||||
* Hide constructor from clients
|
||||
*/
|
||||
JulianUtility();
|
||||
nsCalUtility();
|
||||
|
||||
public:
|
||||
|
||||
@ -124,5 +124,5 @@ public:
|
||||
static UnicodeString & addDoubleQuotes(UnicodeString & us);
|
||||
};
|
||||
|
||||
#endif /* __JULIANUTILITY_H_ */
|
||||
#endif /* __NSCALUTILITY_H_ */
|
||||
|
||||
|
||||
@ -48,13 +48,13 @@ public:
|
||||
NS_IMETHOD SetMinute(PRUint32 aMinute);
|
||||
NS_IMETHOD SetSecond(PRUint32 aSecond);
|
||||
|
||||
NS_IMETHOD_(Julian_Duration&) GetDuration();
|
||||
NS_IMETHOD_(nsCalDuration&) GetDuration();
|
||||
|
||||
protected:
|
||||
~nsDuration();
|
||||
|
||||
private:
|
||||
Julian_Duration * mDuration;
|
||||
nsCalDuration * mDuration;
|
||||
|
||||
};
|
||||
|
||||
|
||||
@ -22,8 +22,8 @@
|
||||
* 3/19/98 5:35:59 PM
|
||||
*/
|
||||
|
||||
#ifndef __JULIANUIDRANDOMGENERATOR_H_
|
||||
#define __JULIANUIDRANDOMGENERATOR_H_
|
||||
#ifndef __NSCALRANDOMGENERATOR_H_
|
||||
#define __NSCALRANDOMGENERATOR_H_
|
||||
|
||||
#include <unistring.h>
|
||||
#include "nscalutilexp.h"
|
||||
@ -31,14 +31,14 @@
|
||||
/**
|
||||
* Class that contains method to generate random UID strings.
|
||||
*/
|
||||
class NS_CAL_UTIL JulianUIDRandomGenerator
|
||||
class NS_CAL_UTIL nsCalUIDRandomGenerator
|
||||
{
|
||||
public:
|
||||
/** default constructor. It's of no use */
|
||||
JulianUIDRandomGenerator();
|
||||
nsCalUIDRandomGenerator();
|
||||
|
||||
/** destructor. It's of no use */
|
||||
~JulianUIDRandomGenerator();
|
||||
~nsCalUIDRandomGenerator();
|
||||
|
||||
/**
|
||||
* generates random UID strings by appending
|
||||
@ -63,5 +63,5 @@ public:
|
||||
static UnicodeString generate(UnicodeString us);
|
||||
};
|
||||
|
||||
#endif /*__JULIANUIDRANDOMGENERATOR_H_ */
|
||||
#endif /*__NSCALRANDOMGENERATOR_H_ */
|
||||
|
||||
|
||||
@ -760,7 +760,7 @@ void DateTime::add(Calendar::EDateFields aField, t_int32 amount)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void DateTime::add(Julian_Duration d)
|
||||
void DateTime::add(nsCalDuration d)
|
||||
{
|
||||
add(Calendar::YEAR, d.getYear());
|
||||
add(Calendar::MONTH, d.getMonth());
|
||||
@ -773,7 +773,7 @@ void DateTime::add(Julian_Duration d)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void DateTime::subtract(Julian_Duration d)
|
||||
void DateTime::subtract(nsCalDuration d)
|
||||
{
|
||||
add(Calendar::YEAR, - d.getYear());
|
||||
add(Calendar::MONTH, - d.getMonth());
|
||||
@ -785,8 +785,8 @@ void DateTime::subtract(Julian_Duration d)
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
Julian_Duration & DateTime::getDuration(DateTime start, DateTime end,
|
||||
Julian_Duration & out)
|
||||
nsCalDuration & DateTime::getDuration(DateTime start, DateTime end,
|
||||
nsCalDuration & out)
|
||||
{
|
||||
t_int32 y = 0, mo = 0, d = 0, h = 0, m = 0, s = 0;
|
||||
t_int32 toNextMonth = 0;
|
||||
@ -1370,15 +1370,15 @@ DateTime::IsParseable(UnicodeString & s, t_int32 & iYear, t_int32 & iMonth,
|
||||
|
||||
/*
|
||||
// old way, works but slow and leaks
|
||||
iYear = JulianUtility::atot_int32(s.extract(0, 4, temp).toCString(""), bParseError, 4);
|
||||
iMonth = JulianUtility::atot_int32(s.extract(4, 2, temp).toCString(""), bParseError, 2);
|
||||
iDay = JulianUtility::atot_int32(s.extract(6, 2, temp).toCString(""), bParseError, 2);
|
||||
iYear = nsCalUtility::atot_int32(s.extract(0, 4, temp).toCString(""), bParseError, 4);
|
||||
iMonth = nsCalUtility::atot_int32(s.extract(4, 2, temp).toCString(""), bParseError, 2);
|
||||
iDay = nsCalUtility::atot_int32(s.extract(6, 2, temp).toCString(""), bParseError, 2);
|
||||
*/
|
||||
|
||||
// new way is faster, but uses ptr arithmetic
|
||||
iYear = JulianUtility::atot_int32(c, bParseError, 4);
|
||||
iMonth = JulianUtility::atot_int32(c + 4, bParseError, 2);
|
||||
iDay = JulianUtility::atot_int32(c + 6, bParseError, 2);
|
||||
iYear = nsCalUtility::atot_int32(c, bParseError, 4);
|
||||
iMonth = nsCalUtility::atot_int32(c + 4, bParseError, 2);
|
||||
iDay = nsCalUtility::atot_int32(c + 6, bParseError, 2);
|
||||
|
||||
if (iMonth > 12 || iDay > 31)
|
||||
{
|
||||
@ -1394,15 +1394,15 @@ DateTime::IsParseable(UnicodeString & s, t_int32 & iYear, t_int32 & iMonth,
|
||||
{
|
||||
/*
|
||||
// old way, works but slow
|
||||
iHour = JulianUtility::atot_int32(s.extract(9, 2, temp).toCString(""), bParseError, 2);
|
||||
iMinute= JulianUtility::atot_int32(s.extract(11, 2, temp).toCString(""), bParseError, 2);
|
||||
iSecond= JulianUtility::atot_int32(s.extract(13, 2, temp).toCString(""), bParseError, 2);
|
||||
iHour = nsCalUtility::atot_int32(s.extract(9, 2, temp).toCString(""), bParseError, 2);
|
||||
iMinute= nsCalUtility::atot_int32(s.extract(11, 2, temp).toCString(""), bParseError, 2);
|
||||
iSecond= nsCalUtility::atot_int32(s.extract(13, 2, temp).toCString(""), bParseError, 2);
|
||||
*/
|
||||
|
||||
// new way is faster, but uses ptr arithmetic
|
||||
iHour = JulianUtility::atot_int32(c + 9, bParseError, 2);
|
||||
iMinute = JulianUtility::atot_int32(c + 11, bParseError, 2);
|
||||
iSecond = JulianUtility::atot_int32(c + 13, bParseError, 2);
|
||||
iHour = nsCalUtility::atot_int32(c + 9, bParseError, 2);
|
||||
iMinute = nsCalUtility::atot_int32(c + 11, bParseError, 2);
|
||||
iSecond = nsCalUtility::atot_int32(c + 13, bParseError, 2);
|
||||
|
||||
if (iHour > 23 || iMinute > 59 || iSecond > 59)
|
||||
{
|
||||
@ -1459,12 +1459,12 @@ t_bool DateTime::IsParseableUTCOffset(UnicodeString & s,
|
||||
|
||||
/*
|
||||
// old way, works but slow and leaks
|
||||
iHour = JulianUtility::atot_int32(s.extract(1, 2, u).toCString(""), bParseError, 2);
|
||||
iMin = JulianUtility::atot_int32(s.extract(3, 2, u).toCString(""), bParseError, 2);
|
||||
iHour = nsCalUtility::atot_int32(s.extract(1, 2, u).toCString(""), bParseError, 2);
|
||||
iMin = nsCalUtility::atot_int32(s.extract(3, 2, u).toCString(""), bParseError, 2);
|
||||
*/
|
||||
|
||||
iHour = JulianUtility::atot_int32(cc + 1, bParseError, 2);
|
||||
iMin = JulianUtility::atot_int32(cc + 3, bParseError, 2);
|
||||
iHour = nsCalUtility::atot_int32(cc + 1, bParseError, 2);
|
||||
iMin = nsCalUtility::atot_int32(cc + 3, bParseError, 2);
|
||||
|
||||
delete [] cc;
|
||||
|
||||
|
||||
@ -30,10 +30,10 @@
|
||||
#include "jutility.h"
|
||||
|
||||
// turn this flag on to allow for parsing of year and month
|
||||
#define JULIAN_DURATION_PARSING_YEAR_AND_MONTH 1
|
||||
#define NSCALDURATION_PARSING_YEAR_AND_MONTH 1
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void Julian_Duration::setInvalidDuration()
|
||||
void nsCalDuration::setInvalidDuration()
|
||||
{
|
||||
m_iYear = -1;
|
||||
m_iMonth = -1;
|
||||
@ -46,7 +46,7 @@ void Julian_Duration::setInvalidDuration()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void Julian_Duration::parse(UnicodeString & us)
|
||||
void nsCalDuration::parse(UnicodeString & us)
|
||||
{
|
||||
// NOTE: use a better algorithm like a regexp scanf or something.
|
||||
|
||||
@ -56,7 +56,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
t_bool bErrorInParse = FALSE;
|
||||
t_int32 startOfParse = 0, indexOfT = 0, endOfParse = 0;
|
||||
t_int32 day = 0, hour = 0, minute = 0, second = 0, week = 0;
|
||||
#if JULIAN_DURATION_PARSING_YEAR_AND_MONTH
|
||||
#if NSCALDURATION_PARSING_YEAR_AND_MONTH
|
||||
t_int32 year = 0, month = 0;
|
||||
t_int32 indexOfY = 0, indexOfMo = 0;
|
||||
#endif
|
||||
@ -98,14 +98,14 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
startOfParse = 0;
|
||||
endOfParse = sSection.size();
|
||||
|
||||
#if JULIAN_DURATION_PARSING_YEAR_AND_MONTH
|
||||
#if NSCALDURATION_PARSING_YEAR_AND_MONTH
|
||||
indexOfY = sSection.indexOf('Y');
|
||||
if (indexOfY >= 0)
|
||||
{
|
||||
sVal = sSection.extractBetween(startOfParse, indexOfY, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
year = JulianUtility::atot_int32(cc,
|
||||
year = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
startOfParse = indexOfY + 1;
|
||||
@ -116,7 +116,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
sVal = sSection.extractBetween(startOfParse, indexOfMo, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
month = JulianUtility::atot_int32(cc,
|
||||
month = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
startOfParse = indexOfMo + 1;
|
||||
@ -128,12 +128,12 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
sVal = sSection.extractBetween(startOfParse, indexOfD, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
day = JulianUtility::atot_int32(cc,
|
||||
day = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
startOfParse = indexOfD + 1;
|
||||
}
|
||||
#if JULIAN_DURATION_PARSING_YEAR_AND_MONTH
|
||||
#if NSCALDURATION_PARSING_YEAR_AND_MONTH
|
||||
if (sSection.size() >= 1 && indexOfY == -1 &&
|
||||
indexOfMo == -1 && indexOfD == -1)
|
||||
{
|
||||
@ -173,7 +173,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
sVal = sSection.extractBetween(startOfParse, indexOfH, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
hour = JulianUtility::atot_int32(cc,
|
||||
hour = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
startOfParse = indexOfH + 1;
|
||||
@ -184,7 +184,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
sVal = sSection.extractBetween(startOfParse, indexOfMi, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
minute = JulianUtility::atot_int32(cc,
|
||||
minute = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
startOfParse = indexOfMi + 1;
|
||||
@ -195,7 +195,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
sVal = sSection.extractBetween(startOfParse, indexOfS, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
second = JulianUtility::atot_int32(cc,
|
||||
second = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
startOfParse = indexOfS + 1;
|
||||
@ -228,13 +228,13 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
sVal = us.extractBetween(1, us.size() - 1, sVal);
|
||||
cc = sVal.toCString("");
|
||||
PR_ASSERT(cc != 0);
|
||||
week = JulianUtility::atot_int32(cc,
|
||||
week = nsCalUtility::atot_int32(cc,
|
||||
bErrorInParse, sVal.size());
|
||||
delete [] cc;
|
||||
}
|
||||
}
|
||||
//if (FALSE) TRACE("parse: %d W, %d Y %d M %d D T %d H %d M %d S\r\n", week, year, month, day, hour, minute, second);
|
||||
#if JULIAN_DURATION_PARSING_YEAR_AND_MONTH
|
||||
#if NSCALDURATION_PARSING_YEAR_AND_MONTH
|
||||
if (year < 0 || month < 0 || day < 0 ||
|
||||
hour < 0 || minute < 0 || second < 0 || week < 0)
|
||||
bErrorInParse = TRUE;
|
||||
@ -251,7 +251,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
}
|
||||
else
|
||||
{
|
||||
#if JULIAN_DURATION_PARSING_YEAR_AND_MONTH
|
||||
#if NSCALDURATION_PARSING_YEAR_AND_MONTH
|
||||
|
||||
m_iYear = year;
|
||||
m_iMonth = month;
|
||||
@ -276,7 +276,7 @@ void Julian_Duration::parse(UnicodeString & us)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
Julian_Duration::Julian_Duration()
|
||||
nsCalDuration::nsCalDuration()
|
||||
:
|
||||
m_iYear(0),m_iMonth(0),m_iDay(0),m_iHour(0),
|
||||
m_iMinute(0),m_iSecond(0), m_iWeek(0),
|
||||
@ -286,7 +286,7 @@ Julian_Duration::Julian_Duration()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
Julian_Duration::Julian_Duration(UnicodeString & us)
|
||||
nsCalDuration::nsCalDuration(UnicodeString & us)
|
||||
:
|
||||
m_iYear(0),m_iMonth(0),m_iDay(0),m_iHour(0),
|
||||
m_iMinute(0),m_iSecond(0), m_iWeek(0),
|
||||
@ -297,7 +297,7 @@ Julian_Duration::Julian_Duration(UnicodeString & us)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
Julian_Duration::Julian_Duration(t_int32 type, t_int32 value)
|
||||
nsCalDuration::nsCalDuration(t_int32 type, t_int32 value)
|
||||
:
|
||||
m_iYear(0),m_iMonth(0),m_iDay(0),m_iHour(0),
|
||||
m_iMinute(0),m_iSecond(0), m_iWeek(0),
|
||||
@ -305,22 +305,22 @@ Julian_Duration::Julian_Duration(t_int32 type, t_int32 value)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case JulianUtility::RT_MINUTELY:
|
||||
case nsCalUtility::RT_MINUTELY:
|
||||
m_iMinute = value;
|
||||
break;
|
||||
case JulianUtility::RT_HOURLY:
|
||||
case nsCalUtility::RT_HOURLY:
|
||||
m_iHour = value;
|
||||
break;
|
||||
case JulianUtility::RT_DAILY:
|
||||
case nsCalUtility::RT_DAILY:
|
||||
m_iDay = value;
|
||||
break;
|
||||
case JulianUtility::RT_WEEKLY:
|
||||
case nsCalUtility::RT_WEEKLY:
|
||||
m_iWeek = value;
|
||||
break;
|
||||
case JulianUtility::RT_MONTHLY:
|
||||
case nsCalUtility::RT_MONTHLY:
|
||||
m_iMonth = value;
|
||||
break;
|
||||
case JulianUtility::RT_YEARLY:
|
||||
case nsCalUtility::RT_YEARLY:
|
||||
m_iYear = value;
|
||||
break;
|
||||
default:
|
||||
@ -330,7 +330,7 @@ Julian_Duration::Julian_Duration(t_int32 type, t_int32 value)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
Julian_Duration::Julian_Duration(Julian_Duration & d)
|
||||
nsCalDuration::nsCalDuration(nsCalDuration & d)
|
||||
:
|
||||
m_iYear(0),m_iMonth(0),m_iDay(0),m_iHour(0),
|
||||
m_iMinute(0),m_iSecond(0), m_iWeek(0),
|
||||
@ -360,7 +360,7 @@ Julian_Duration::Julian_Duration(Julian_Duration & d)
|
||||
}
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
Julian_Duration::Julian_Duration(t_int32 year, t_int32 month, t_int32 day,
|
||||
nsCalDuration::nsCalDuration(t_int32 year, t_int32 month, t_int32 day,
|
||||
t_int32 hour, t_int32 min, t_int32 sec,
|
||||
t_int32 week, t_bool bNegativeDuration)
|
||||
{
|
||||
@ -382,7 +382,7 @@ Julian_Duration::Julian_Duration(t_int32 year, t_int32 month, t_int32 day,
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
Julian_Duration::~Julian_Duration()
|
||||
nsCalDuration::~nsCalDuration()
|
||||
{
|
||||
}
|
||||
|
||||
@ -391,7 +391,7 @@ Julian_Duration::~Julian_Duration()
|
||||
///////////////////////////////////
|
||||
// GETTERS AND SETTERS
|
||||
///////////////////////////////////
|
||||
void Julian_Duration::set(t_int32 year, t_int32 month, t_int32 day,
|
||||
void nsCalDuration::set(t_int32 year, t_int32 month, t_int32 day,
|
||||
t_int32 hour, t_int32 min, t_int32 sec, t_bool
|
||||
bNegativeDuration)
|
||||
{
|
||||
@ -405,7 +405,7 @@ void Julian_Duration::set(t_int32 year, t_int32 month, t_int32 day,
|
||||
m_iWeek = 0;
|
||||
}
|
||||
|
||||
void Julian_Duration::set(t_int32 week, t_bool bNegativeDuration)
|
||||
void nsCalDuration::set(t_int32 week, t_bool bNegativeDuration)
|
||||
{
|
||||
m_iWeek = week;
|
||||
m_NegativeDuration = bNegativeDuration;
|
||||
@ -417,49 +417,49 @@ void Julian_Duration::set(t_int32 week, t_bool bNegativeDuration)
|
||||
m_iSecond = 0;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getYear() const
|
||||
t_int32 nsCalDuration::getYear() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iYear);
|
||||
return m_iYear;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getMonth() const
|
||||
t_int32 nsCalDuration::getMonth() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iMonth);
|
||||
return m_iMonth;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getDay() const
|
||||
t_int32 nsCalDuration::getDay() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iDay);
|
||||
return m_iDay;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getHour() const
|
||||
t_int32 nsCalDuration::getHour() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iHour);
|
||||
return m_iHour;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getMinute() const
|
||||
t_int32 nsCalDuration::getMinute() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iMinute);
|
||||
return m_iMinute;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getSecond() const
|
||||
t_int32 nsCalDuration::getSecond() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iSecond);
|
||||
return m_iSecond;
|
||||
}
|
||||
|
||||
t_int32 Julian_Duration::getWeek() const
|
||||
t_int32 nsCalDuration::getWeek() const
|
||||
{
|
||||
if (m_NegativeDuration)
|
||||
return (0 - m_iWeek);
|
||||
@ -474,7 +474,7 @@ t_int32 Julian_Duration::getWeek() const
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void Julian_Duration::setDurationString(UnicodeString & s)
|
||||
void nsCalDuration::setDurationString(UnicodeString & s)
|
||||
{
|
||||
parse(s);
|
||||
}
|
||||
@ -482,7 +482,7 @@ void Julian_Duration::setDurationString(UnicodeString & s)
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
// TODO - will work if only normalize works
|
||||
t_int32 Julian_Duration::compareTo(const Julian_Duration & d)
|
||||
t_int32 nsCalDuration::compareTo(const nsCalDuration & d)
|
||||
{
|
||||
normalize();
|
||||
|
||||
@ -505,7 +505,7 @@ t_int32 Julian_Duration::compareTo(const Julian_Duration & d)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void Julian_Duration::normalize()
|
||||
void nsCalDuration::normalize()
|
||||
{
|
||||
// TODO: RISKY, assumes 30 days in a month, 12 months in a year
|
||||
t_int32 temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0, temp5 = 0;
|
||||
@ -539,7 +539,7 @@ void Julian_Duration::normalize()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void Julian_Duration::unnormalize()
|
||||
void nsCalDuration::unnormalize()
|
||||
{
|
||||
// TODO: watch out for overflow
|
||||
if (m_iYear > 0)
|
||||
@ -557,7 +557,7 @@ void Julian_Duration::unnormalize()
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
t_bool
|
||||
Julian_Duration::isZeroLength()
|
||||
nsCalDuration::isZeroLength()
|
||||
{
|
||||
if (m_iYear <= 0 && m_iMonth <= 0 && m_iDay <= 0 &&
|
||||
m_iHour <= 0 && m_iMinute <= 0 && m_iSecond <= 0 &&
|
||||
@ -569,7 +569,7 @@ Julian_Duration::isZeroLength()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
UnicodeString Julian_Duration::toString()
|
||||
UnicodeString nsCalDuration::toString()
|
||||
{
|
||||
char sBuf[100];
|
||||
char sBuf2[100];
|
||||
@ -602,7 +602,7 @@ UnicodeString Julian_Duration::toString()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
UnicodeString Julian_Duration::toICALString()
|
||||
UnicodeString nsCalDuration::toICALString()
|
||||
{
|
||||
//if (FALSE) TRACE("toString: %d W, %d Y %d M %d D T %d H %d M %d S\r\n", m_iYear, m_iMonth, m_iDay, m_iHour, m_im_iMinute, m_iSecond);
|
||||
|
||||
@ -625,7 +625,7 @@ UnicodeString Julian_Duration::toICALString()
|
||||
#if 1
|
||||
// full form
|
||||
char sNum[100];
|
||||
#if JULIAN_DURATION_PARSING_YEAR_AND_MONTH
|
||||
#if NSCALDURATION_PARSING_YEAR_AND_MONTH
|
||||
sprintf(sNum, "%sP%dY%dM%dDT%dH%dM%dS",
|
||||
((m_NegativeDuration) ? "-" : ""), m_iYear, m_iMonth, m_iDay, m_iHour, m_iMinute, m_iSecond);
|
||||
#else
|
||||
@ -682,7 +682,7 @@ UnicodeString Julian_Duration::toICALString()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
t_bool Julian_Duration::isValid()
|
||||
t_bool nsCalDuration::isValid()
|
||||
{
|
||||
if (m_iYear < 0 || m_iMonth < 0 || m_iDay < 0 ||
|
||||
m_iHour < 0 || m_iMinute < 0 || m_iSecond < 0 ||
|
||||
@ -698,7 +698,7 @@ t_bool Julian_Duration::isValid()
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
const Julian_Duration & Julian_Duration::operator=(const Julian_Duration& d)
|
||||
const nsCalDuration & nsCalDuration::operator=(const nsCalDuration& d)
|
||||
{
|
||||
m_iYear = d.m_iYear;
|
||||
m_iMonth = d.m_iMonth;
|
||||
@ -714,14 +714,14 @@ const Julian_Duration & Julian_Duration::operator=(const Julian_Duration& d)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
t_bool Julian_Duration::operator==(const Julian_Duration & that)
|
||||
t_bool nsCalDuration::operator==(const nsCalDuration & that)
|
||||
{
|
||||
return (compareTo(that) == 0);
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
t_bool Julian_Duration::operator!=(const Julian_Duration & that)
|
||||
t_bool nsCalDuration::operator!=(const nsCalDuration & that)
|
||||
{
|
||||
return (compareTo(that) != 0);
|
||||
}
|
||||
|
||||
@ -25,12 +25,12 @@
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
JulianUtility::JulianUtility() {}
|
||||
nsCalUtility::nsCalUtility() {}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
//t_int32 JulianUtility::atot_int32(const char * nPtr,
|
||||
t_int32 JulianUtility::atot_int32(char * nPtr,
|
||||
//t_int32 nsCalUtility::atot_int32(const char * nPtr,
|
||||
t_int32 nsCalUtility::atot_int32(char * nPtr,
|
||||
t_bool & bParseError,
|
||||
t_int32 size)
|
||||
{
|
||||
@ -54,7 +54,7 @@ t_int32 JulianUtility::atot_int32(char * nPtr,
|
||||
}
|
||||
//---------------------------------------------------------------------
|
||||
#if 0
|
||||
t_int32 JulianUtility::atot_int32(const char * nPtr,
|
||||
t_int32 nsCalUtility::atot_int32(const char * nPtr,
|
||||
t_bool & bParseError,
|
||||
t_int32 size)
|
||||
{
|
||||
@ -74,7 +74,7 @@ t_int32 JulianUtility::atot_int32(const char * nPtr,
|
||||
}
|
||||
#endif
|
||||
//---------------------------------------------------------------------
|
||||
t_bool JulianUtility::checkRange(t_int32 hashCode, JAtom range[],
|
||||
t_bool nsCalUtility::checkRange(t_int32 hashCode, JAtom range[],
|
||||
t_int32 rangeSize)
|
||||
{
|
||||
t_int32 i;
|
||||
@ -89,7 +89,7 @@ t_bool JulianUtility::checkRange(t_int32 hashCode, JAtom range[],
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
void
|
||||
JulianUtility::stripDoubleQuotes(UnicodeString & u)
|
||||
nsCalUtility::stripDoubleQuotes(UnicodeString & u)
|
||||
{
|
||||
if (u.size() > 0)
|
||||
{
|
||||
@ -110,7 +110,7 @@ JulianUtility::stripDoubleQuotes(UnicodeString & u)
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
UnicodeString &
|
||||
JulianUtility::addDoubleQuotes(UnicodeString & us)
|
||||
nsCalUtility::addDoubleQuotes(UnicodeString & us)
|
||||
{
|
||||
if (us.size() != 0)
|
||||
{
|
||||
@ -122,14 +122,14 @@ JulianUtility::addDoubleQuotes(UnicodeString & us)
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
/*
|
||||
char * JulianUtility::unistrToStr(const UnicodeString & us)
|
||||
char * nsCalUtility::unistrToStr(const UnicodeString & us)
|
||||
{
|
||||
return us.toCString("");
|
||||
}
|
||||
*/
|
||||
//---------------------------------------------------------------------
|
||||
/*
|
||||
UnicodeString & JulianUtility::ToUpper(const UnicodeString & eightBitString)
|
||||
UnicodeString & nsCalUtility::ToUpper(const UnicodeString & eightBitString)
|
||||
{
|
||||
t_int32 i;
|
||||
//
|
||||
@ -159,7 +159,7 @@ UnicodeString & JulianUtility::ToUpper(const UnicodeString & eightBitString)
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
void JulianUtility::TRACE_DateTimeVector(JulianPtrArray & vector)
|
||||
void nsCalUtility::TRACE_DateTimeVector(JulianPtrArray & vector)
|
||||
{
|
||||
for (i = 0; i < vector.GetSize(); i++)
|
||||
{
|
||||
|
||||
@ -45,7 +45,7 @@ NS_IMPL_RELEASE(nsDuration)
|
||||
|
||||
nsresult nsDuration :: Init()
|
||||
{
|
||||
mDuration = new Julian_Duration();
|
||||
mDuration = new nsCalDuration();
|
||||
|
||||
return NS_OK ;
|
||||
}
|
||||
@ -184,7 +184,7 @@ nsresult nsDuration :: SetSecond(PRUint32 aSecond)
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
Julian_Duration& nsDuration :: GetDuration()
|
||||
nsCalDuration& nsDuration :: GetDuration()
|
||||
{
|
||||
return (*mDuration);
|
||||
}
|
||||
|
||||
@ -32,20 +32,20 @@
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
JulianUIDRandomGenerator::JulianUIDRandomGenerator()
|
||||
nsCalUIDRandomGenerator::nsCalUIDRandomGenerator()
|
||||
{
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
JulianUIDRandomGenerator::~JulianUIDRandomGenerator()
|
||||
nsCalUIDRandomGenerator::~nsCalUIDRandomGenerator()
|
||||
{
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
UnicodeString
|
||||
JulianUIDRandomGenerator::generate(UnicodeString us)
|
||||
nsCalUIDRandomGenerator::generate(UnicodeString us)
|
||||
{
|
||||
#if 0
|
||||
char sBuf[10];
|
||||
@ -68,7 +68,7 @@ JulianUIDRandomGenerator::generate(UnicodeString us)
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
UnicodeString
|
||||
JulianUIDRandomGenerator::generate()
|
||||
nsCalUIDRandomGenerator::generate()
|
||||
{
|
||||
return generate("");
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user