github.com/insolar/vanilla@v0.0.0-20201023172447-248fdf805322/keyset/keyset_mutable.go (about)

     1  // Copyright 2020 Insolar Network Ltd.
     2  // All rights reserved.
     3  // This material is licensed under the Insolar License version 1.0,
     4  // available at https://github.com/insolar/assured-ledger/blob/master/LICENSE.md.
     5  
     6  package keyset
     7  
     8  // Creates a new empty mutable set
     9  func NewMutable() MutableKeySet {
    10  	return MutableKeySet{newInternalMutable(false, emptyBasicKeySet)}
    11  }
    12  
    13  // Creates a new mutable open set - initial state will match any keys
    14  func NewOpenMutable() MutableKeySet {
    15  	return MutableKeySet{newInternalMutable(true, emptyBasicKeySet)}
    16  }
    17  
    18  // Creates a mutable overlay over an immutable list. The overlay will track all additions and removals.
    19  // The provided KeyList must be immutable or behavior of the overlay will be incorrect.
    20  func WrapAsMutable(keys KeyList) MutableKeySet {
    21  	return MutableKeySet{newMutableOverlay(keys)}
    22  }
    23  
    24  var _ KeySet = &MutableKeySet{}
    25  
    26  // WARNING! Any KeySet(s) returned by MutableKeySet can change, unless MutableKeySet is frozen.
    27  // Can't be casted to a KeyList as can be changed to be an open set.
    28  type MutableKeySet struct {
    29  	mutableKeySet
    30  }
    31  
    32  func newInternalMutable(exclusive bool, ks internalKeySet) mutableKeySet {
    33  	switch {
    34  	case ks == nil:
    35  		panic("illegal value")
    36  	case exclusive:
    37  		return &exclusiveMutable{exclusiveKeySet{ks}}
    38  	default:
    39  		return &inclusiveMutable{inclusiveKeySet{ks}}
    40  	}
    41  }
    42  
    43  func (v *MutableKeySet) copyAs(exclusive bool) mutableKeySet {
    44  	return newInternalMutable(exclusive, v.mutableKeySet.copy(0))
    45  }
    46  
    47  // creates a copy of this set
    48  func (v *MutableKeySet) Copy() *MutableKeySet {
    49  	return &MutableKeySet{v.copyAs(v.IsOpenSet())}
    50  }
    51  
    52  // creates an complementary copy of this set
    53  func (v *MutableKeySet) InverseCopy() *MutableKeySet {
    54  	return &MutableKeySet{v.copyAs(!v.IsOpenSet())}
    55  }
    56  
    57  // makes this set immutable - modification methods will panic
    58  func (v *MutableKeySet) Freeze() KeySet {
    59  	if fks, ok := v.mutableKeySet.(frozenKeySet); ok {
    60  		return fks.copyKeySet
    61  	}
    62  	ks := v.mutableKeySet
    63  	if ks == nil {
    64  		panic("illegal state")
    65  	}
    66  	v.mutableKeySet = frozenKeySet{ks}
    67  	return ks
    68  }
    69  
    70  // this set was made immutable - modification methods will panic
    71  func (v *MutableKeySet) IsFrozen() bool {
    72  	_, ok := v.mutableKeySet.(frozenKeySet)
    73  	return ok
    74  }
    75  
    76  // only keys present in both sets will remain in this set
    77  func (v *MutableKeySet) RetainAll(ks KeySet) {
    78  	if iks := v.mutableKeySet.retainAll(ks); iks != nil {
    79  		v.mutableKeySet = iks
    80  	}
    81  }
    82  
    83  // only keys not present in the given set will remain in this set
    84  func (v *MutableKeySet) RemoveAll(ks KeySet) {
    85  	if iks := v.mutableKeySet.removeAll(ks); iks != nil {
    86  		v.mutableKeySet = iks
    87  	}
    88  }
    89  
    90  // adds to this set all keys from the given one. Repeated keys are ignored.
    91  func (v *MutableKeySet) AddAll(ks KeySet) {
    92  	if iks := v.mutableKeySet.addAll(ks); iks != nil {
    93  		v.mutableKeySet = iks
    94  	}
    95  }
    96  
    97  // removes a key from this set. Does nothing when a key is missing.
    98  func (v *MutableKeySet) Remove(k Key) {
    99  	v.mutableKeySet.remove(k)
   100  }
   101  
   102  // removes keys from this set. Does nothing when a key is missing.
   103  func (v *MutableKeySet) RemoveKeys(keys []Key) {
   104  	v.mutableKeySet.removeKeys(keys)
   105  }
   106  
   107  // add a key to this set. Repeated keys are ignored.
   108  func (v *MutableKeySet) Add(k Key) {
   109  	v.mutableKeySet.add(k)
   110  }
   111  
   112  // adds to this set all keys from the given list. Repeated keys are ignored.
   113  func (v *MutableKeySet) AddKeys(keys []Key) {
   114  	v.mutableKeySet.addKeys(keys)
   115  }
   116  
   117  type frozenKeySet struct {
   118  	copyKeySet
   119  }
   120  
   121  func (frozenKeySet) removeKeys(k []Key) {
   122  	panic("illegal state")
   123  }
   124  
   125  func (frozenKeySet) addKeys(k []Key) {
   126  	panic("illegal state")
   127  }
   128  
   129  func (frozenKeySet) retainAll(ks KeySet) mutableKeySet {
   130  	panic("illegal state")
   131  }
   132  
   133  func (frozenKeySet) removeAll(ks KeySet) mutableKeySet {
   134  	panic("illegal state")
   135  }
   136  
   137  func (frozenKeySet) addAll(ks KeySet) mutableKeySet {
   138  	panic("illegal state")
   139  }
   140  
   141  func (frozenKeySet) remove(k Key) {
   142  	panic("illegal state")
   143  }
   144  
   145  func (frozenKeySet) add(k Key) {
   146  	panic("illegal state")
   147  }