golden hour

/opt/alt/libicu65/usr/include/unicode

File/Folder	Size	Actions
alphaindex.h	26.48 KB
appendable.h	8.49 KB
basictz.h	9.15 KB
brkiter.h	27.8 KB
bytestream.h	9.6 KB
bytestrie.h	20.77 KB
bytestriebuilder.h	7.08 KB
calendar.h	105.74 KB
caniter.h	7.43 KB
casemap.h	25.33 KB
char16ptr.h	7.22 KB
chariter.h	24.05 KB
choicfmt.h	23.91 KB
coleitr.h	13.76 KB
coll.h	56.23 KB
compactdecimalformat.h	6.88 KB
curramt.h	3.76 KB
currpinf.h	7.3 KB
currunit.h	4.05 KB
datefmt.h	40.67 KB
dbbi.h	1.19 KB
dcfmtsym.h	20.13 KB
decimfmt.h	87.38 KB
docmain.h	6.97 KB
dtfmtsym.h	37.7 KB
dtintrv.h	3.84 KB
dtitvfmt.h	46.63 KB
dtitvinf.h	18.51 KB
dtptngen.h	25.08 KB
dtrule.h	8.68 KB
edits.h	20.74 KB
enumset.h	2.08 KB
errorcode.h	4.84 KB
fieldpos.h	8.69 KB
filteredbrk.h	5.37 KB
fmtable.h	24.42 KB
format.h	12.5 KB
formattedvalue.h	10.27 KB
fpositer.h	3.04 KB
gender.h	3.33 KB
gregocal.h	31.71 KB
icudataver.h	1.03 KB
icuplug.h	11.88 KB
idna.h	12.7 KB
listformatter.h	9.47 KB
localebuilder.h	11.27 KB
localematcher.h	22.5 KB
localpointer.h	19.69 KB
locdspnm.h	7.12 KB
locid.h	47.4 KB
measfmt.h	11.33 KB
measunit.h	93.31 KB
measure.h	4.32 KB
messagepattern.h	33.71 KB
msgfmt.h	44.11 KB
normalizer2.h	34.03 KB
normlzr.h	30.94 KB
nounit.h	2.69 KB
numberformatter.h	86.31 KB
numberrangeformatter.h	30.14 KB
numfmt.h	49.81 KB
numsys.h	7.19 KB
parseerr.h	3.08 KB
parsepos.h	5.56 KB
platform.h	28.08 KB
plurfmt.h	25.2 KB
plurrule.h	18.39 KB
ptypes.h	3.49 KB
putil.h	6.33 KB
rbbi.h	26.58 KB
rbnf.h	48.73 KB
rbtz.h	15.6 KB
regex.h	84.36 KB
region.h	9.18 KB
reldatefmt.h	22.62 KB
rep.h	9.37 KB
resbund.h	18.07 KB
schriter.h	6.32 KB
scientificnumberformatter.h	6.4 KB
search.h	22.22 KB
selfmt.h	14.3 KB
simpleformatter.h	12.59 KB
simpletz.h	45.44 KB
smpdtfmt.h	70.97 KB
sortkey.h	11.18 KB
std_string.h	1.05 KB
strenum.h	9.92 KB
stringoptions.h	5.79 KB
stringpiece.h	7.38 KB
stringtriebuilder.h	15.33 KB
stsearch.h	21.3 KB
symtable.h	4.27 KB
tblcoll.h	36.61 KB
timezone.h	41.02 KB
tmunit.h	3.38 KB
tmutamt.h	4.9 KB
tmutfmt.h	7.85 KB
translit.h	65.82 KB
tzfmt.h	42.89 KB
tznames.h	16.85 KB
tzrule.h	35.37 KB
tztrans.h	6.12 KB
ubidi.h	89.56 KB
ubiditransform.h	12.65 KB
ubrk.h	23.97 KB
ucal.h	56.9 KB
ucasemap.h	15.18 KB
ucat.h	5.36 KB
uchar.h	140.56 KB
ucharstrie.h	22.58 KB
ucharstriebuilder.h	7.21 KB
uchriter.h	13.2 KB
uclean.h	11.21 KB
ucnv.h	83.09 KB
ucnv_cb.h	6.59 KB
ucnv_err.h	20.99 KB
ucnvsel.h	6.14 KB
ucol.h	61.46 KB
ucoleitr.h	9.46 KB
uconfig.h	12.07 KB
ucpmap.h	5.53 KB
ucptrie.h	22.46 KB
ucsdet.h	14.67 KB
ucurr.h	16.12 KB
udat.h	60.88 KB
udata.h	15.56 KB
udateintervalformat.h	10.03 KB
udatpg.h	26.01 KB
udisplaycontext.h	5.89 KB
uenum.h	7.78 KB
ufieldpositer.h	4.36 KB
uformattable.h	10.94 KB
uformattedvalue.h	12.14 KB
ugender.h	2 KB
uidna.h	33.37 KB
uiter.h	22.77 KB
uldnames.h	10.45 KB
ulistformatter.h	8.83 KB
uloc.h	52.54 KB
ulocdata.h	11.26 KB
umachine.h	14.53 KB
umisc.h	1.33 KB
umsg.h	24.23 KB
umutablecptrie.h	8.24 KB
unifilt.h	3.96 KB
unifunct.h	4.04 KB
unimatch.h	6.1 KB
unirepl.h	3.38 KB
uniset.h	64.9 KB
unistr.h	170.43 KB
unorm.h	20.52 KB
unorm2.h	24.66 KB
unum.h	53.62 KB
unumberformatter.h	25.36 KB
unumsys.h	7.21 KB
uobject.h	10.68 KB
upluralrules.h	7.88 KB
uregex.h	72.05 KB
uregion.h	9.84 KB
ureldatefmt.h	17.26 KB
urename.h	130.97 KB
urep.h	5.38 KB
ures.h	36.54 KB
uscript.h	26.87 KB
usearch.h	38.12 KB
uset.h	40 KB
usetiter.h	9.55 KB
ushape.h	18 KB
uspoof.h	65.9 KB
usprep.h	8.14 KB
ustdio.h	38.54 KB
ustream.h	1.89 KB
ustring.h	72.47 KB
ustringtrie.h	3.15 KB
utext.h	58.13 KB
utf.h	7.86 KB
utf16.h	23.32 KB
utf32.h	763 B
utf8.h	30.96 KB
utf_old.h	45.83 KB
utmscale.h	13.78 KB
utrace.h	15.73 KB
utrans.h	25.52 KB
utypes.h	30.74 KB
uvernum.h	6.67 KB
uversion.h	6 KB
vtzone.h	20.3 KB

Edit: rbtz.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2007-2013, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*/
#ifndef RBTZ_H
#define RBTZ_H

#include "unicode/utypes.h"

#if U_SHOW_CPLUSPLUS_API

/**
 * \file 
 * \brief C++ API: Rule based customizable time zone
 */

#if !UCONFIG_NO_FORMATTING

#include "unicode/basictz.h"
#include "unicode/unistr.h"

U_NAMESPACE_BEGIN

// forward declaration
class UVector;
struct Transition;

/**
 * a BasicTimeZone subclass implemented in terms of InitialTimeZoneRule and TimeZoneRule instances
 * @see BasicTimeZone
 * @see InitialTimeZoneRule
 * @see TimeZoneRule
 */
class U_I18N_API RuleBasedTimeZone : public BasicTimeZone {
public:
    /**
     * Constructs a <code>RuleBasedTimeZone</code> object with the ID and the
     * <code>InitialTimeZoneRule</code>.  The input <code>InitialTimeZoneRule</code>
     * is adopted by this <code>RuleBasedTimeZone</code>, thus the caller must not
     * delete it.
     * @param id                The time zone ID.
     * @param initialRule       The initial time zone rule.
     * @stable ICU 3.8
     */
    RuleBasedTimeZone(const UnicodeString& id, InitialTimeZoneRule* initialRule);

/**
     * Copy constructor.
     * @param source    The RuleBasedTimeZone object to be copied.
     * @stable ICU 3.8
     */
    RuleBasedTimeZone(const RuleBasedTimeZone& source);

/**
     * Destructor.
     * @stable ICU 3.8
     */
    virtual ~RuleBasedTimeZone();

/**
     * Assignment operator.
     * @param right The object to be copied.
     * @stable ICU 3.8
     */
    RuleBasedTimeZone& operator=(const RuleBasedTimeZone& right);

/**
     * Return true if the given <code>TimeZone</code> objects are
     * semantically equal. Objects of different subclasses are considered unequal.
     * @param that  The object to be compared with.
     * @return  true if the given <code>TimeZone</code> objects are
      *semantically equal.
     * @stable ICU 3.8
     */
    virtual UBool operator==(const TimeZone& that) const;

/**
     * Return true if the given <code>TimeZone</code> objects are
     * semantically unequal. Objects of different subclasses are considered unequal.
     * @param that  The object to be compared with.
     * @return  true if the given <code>TimeZone</code> objects are
     * semantically unequal.
     * @stable ICU 3.8
     */
    virtual UBool operator!=(const TimeZone& that) const;

/**
     * Adds the <code>TimeZoneRule</code> which represents time transitions.
     * The <code>TimeZoneRule</code> must have start times, that is, the result
     * of isTransitionRule() must be true. Otherwise, U_ILLEGAL_ARGUMENT_ERROR
     * is set to the error code.
     * The input <code>TimeZoneRule</code> is adopted by this
     * <code>RuleBasedTimeZone</code> on successful completion of this method,
     * thus, the caller must not delete it when no error is returned.
     * After all rules are added, the caller must call complete() method to
     * make this <code>RuleBasedTimeZone</code> ready to handle common time
     * zone functions.
     * @param rule The <code>TimeZoneRule</code>.
     * @param status Output param to filled in with a success or an error.
     * @stable ICU 3.8
     */
    void addTransitionRule(TimeZoneRule* rule, UErrorCode& status);

/**
     * Makes the <code>TimeZoneRule</code> ready to handle actual timezone
     * calcuation APIs.  This method collects time zone rules specified
     * by the caller via the constructor and addTransitionRule() and
     * builds internal structure for making the object ready to support
     * time zone APIs such as getOffset(), getNextTransition() and others.
     * @param status Output param to filled in with a success or an error.
     * @stable ICU 3.8
     */
    void complete(UErrorCode& status);

/**
     * Clones TimeZone objects polymorphically. Clients are responsible for deleting
     * the TimeZone object cloned.
     *
     * @return   A new copy of this TimeZone object.
     * @stable ICU 3.8
     */
    virtual RuleBasedTimeZone* clone() const;

/**
     * Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseconds to add
     * to GMT to get local time in this time zone, taking daylight savings time into
     * account) as of a particular reference date.  The reference date is used to determine
     * whether daylight savings time is in effect and needs to be figured into the offset
     * that is returned (in other words, what is the adjusted GMT offset in this time zone
     * at this particular date and time?).  For the time zones produced by createTimeZone(),
     * the reference data is specified according to the Gregorian calendar, and the date
     * and time fields are local standard time.
     *
     * <p>Note: Don't call this method. Instead, call the getOffset(UDate...) overload,
     * which returns both the raw and the DST offset for a given time. This method
     * is retained only for backward compatibility.
     *
     * @param era        The reference date's era
     * @param year       The reference date's year
     * @param month      The reference date's month (0-based; 0 is January)
     * @param day        The reference date's day-in-month (1-based)
     * @param dayOfWeek  The reference date's day-of-week (1-based; 1 is Sunday)
     * @param millis     The reference date's milliseconds in day, local standard time
     * @param status     Output param to filled in with a success or an error.
     * @return           The offset in milliseconds to add to GMT to get local time.
     * @stable ICU 3.8
     */
    virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
                              uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const;

/**
     * Gets the time zone offset, for current date, modified in case of
     * daylight savings. This is the offset to add *to* UTC to get local time.
     *
     * <p>Note: Don't call this method. Instead, call the getOffset(UDate...) overload,
     * which returns both the raw and the DST offset for a given time. This method
     * is retained only for backward compatibility.
     *
     * @param era        The reference date's era
     * @param year       The reference date's year
     * @param month      The reference date's month (0-based; 0 is January)
     * @param day        The reference date's day-in-month (1-based)
     * @param dayOfWeek  The reference date's day-of-week (1-based; 1 is Sunday)
     * @param millis     The reference date's milliseconds in day, local standard time
     * @param monthLength The length of the given month in days.
     * @param status     Output param to filled in with a success or an error.
     * @return           The offset in milliseconds to add to GMT to get local time.
     * @stable ICU 3.8
     */
    virtual int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
                           uint8_t dayOfWeek, int32_t millis,
                           int32_t monthLength, UErrorCode& status) const;

/**
     * Returns the time zone raw and GMT offset for the given moment
     * in time.  Upon return, local-millis = GMT-millis + rawOffset +
     * dstOffset.  All computations are performed in the proleptic
     * Gregorian calendar.  The default implementation in the TimeZone
     * class delegates to the 8-argument getOffset().
     *
     * @param date moment in time for which to return offsets, in
     * units of milliseconds from January 1, 1970 0:00 GMT, either GMT
     * time or local wall time, depending on `local'.
     * @param local if true, `date' is local wall time; otherwise it
     * is in GMT time.
     * @param rawOffset output parameter to receive the raw offset, that
     * is, the offset not including DST adjustments
     * @param dstOffset output parameter to receive the DST offset,
     * that is, the offset to be added to `rawOffset' to obtain the
     * total offset between local and GMT time. If DST is not in
     * effect, this value is zero; otherwise it is a positive value,
     * typically one hour.
     * @param ec input-output error code
     * @stable ICU 3.8
     */
    virtual void getOffset(UDate date, UBool local, int32_t& rawOffset,
                           int32_t& dstOffset, UErrorCode& ec) const;

/**
     * Sets the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
     * to GMT to get local time, before taking daylight savings time into account).
     *
     * @param offsetMillis  The new raw GMT offset for this time zone.
     * @stable ICU 3.8
     */
    virtual void setRawOffset(int32_t offsetMillis);

/**
     * Returns the TimeZone's raw GMT offset (i.e., the number of milliseconds to add
     * to GMT to get local time, before taking daylight savings time into account).
     *
     * @return   The TimeZone's raw GMT offset.
     * @stable ICU 3.8
     */
    virtual int32_t getRawOffset(void) const;

/**
     * Queries if this time zone uses daylight savings time.
     * @return true if this time zone uses daylight savings time,
     * false, otherwise.
     * @stable ICU 3.8
     */
    virtual UBool useDaylightTime(void) const;

#ifndef U_FORCE_HIDE_DEPRECATED_API
    /**
     * Queries if the given date is in daylight savings time in
     * this time zone.
     * This method is wasteful since it creates a new GregorianCalendar and
     * deletes it each time it is called. This is a deprecated method
     * and provided only for Java compatibility.
     *
     * @param date the given UDate.
     * @param status Output param filled in with success/error code.
     * @return true if the given date is in daylight savings time,
     * false, otherwise.
     * @deprecated ICU 2.4. Use Calendar::inDaylightTime() instead.
     */
    virtual UBool inDaylightTime(UDate date, UErrorCode& status) const;
#endif  // U_FORCE_HIDE_DEPRECATED_API

/**
     * Returns true if this zone has the same rule and offset as another zone.
     * That is, if this zone differs only in ID, if at all.
     * @param other the <code>TimeZone</code> object to be compared with
     * @return true if the given zone is the same as this one,
     * with the possible exception of the ID
     * @stable ICU 3.8
     */
    virtual UBool hasSameRules(const TimeZone& other) const;

/**
     * Gets the first time zone transition after the base time.
     * @param base      The base time.
     * @param inclusive Whether the base time is inclusive or not.
     * @param result    Receives the first transition after the base time.
     * @return  TRUE if the transition is found.
     * @stable ICU 3.8
     */
    virtual UBool getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;

/**
     * Gets the most recent time zone transition before the base time.
     * @param base      The base time.
     * @param inclusive Whether the base time is inclusive or not.
     * @param result    Receives the most recent transition before the base time.
     * @return  TRUE if the transition is found.
     * @stable ICU 3.8
     */
    virtual UBool getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const;

/**
     * Returns the number of <code>TimeZoneRule</code>s which represents time transitions,
     * for this time zone, that is, all <code>TimeZoneRule</code>s for this time zone except
     * <code>InitialTimeZoneRule</code>.  The return value range is 0 or any positive value.
     * @param status    Receives error status code.
     * @return The number of <code>TimeZoneRule</code>s representing time transitions.
     * @stable ICU 3.8
     */
    virtual int32_t countTransitionRules(UErrorCode& status) const;

/**
     * Gets the <code>InitialTimeZoneRule</code> and the set of <code>TimeZoneRule</code>
     * which represent time transitions for this time zone.  On successful return,
     * the argument initial points to non-NULL <code>InitialTimeZoneRule</code> and
     * the array trsrules is filled with 0 or multiple <code>TimeZoneRule</code>
     * instances up to the size specified by trscount.  The results are referencing the
     * rule instance held by this time zone instance.  Therefore, after this time zone
     * is destructed, they are no longer available.
     * @param initial       Receives the initial timezone rule
     * @param trsrules      Receives the timezone transition rules
     * @param trscount      On input, specify the size of the array 'transitions' receiving
     *                      the timezone transition rules.  On output, actual number of
     *                      rules filled in the array will be set.
     * @param status        Receives error status code.
     * @stable ICU 3.8
     */
    virtual void getTimeZoneRules(const InitialTimeZoneRule*& initial,
        const TimeZoneRule* trsrules[], int32_t& trscount, UErrorCode& status) const;

/**
     * Get time zone offsets from local wall time.
     * @internal
     */
    virtual void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
        int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const;

private:
    void deleteRules(void);
    void deleteTransitions(void);
    UVector* copyRules(UVector* source);
    TimeZoneRule* findRuleInFinal(UDate date, UBool local,
        int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const;
    UBool findNext(UDate base, UBool inclusive, UDate& time, TimeZoneRule*& from, TimeZoneRule*& to) const;
    UBool findPrev(UDate base, UBool inclusive, UDate& time, TimeZoneRule*& from, TimeZoneRule*& to) const;
    int32_t getLocalDelta(int32_t rawBefore, int32_t dstBefore, int32_t rawAfter, int32_t dstAfter,
        int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const;
    UDate getTransitionTime(Transition* transition, UBool local,
        int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const;
    void getOffsetInternal(UDate date, UBool local, int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
        int32_t& rawOffset, int32_t& dstOffset, UErrorCode& ec) const;
    void completeConst(UErrorCode &status) const;

InitialTimeZoneRule *fInitialRule;
    UVector             *fHistoricRules;
    UVector             *fFinalRules;
    UVector             *fHistoricTransitions;
    UBool               fUpToDate;

public:
    /**
     * Return the class ID for this class. This is useful only for comparing to
     * a return value from getDynamicClassID(). For example:
     * <pre>
     * .   Base* polymorphic_pointer = createPolymorphicObject();
     * .   if (polymorphic_pointer->getDynamicClassID() ==
     * .       erived::getStaticClassID()) ...
     * </pre>
     * @return          The class ID for all objects of this class.
     * @stable ICU 3.8
     */
    static UClassID U_EXPORT2 getStaticClassID(void);

/**
     * Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This
     * method is to implement a simple version of RTTI, since not all C++
     * compilers support genuine RTTI. Polymorphic operator==() and clone()
     * methods call this method.
     *
     * @return          The class ID for this object. All objects of a
     *                  given class have the same class ID.  Objects of
     *                  other classes have different class IDs.
     * @stable ICU 3.8
     */
    virtual UClassID getDynamicClassID(void) const;
};

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_FORMATTING */

#endif /* U_SHOW_CPLUSPLUS_API */

#endif // RBTZ_H

//eof