youyouayedee

type ClockStorage interface {
	// Load retrieves the last known timestamp and the last known counter
	// value for the given Node.
	//
	// If the implementation returns ErrClockNotFound for any reason, the
	// UUID generator is required to use the current time as the last known
	// timestamp and to generate a new random counter value from scratch.
	//
	// Implementations are not required to retain a (timestamp, counter)
	// tuple for each node; if there is no tuple stored for the given Node,
	// then ErrClockNotFound is the best choice of return value.
	//
	Load(Node) (time.Time, uint32, error)

	// Store associates the given last known timestamp and last known
	// counter value with the given Node, synchronizing the data to
	// persistent storage.
	//
	// Implementations are free to discard the (timestamp, counter) tuples
	// associated with any previous node identifiers upon receiving a Store
	// method call with a new node identifier.  However, it may be
	// beneficial to retain one such tuple for each past node identifier,
	// at least when such node identifiers are flagged as both IsGlobal and
	// IsUnicast.
	//
	Store(Node, time.Time, uint32) error
}

type ClockStorageFile struct {
	// contains filtered or unexported fields
}

type ClockStorageUnavailable struct{}

type DCEDomain byte

type Decoded struct {
	// Valid is true iff the UUID was successfully decoded to any degree.
	Valid bool

	// Version holds the detected UUID version.
	Version Version

	// HasTicks is true iff the Time and Ticks fields are valid.
	HasTicks bool

	// HasCounter is true iff the Counter field is valid.
	HasCounter bool

	// HasNode is true iff the Node field is valid.
	HasNode bool

	// HasData is true iff the Data field is valid.
	HasData bool

	// HasDomainAndID is true iff the Domain and ID fields are valid.
	HasDomainAndID bool

	// Time holds the decoded time extracted from a time-based UUID.
	Time time.Time

	// Ticks holds the raw tick count from a time-based UUID.
	//
	// For V1 and V6 UUIDs, this is hectonanoseconds since the start of the
	// Gregorian calendar in 1582, with leap seconds (probably) included.
	//
	// For V7 UUIDs, this is milliseconds since the start of the Unix epoch
	// in 1970, with leap seconds omitted.
	//
	Ticks int64

	// Counter holds the raw counter value from a time-based UUID.
	//
	// Only valid for V1 and V6 UUIDs.
	//
	Counter int

	// Node holds the node identifier from a time-based UUID.
	//
	// Only valid for V1 and V6 UUIDs.
	//
	Node Node

	// Domain holds the DCE domain.
	//
	// Only valid for V2 UUIDs.
	//
	Domain DCEDomain

	// ID holds the DCE identifier.
	//
	// Only valid for V2 UUIDs.
	//
	ID uint32

	// Data contains any additional random or opaque bytes, with the
	// variant and version bits cleared if applicable.
	//
	// For V1 and V6 UUIDs, this field is not used.
	//
	// For V7 UUIDs, this field contains all the bits from the UUID except
	// the timestamp.
	//
	// For V3, V4, V5, and V8 UUIDs, this field contains almost all bits
	// from the UUID.
	//
	Data []byte
}

type EnumData struct {
	GoName string
	Name   string
	Format string
}

type ErrClockNotFound struct{}

type ErrHashFactoryIsNil struct {
	Version Version
}

type ErrInputNotValid struct {
	Input UUID
}

type ErrLockNotSupported struct{}

type ErrMethodNotSupported struct {
	Method Method
}

type ErrNamespaceNotValid struct {
	Version   Version
	Namespace UUID
}

type ErrOperationFailed struct {
	Operation Operation
	Err       error
}

type ErrParseFailed struct {
	Input      []byte
	Problem    ParseProblem
	Args       []interface{}
	Index      uint
	ExpectByte byte
	ActualByte byte
}

type ErrVersionMismatch struct {
	Requested Version
	Expected  []Version
}

type ErrVersionNotSupported struct {
	Version Version
}

type Generator interface {
	// NewUUID generates a new unpredictable UUID.
	//
	// Generators are not required to support this operation, and should
	// return ErrMethodNotSupported{MethodNewUUID} if it is not.
	//
	NewUUID() (UUID, error)

	// NewHashUUID generates a new deterministic UUID by hashing the given
	// input data.
	//
	// Generators are not required to support this operation, and should
	// return ErrMethodNotSupported{MethodNewHashUUID} if it is not.
	//
	NewHashUUID(data []byte) (UUID, error)
}

type GeneratorBase struct{}

type GeneratorFactory interface {
	NewGenerator(Version, Options) (Generator, error)
}

type GeneratorFactoryFunc func(Version, Options) (Generator, error)

type LeapSecondCalculator interface {
	LeapSecondsSinceUnixEpoch(seconds int64, includesLeapSeconds bool) int
}

type LeapSecondCalculatorDummy struct{}

type LeapSecondCalculatorFixed struct{}

type Method uint

type Node [6]byte

type Operation uint

type Options struct {
	// Node indicates the node identifier to use.  The node identifier is
	// typically either a unique EUI-48 network hardware address associated
	// with the current host, or else a random 46-bit value modified to
	// look like a non-globally-unique EUI-48.
	//
	// Only time-based UUID generators use this field.  If this field is
	// the zero value but a generator requires it, then the generator will
	// query the local host during generator initialization by using the
	// GenerateNode function provided by this library.
	//
	// If the caller wishes to guarantee uniqueness between multiple
	// Generator instances for the same UUID version, it is the
	// responsibility of the caller to verify that a globally unique Node
	// can be obtained for the current host, or else to generate a random
	// node identifier and then preserve it for re-use, e.g. by writing it
	// to a file so that it is not forgotten across reboots and program
	// restarts.
	//
	Node Node

	// TimeSource is a function which returns the current time.
	//
	// Only time-based UUID generators use this field.  If this field is
	// nil but a generator requires it, then the built-in Go "time".Now
	// function is used instead.
	//
	TimeSource func() time.Time

	// LeapSecondCalculator provides the number of leap seconds by which
	// Unix time differs from the actual number of SI seconds since
	// 1970-01-01T00:00:00Z.
	//
	// Only V1 and V6 time-based UUID generators use this field.  If this
	// field is required but nil, an instance of LeapSecondCalculatorDummy
	// will be used instead.  The value is is needed to calculate the
	// RFC4122-correct timestamp values while generating V1 and V6
	// time-based UUIDs.
	//
	LeapSecondCalculator LeapSecondCalculator

	// ClockStorage provides persistent storage for clock counters.
	//
	// Only time-based UUID generators use this field.  If it is nil but a
	// generator requires it, then ClockStorageUnavailable is used instead.
	// This will degrade the uniqueness guarantees provided by those
	// generators; if the caller needs stronger guarantees, they must
	// provide their own ClockStorage instance that meets their
	// requirements.
	//
	ClockStorage ClockStorage

	// Namespace is the base UUID for namespacing data inputs when hashing.
	//
	// Only hash-based UUID generators use this field, but for those UUID
	// generators it is a mandatory field.  Generator initialization will
	// fail if this field is not initialized to a valid UUID.
	//
	Namespace UUID

	// HashFactory is a callback to produce new instances of hash.Hash on demand.
	//
	// Only hash-based UUID generators for V8 UUIDs use this field, and for
	// that case the field is mandatory.  V3 and V5 UUID generators ignore
	// this field and always use md5.New or sha1.New, respectively.
	//
	HashFactory func() hash.Hash

	// ForceRandomNode controls the behavior of GenerateNode when a node
	// identifier is required but Node is the zero value.
	//
	ForceRandomNode bool

	// RandomSource specifies a source of random bytes.
	//
	// Both random-based and time-based UUID generators use this field,
	// although the latter only use it to generate a node identifier if one
	// cannot otherwise be obtained.  If this field is nil but a source of
	// random bytes is required, then "crypto/rand".Reader will be used
	// instead.
	//
	RandomSource io.Reader
}

type ParseProblem uint

type TextUUID struct {
	UUID UUID
}

type UUID [Size]byte

type Version byte