Subversion Repositories openrisc

// Copyright 2011 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package time

import "sync"

// A Location maps time instants to the zone in use at that time.

// Typically, the Location represents the collection of time offsets

// in use in a geographical area, such as CEST and CET for central Europe.

type Location struct {

        name string

        zone []zone

        tx   []zoneTrans

        // Most lookups will be for the current time.

        // To avoid the binary search through tx, keep a

        // static one-element cache that gives the correct

        // zone for the time when the Location was created.

        // if cacheStart <= t <= cacheEnd,

        // lookup can return cacheZone.

        // The units for cacheStart and cacheEnd are seconds

        // since January 1, 1970 UTC, to match the argument

        // to lookup.

        cacheStart int64

        cacheEnd   int64

        cacheZone  *zone

}

// A zone represents a single time zone such as CEST or CET.

type zone struct {

        name   string // abbreviated name, "CET"

        offset int    // seconds east of UTC

        isDST  bool   // is this zone Daylight Savings Time?

}

// A zoneTrans represents a single time zone transition.

type zoneTrans struct {

        when         int64 // transition time, in seconds since 1970 GMT

        index        uint8 // the index of the zone that goes into effect at that time

        isstd, isutc bool  // ignored - no idea what these mean

}

// UTC represents Universal Coordinated Time (UTC).

var UTC *Location = &utcLoc

// utcLoc is separate so that get can refer to &utcLoc

// and ensure that it never returns a nil *Location,

// even if a badly behaved client has changed UTC.

var utcLoc = Location{name: "UTC"}

// Local represents the system's local time zone.

var Local *Location = &localLoc

// localLoc is separate so that initLocal can initialize

// it even if a client has changed Local.

var localLoc Location

var localOnce sync.Once

func (l *Location) get() *Location {

        if l == nil {

                return &utcLoc

        }

        if l == &localLoc {

                localOnce.Do(initLocal)

        }

        return l

}

// String returns a descriptive name for the time zone information,

// corresponding to the argument to LoadLocation.

func (l *Location) String() string {

        return l.get().name

}

// FixedZone returns a Location that always uses

// the given zone name and offset (seconds east of UTC).

func FixedZone(name string, offset int) *Location {

        l := &Location{

                name:       name,

                zone:       []zone{{name, offset, false}},

                tx:         []zoneTrans{{-1 << 63, 0, false, false}},

                cacheStart: -1 << 63,

                cacheEnd:   1<<63 - 1,

        }

        l.cacheZone = &l.zone[0]

        return l

}

// lookup returns information about the time zone in use at an

// instant in time expressed as seconds since January 1, 1970 00:00:00 UTC.

//

// The returned information gives the name of the zone (such as "CET"),

// the start and end times bracketing sec when that zone is in effect,

// the offset in seconds east of UTC (such as -5*60*60), and whether

// the daylight savings is being observed at that time.

func (l *Location) lookup(sec int64) (name string, offset int, isDST bool, start, end int64) {

        l = l.get()

        if len(l.tx) == 0 {

                name = "UTC"

                offset = 0

                isDST = false

                start = -1 << 63

                end = 1<<63 - 1

                return

        }

        if zone := l.cacheZone; zone != nil && l.cacheStart <= sec && sec < l.cacheEnd {

                name = zone.name

                offset = zone.offset

                isDST = zone.isDST

                start = l.cacheStart

                end = l.cacheEnd

                return

        }

        // Binary search for entry with largest time <= sec.

        // Not using sort.Search to avoid dependencies.

        tx := l.tx

        end = 1<<63 - 1

        for len(tx) > 1 {

                m := len(tx) / 2

                lim := tx[m].when

                if sec < lim {

                        end = lim

                        tx = tx[0:m]

                } else {

                        tx = tx[m:]

                }

        }

        zone := &l.zone[tx[0].index]

        name = zone.name

        offset = zone.offset

        isDST = zone.isDST

        start = tx[0].when

        // end = maintained during the search

        return

}

// lookupName returns information about the time zone with

// the given name (such as "EST").

func (l *Location) lookupName(name string) (offset int, isDST bool, ok bool) {

        l = l.get()

        for i := range l.zone {

                zone := &l.zone[i]

                if zone.name == name {

                        return zone.offset, zone.isDST, true

                }

        }

        return

}

// lookupOffset returns information about the time zone with

// the given offset (such as -5*60*60).

func (l *Location) lookupOffset(offset int) (name string, isDST bool, ok bool) {

        l = l.get()

        for i := range l.zone {

                zone := &l.zone[i]

                if zone.offset == offset {

                        return zone.name, zone.isDST, true

                }

        }

        return

}

// NOTE(rsc): Eventually we will need to accept the POSIX TZ environment

// syntax too, but I don't feel like implementing it today.

// NOTE(rsc): Using the IANA names below means ensuring we have access

// to the database.  Probably we will ship the files in $GOROOT/lib/zoneinfo/

// and only look there if there are no system files available (such as on Windows).

// The files total 200 kB.

// LoadLocation returns the Location with the given name.

//

// If the name is "" or "UTC", LoadLocation returns UTC.

// If the name is "Local", LoadLocation returns Local.

//

// Otherwise, the name is taken to be a location name corresponding to a file

// in the IANA Time Zone database, such as "America/New_York".

func LoadLocation(name string) (*Location, error) {

        if name == "" || name == "UTC" {

                return UTC, nil

        }

        if name == "Local" {

                return Local, nil

        }

        return loadLocation(name)

}