github.com/metacubex/mihomo@v1.18.5/common/atomic/type.go (about)

     1  package atomic
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"strconv"
     7  	"sync/atomic"
     8  )
     9  
    10  type Bool struct {
    11  	atomic.Bool
    12  }
    13  
    14  func NewBool(val bool) (i Bool) {
    15  	i.Store(val)
    16  	return
    17  }
    18  
    19  func (i *Bool) MarshalJSON() ([]byte, error) {
    20  	return json.Marshal(i.Load())
    21  }
    22  
    23  func (i *Bool) UnmarshalJSON(b []byte) error {
    24  	var v bool
    25  	if err := json.Unmarshal(b, &v); err != nil {
    26  		return err
    27  	}
    28  	i.Store(v)
    29  	return nil
    30  }
    31  
    32  func (i *Bool) String() string {
    33  	v := i.Load()
    34  	return strconv.FormatBool(v)
    35  }
    36  
    37  type Pointer[T any] struct {
    38  	atomic.Pointer[T]
    39  }
    40  
    41  func NewPointer[T any](v *T) (p Pointer[T]) {
    42  	if v != nil {
    43  		p.Store(v)
    44  	}
    45  	return
    46  }
    47  
    48  func (p *Pointer[T]) MarshalJSON() ([]byte, error) {
    49  	return json.Marshal(p.Load())
    50  }
    51  
    52  func (p *Pointer[T]) UnmarshalJSON(b []byte) error {
    53  	var v *T
    54  	if err := json.Unmarshal(b, &v); err != nil {
    55  		return err
    56  	}
    57  	p.Store(v)
    58  	return nil
    59  }
    60  
    61  func (p *Pointer[T]) String() string {
    62  	return fmt.Sprint(p.Load())
    63  }
    64  
    65  type Int32 struct {
    66  	atomic.Int32
    67  }
    68  
    69  func NewInt32(val int32) (i Int32) {
    70  	i.Store(val)
    71  	return
    72  }
    73  
    74  func (i *Int32) MarshalJSON() ([]byte, error) {
    75  	return json.Marshal(i.Load())
    76  }
    77  
    78  func (i *Int32) UnmarshalJSON(b []byte) error {
    79  	var v int32
    80  	if err := json.Unmarshal(b, &v); err != nil {
    81  		return err
    82  	}
    83  	i.Store(v)
    84  	return nil
    85  }
    86  
    87  func (i *Int32) String() string {
    88  	v := i.Load()
    89  	return strconv.FormatInt(int64(v), 10)
    90  }
    91  
    92  type Int64 struct {
    93  	atomic.Int64
    94  }
    95  
    96  func NewInt64(val int64) (i Int64) {
    97  	i.Store(val)
    98  	return
    99  }
   100  
   101  func (i *Int64) MarshalJSON() ([]byte, error) {
   102  	return json.Marshal(i.Load())
   103  }
   104  
   105  func (i *Int64) UnmarshalJSON(b []byte) error {
   106  	var v int64
   107  	if err := json.Unmarshal(b, &v); err != nil {
   108  		return err
   109  	}
   110  	i.Store(v)
   111  	return nil
   112  }
   113  
   114  func (i *Int64) String() string {
   115  	v := i.Load()
   116  	return strconv.FormatInt(int64(v), 10)
   117  }
   118  
   119  type Uint32 struct {
   120  	atomic.Uint32
   121  }
   122  
   123  func NewUint32(val uint32) (i Uint32) {
   124  	i.Store(val)
   125  	return
   126  }
   127  
   128  func (i *Uint32) MarshalJSON() ([]byte, error) {
   129  	return json.Marshal(i.Load())
   130  }
   131  
   132  func (i *Uint32) UnmarshalJSON(b []byte) error {
   133  	var v uint32
   134  	if err := json.Unmarshal(b, &v); err != nil {
   135  		return err
   136  	}
   137  	i.Store(v)
   138  	return nil
   139  }
   140  
   141  func (i *Uint32) String() string {
   142  	v := i.Load()
   143  	return strconv.FormatUint(uint64(v), 10)
   144  }
   145  
   146  type Uint64 struct {
   147  	atomic.Uint64
   148  }
   149  
   150  func NewUint64(val uint64) (i Uint64) {
   151  	i.Store(val)
   152  	return
   153  }
   154  
   155  func (i *Uint64) MarshalJSON() ([]byte, error) {
   156  	return json.Marshal(i.Load())
   157  }
   158  
   159  func (i *Uint64) UnmarshalJSON(b []byte) error {
   160  	var v uint64
   161  	if err := json.Unmarshal(b, &v); err != nil {
   162  		return err
   163  	}
   164  	i.Store(v)
   165  	return nil
   166  }
   167  
   168  func (i *Uint64) String() string {
   169  	v := i.Load()
   170  	return strconv.FormatUint(uint64(v), 10)
   171  }
   172  
   173  type Uintptr struct {
   174  	atomic.Uintptr
   175  }
   176  
   177  func NewUintptr(val uintptr) (i Uintptr) {
   178  	i.Store(val)
   179  	return
   180  }
   181  
   182  func (i *Uintptr) MarshalJSON() ([]byte, error) {
   183  	return json.Marshal(i.Load())
   184  }
   185  
   186  func (i *Uintptr) UnmarshalJSON(b []byte) error {
   187  	var v uintptr
   188  	if err := json.Unmarshal(b, &v); err != nil {
   189  		return err
   190  	}
   191  	i.Store(v)
   192  	return nil
   193  }
   194  
   195  func (i *Uintptr) String() string {
   196  	v := i.Load()
   197  	return strconv.FormatUint(uint64(v), 10)
   198  }