11package refhints
22
33import (
4+ "encoding/json"
45 "maps"
56 "slices"
67 "strings"
@@ -35,12 +36,6 @@ const (
3536 IMPLICIT_TRUE = "true"
3637)
3738
38- func MatchType (typs ... string ) matcher.Matcher [ReferenceHint ] {
39- return func (h ReferenceHint ) bool {
40- return slices .Contains (typs , h .GetType ())
41- }
42- }
43-
4439// ReferenceHints is list of hints.
4540// Notaion: a sequence of hint notations separated by a ;.
4641type ReferenceHints []ReferenceHint
@@ -50,7 +45,7 @@ func NewHints(f func(ref string, implicit ...bool) ReferenceHint, ref string, im
5045}
5146
5247func (h * ReferenceHints ) Add (hints ... ReferenceHint ) {
53- * h = sliceutils . AppendUniqueFunc ( * h , runtime . MatchType [ ReferenceHint ] , hints ... )
48+ AddUnique ( h , hints ... )
5449}
5550
5651func (h ReferenceHints ) Copy () ReferenceHints {
@@ -75,7 +70,7 @@ func (h ReferenceHints) GetReferenceHint(typs ...string) ReferenceHint {
7570 if len (typs ) == 0 {
7671 return nil
7772 }
78- hints := sliceutils . Filter (h , MatchType (typs ... ))
73+ hints := Filter (h , MatchType (typs ... ))
7974 if len (hints ) == 0 {
8075 return nil
8176 }
@@ -128,18 +123,55 @@ type ReferenceHint interface {
128123 AsDefault () DefaultReferenceHint
129124}
130125
131- func IsImplicitHint (h ReferenceHint ) bool {
126+ func MatchType (typs ... string ) matcher.Matcher [ReferenceHint ] {
127+ return func (h ReferenceHint ) bool {
128+ return slices .Contains (typs , h .GetType ())
129+ }
130+ }
131+
132+ func Equal (o ReferenceHint ) matcher.Matcher [ReferenceHint ] {
133+ d := o .Serialize ()
134+ return func (h ReferenceHint ) bool {
135+ return h .Serialize () == d
136+ }
137+ }
138+
139+ func IsImplicit (h ReferenceHint ) bool {
132140 if h == nil {
133141 return false
134142 }
135143 return h .GetProperty (HINT_IMPLICIT ) == IMPLICIT_TRUE
136144}
137145
138- func FilterImplicit (hints []ReferenceHint ) ReferenceHints {
146+ func IsExplicit (h ReferenceHint ) bool {
147+ if h == nil {
148+ return false
149+ }
150+ return ! IsImplicit (h )
151+ }
152+
153+ func Filter (hints []ReferenceHint , cond matcher.Matcher [ReferenceHint ]) ReferenceHints {
139154 if len (hints ) == 0 {
140155 return nil
141156 }
142- return sliceutils .Filter (hints , IsImplicitHint )
157+ return sliceutils .Filter (hints , cond )
158+ }
159+
160+ func FilterImplicit (hints []ReferenceHint ) ReferenceHints {
161+ return Filter (hints , IsImplicit )
162+ }
163+
164+ func AsImplicit [S ~ []T , T ReferenceHint ](hints S ) DefaultReferenceHints {
165+ var result DefaultReferenceHints
166+
167+ for _ , h := range hints {
168+ if IsImplicit (h ) {
169+ result .Add (h )
170+ } else {
171+ result .Add (h .AsDefault ().SetProperty (HINT_IMPLICIT , IMPLICIT_TRUE ))
172+ }
173+ }
174+ return result
143175}
144176
145177// GetReference returns the default reference hint attribute
@@ -245,6 +277,57 @@ func (h DefaultReferenceHint) Serialize(implicit ...bool) string {
245277 return s
246278}
247279
280+ ////////////////////////////////////////////////////////////////////////////////
281+
282+ type DefaultReferenceHints []DefaultReferenceHint
283+
284+ func (h * DefaultReferenceHints ) Add (hints ... ReferenceHint ) {
285+ AddUnique (h , sliceutils .Transform (hints , AsDefault )... )
286+ }
287+
288+ func (h DefaultReferenceHints ) Copy () ReferenceHints {
289+ var result ReferenceHints
290+
291+ for _ , v := range h {
292+ result = append (result , v .Copy ())
293+ }
294+ return result
295+ }
296+
297+ // Serialize provides a string representation. The implicit
298+ // attribute is only serialized, if it is called with true.
299+ func (h DefaultReferenceHints ) Serialize (implicit ... bool ) string {
300+ return HintsToString (sliceutils.Convert [ReferenceHint ](h ), implicit ... )
301+ }
302+
303+ var _ json.Marshaler = DefaultReferenceHints {}
304+
305+ func (h DefaultReferenceHints ) MarshalJSON () ([]byte , error ) {
306+ return json .Marshal (([]DefaultReferenceHint )(h ))
307+ }
308+
309+ var _ json.Unmarshaler = & DefaultReferenceHints {}
310+
311+ // UnmarshalJSON excepts the serialized form or the list form.
312+ func (h * DefaultReferenceHints ) UnmarshalJSON (data []byte ) error {
313+ var in []DefaultReferenceHint
314+
315+ err := json .Unmarshal (data , & in )
316+ if err == nil {
317+ * h = DefaultReferenceHints (in )
318+ return nil
319+ }
320+ var s string
321+ err = json .Unmarshal (data , & s )
322+ if err != nil {
323+ return err
324+ }
325+ * h = sliceutils .Transform (ParseHints (s ), AsDefault )
326+ return nil
327+ }
328+
329+ ////////////////////////////////////////////////////////////////////////////////
330+
248331func escapeHintValue (v string ) string {
249332 if ! strings .ContainsAny (v , "\" ,;" ) {
250333 return v
@@ -413,10 +496,23 @@ func ParseHints(v string, implicit ...bool) ReferenceHints {
413496 return hints
414497}
415498
416- func Join (hints ... []ReferenceHint ) ReferenceHints {
499+ // JoinUnique joins multiple hint lists, where the first occurrence of a
500+ // hint type takes precedence.
501+ func JoinUnique (hints ... []ReferenceHint ) ReferenceHints {
417502 var result []ReferenceHint
418503 for _ , h := range hints {
419- result = sliceutils . AppendUniqueFunc ( result , runtime . MatchType [ ReferenceHint ] , h ... )
504+ AddUnique ( & result , h ... )
420505 }
421506 return result
422507}
508+
509+ // AddUnique adds hints to hint list, whode type is not yet present in the list.
510+ func AddUnique [S ~ []T , T ReferenceHint ](hints * S , add ... T ) {
511+ * hints = sliceutils .AppendUniqueFunc (* hints , runtime .MatchType [T ], add ... )
512+ }
513+
514+ // AsDefault transforms a generic hint into a default hint.
515+ // It can be used by sliceutils.Transform.
516+ func AsDefault (h ReferenceHint ) DefaultReferenceHint {
517+ return h .AsDefault ()
518+ }
0 commit comments