rename it

ipv4/set.go

@@ -341,11 +341,11 @@ func (me Set) isValid() bool {
 	return me.trie.isValid()
 }
 
-// FindPrefixWithLength returns a Prefix with a Mask of the given prefix length
-// that is contained by the current set but does not overlap the given reserved
-// set. The returned Prefix is optimally placed to avoid any further IP space
+// GetBestFit returns a Prefix with a Mask of the given prefix length that is
+// contained by the current set but does not overlap the given reserved set.
+// The returned Prefix is optimally placed to avoid any further IP space
 // fragmentation. An error is returned if there is not enough space to allocate
-func (me Set) FindPrefixWithLength(reserved SetI, length uint32) (Prefix, error) {
+func (me Set) GetBestFit(reserved SetI, length uint32) (Prefix, error) {
 	prefix, err := me.trie.FindSmallestContainingPrefix(reserved.Set().trie, length)
 	if err != nil {
 		return Prefix{}, fmt.Errorf("no room for prefix of given length")

ipv4/set_test.go

@@ -1072,7 +1072,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 			})
 
 			// Call the method under test to find the best allocation to avoid fragmentation.
-			prefix, err := space.FindPrefixWithLength(reserved, tt.length)
+			prefix, err := space.GetBestFit(reserved, tt.length)
 
 			assert.Equal(t, tt.err, err != nil)
 			if err != nil {
@@ -1121,7 +1121,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 			maxExponent := log2(available)
 
 			// Finding the maximum prefix here, proves we are avoiding fragmentation
-			maxPrefix, err := space.FindPrefixWithLength(reserved, 32-maxExponent)
+			maxPrefix, err := space.GetBestFit(reserved, 32-maxExponent)
 			assert.Nil(t, err)
 			assert.Equal(t, pow2(maxExponent), maxPrefix.NumAddresses())
 			assert.Equal(t, int64(0), reserved.Intersection(maxPrefix).NumAddresses())
@@ -1132,7 +1132,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 				randomSize = 12
 			}
 
-			randomSizePrefix, err := space.FindPrefixWithLength(reserved, 32-randomSize)
+			randomSizePrefix, err := space.GetBestFit(reserved, 32-randomSize)
 			assert.Nil(t, err)
 			assert.Equal(t, pow2(randomSize), randomSizePrefix.NumAddresses())
 			assert.Equal(t, int64(0), reserved.Intersection(randomSizePrefix).NumAddresses())

ipv6/set.go

@@ -329,11 +329,11 @@ func (me Set) isValid() bool {
 	return me.trie.isValid()
 }
 
-// FindPrefixWithLength returns a Prefix with a Mask of the given prefix length
+// GetBestFit returns a Prefix with a Mask of the given prefix length
 // that is contained by the current set but does not overlap the given reserved
 // set. The returned Prefix is optimally placed to avoid any further IP space
 // fragmentation. An error is returned if there is not enough space to allocate
-func (me Set) FindPrefixWithLength(reserved SetI, length uint32) (Prefix, error) {
+func (me Set) GetBestFit(reserved SetI, length uint32) (Prefix, error) {
 	prefix, err := me.trie.FindSmallestContainingPrefix(reserved.Set().trie, length)
 	if err != nil {
 		return Prefix{}, fmt.Errorf("no room for prefix of given length")

ipv6/set_test.go

@@ -991,7 +991,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 			})
 
 			// Call the method under test to find the best allocation to avoid fragmentation.
-			prefix, err := space.FindPrefixWithLength(reserved, tt.length)
+			prefix, err := space.GetBestFit(reserved, tt.length)
 
 			assert.Equal(t, tt.err, err != nil)
 			if err != nil {
@@ -1040,7 +1040,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 			maxExponent := log2(available)
 
 			// Finding the maximum prefix here, proves we are avoiding fragmentation
-			maxPrefix, err := space.FindPrefixWithLength(reserved, 128-maxExponent)
+			maxPrefix, err := space.GetBestFit(reserved, 128-maxExponent)
 			assert.Nil(t, err)
 			maxPrefixes, _ := maxPrefix.NumPrefixes(128)
 			assert.Equal(t, pow2(maxExponent), maxPrefixes)
@@ -1052,7 +1052,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 				randomSize = 12
 			}
 
-			randomSizePrefix, err := space.FindPrefixWithLength(reserved, 128-randomSize)
+			randomSizePrefix, err := space.GetBestFit(reserved, 128-randomSize)
 			assert.Nil(t, err)
 			randomSizePrefixes, _ := randomSizePrefix.NumPrefixes(128)
 			assert.Equal(t, pow2(randomSize), randomSizePrefixes)
@@ -1084,7 +1084,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 			maxExponent := log2(available)
 
 			// Finding the maximum prefix here, proves we are avoiding fragmentation
-			maxPrefix, err := space.FindPrefixWithLength(reserved, 64-maxExponent)
+			maxPrefix, err := space.GetBestFit(reserved, 64-maxExponent)
 			assert.Nil(t, err)
 			maxPrefixes, _ := maxPrefix.NumPrefixes(64)
 			assert.Equal(t, pow2(maxExponent), maxPrefixes)
@@ -1096,7 +1096,7 @@ func TestFindPrefixWithLength(t *testing.T) {
 				randomSize = 12
 			}
 
-			randomSizePrefix, err := space.FindPrefixWithLength(reserved, 64-randomSize)
+			randomSizePrefix, err := space.GetBestFit(reserved, 64-randomSize)
 			assert.Nil(t, err)
 			randomSizePrefixes, _ := randomSizePrefix.NumPrefixes(64)
 			assert.Equal(t, pow2(randomSize), randomSizePrefixes)