mirror of
https://github.com/mjl-/mox.git
synced 2024-12-29 01:43:48 +03:00
40163bd145
the mailbox select/examine responses now return all flags used in a mailbox in the FLAGS response. and indicate in the PERMANENTFLAGS response that clients can set new keywords. we store these values on the new Message.Keywords field. system/well-known flags are still in Message.Flags, so we're recognizing those and handling them separately. the imap store command handles the new flags. as does the append command, and the search command. we store keywords in a mailbox when a message in that mailbox gets the keyword. we don't automatically remove the keywords from a mailbox. there is currently no way at all to remove a keyword from a mailbox. the import commands now handle non-system/well-known keywords too, when importing from mbox/maildir. jmap requires keyword support, so best to get it out of the way now.
94 lines
2.3 KiB
Go
94 lines
2.3 KiB
Go
// Copyright 2021 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 maps defines various functions useful with maps of any type.
|
|
package maps
|
|
|
|
// Keys returns the keys of the map m.
|
|
// The keys will be in an indeterminate order.
|
|
func Keys[M ~map[K]V, K comparable, V any](m M) []K {
|
|
r := make([]K, 0, len(m))
|
|
for k := range m {
|
|
r = append(r, k)
|
|
}
|
|
return r
|
|
}
|
|
|
|
// Values returns the values of the map m.
|
|
// The values will be in an indeterminate order.
|
|
func Values[M ~map[K]V, K comparable, V any](m M) []V {
|
|
r := make([]V, 0, len(m))
|
|
for _, v := range m {
|
|
r = append(r, v)
|
|
}
|
|
return r
|
|
}
|
|
|
|
// Equal reports whether two maps contain the same key/value pairs.
|
|
// Values are compared using ==.
|
|
func Equal[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool {
|
|
if len(m1) != len(m2) {
|
|
return false
|
|
}
|
|
for k, v1 := range m1 {
|
|
if v2, ok := m2[k]; !ok || v1 != v2 {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// EqualFunc is like Equal, but compares values using eq.
|
|
// Keys are still compared with ==.
|
|
func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
|
|
if len(m1) != len(m2) {
|
|
return false
|
|
}
|
|
for k, v1 := range m1 {
|
|
if v2, ok := m2[k]; !ok || !eq(v1, v2) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Clear removes all entries from m, leaving it empty.
|
|
func Clear[M ~map[K]V, K comparable, V any](m M) {
|
|
for k := range m {
|
|
delete(m, k)
|
|
}
|
|
}
|
|
|
|
// Clone returns a copy of m. This is a shallow clone:
|
|
// the new keys and values are set using ordinary assignment.
|
|
func Clone[M ~map[K]V, K comparable, V any](m M) M {
|
|
// Preserve nil in case it matters.
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
r := make(M, len(m))
|
|
for k, v := range m {
|
|
r[k] = v
|
|
}
|
|
return r
|
|
}
|
|
|
|
// Copy copies all key/value pairs in src adding them to dst.
|
|
// When a key in src is already present in dst,
|
|
// the value in dst will be overwritten by the value associated
|
|
// with the key in src.
|
|
func Copy[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2) {
|
|
for k, v := range src {
|
|
dst[k] = v
|
|
}
|
|
}
|
|
|
|
// DeleteFunc deletes any key/value pairs from m for which del returns true.
|
|
func DeleteFunc[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool) {
|
|
for k, v := range m {
|
|
if del(k, v) {
|
|
delete(m, k)
|
|
}
|
|
}
|
|
}
|