github.com/pulumi/terraform@v1.4.0/pkg/command/jsonformat/differ/change_slice.go (about)

     1  package differ
     2  
     3  import (
     4  	"github.com/pulumi/terraform/pkg/command/jsonformat/differ/attribute_path"
     5  )
     6  
     7  // ChangeSlice is a Change that represents a Tuple, Set, or List type, and has
     8  // converted the relevant interfaces into slices for easier access.
     9  type ChangeSlice struct {
    10  	// Before contains the value before the proposed change.
    11  	Before []interface{}
    12  
    13  	// After contains the value after the proposed change.
    14  	After []interface{}
    15  
    16  	// Unknown contains the unknown status of any elements of this list/set.
    17  	Unknown []interface{}
    18  
    19  	// BeforeSensitive contains the before sensitive status of any elements of
    20  	//this list/set.
    21  	BeforeSensitive []interface{}
    22  
    23  	// AfterSensitive contains the after sensitive status of any elements of
    24  	//this list/set.
    25  	AfterSensitive []interface{}
    26  
    27  	// ReplacePaths matches the same attributes in Change exactly.
    28  	ReplacePaths attribute_path.Matcher
    29  
    30  	// RelevantAttributes matches the same attributes in Change exactly.
    31  	RelevantAttributes attribute_path.Matcher
    32  }
    33  
    34  func (change Change) asSlice() ChangeSlice {
    35  	return ChangeSlice{
    36  		Before:             genericToSlice(change.Before),
    37  		After:              genericToSlice(change.After),
    38  		Unknown:            genericToSlice(change.Unknown),
    39  		BeforeSensitive:    genericToSlice(change.BeforeSensitive),
    40  		AfterSensitive:     genericToSlice(change.AfterSensitive),
    41  		ReplacePaths:       change.ReplacePaths,
    42  		RelevantAttributes: change.RelevantAttributes,
    43  	}
    44  }
    45  
    46  func (s ChangeSlice) getChild(beforeIx, afterIx int) Change {
    47  	before, beforeExplicit := getFromGenericSlice(s.Before, beforeIx)
    48  	after, afterExplicit := getFromGenericSlice(s.After, afterIx)
    49  	unknown, _ := getFromGenericSlice(s.Unknown, afterIx)
    50  	beforeSensitive, _ := getFromGenericSlice(s.BeforeSensitive, beforeIx)
    51  	afterSensitive, _ := getFromGenericSlice(s.AfterSensitive, afterIx)
    52  
    53  	mostRelevantIx := beforeIx
    54  	if beforeIx < 0 || beforeIx >= len(s.Before) {
    55  		mostRelevantIx = afterIx
    56  	}
    57  
    58  	return Change{
    59  		BeforeExplicit:     beforeExplicit,
    60  		AfterExplicit:      afterExplicit,
    61  		Before:             before,
    62  		After:              after,
    63  		Unknown:            unknown,
    64  		BeforeSensitive:    beforeSensitive,
    65  		AfterSensitive:     afterSensitive,
    66  		ReplacePaths:       s.ReplacePaths.GetChildWithIndex(mostRelevantIx),
    67  		RelevantAttributes: s.RelevantAttributes.GetChildWithIndex(mostRelevantIx),
    68  	}
    69  }
    70  
    71  func getFromGenericSlice(generic []interface{}, ix int) (interface{}, bool) {
    72  	if generic == nil {
    73  		return nil, false
    74  	}
    75  	if ix < 0 || ix >= len(generic) {
    76  		return nil, false
    77  	}
    78  	return generic[ix], true
    79  }
    80  
    81  func genericToSlice(generic interface{}) []interface{} {
    82  	if concrete, ok := generic.([]interface{}); ok {
    83  		return concrete
    84  	}
    85  	return nil
    86  }