code: func (obj *ResourceInstanceObjectSrc) DeepCopy() *ResourceInstanceObjectSrc {
  	if obj == nil {
  		return nil
  	}
  
  	var attrsFlat map[string]string
  	if obj.AttrsFlat != nil {
  		attrsFlat = make(map[string]string, len(obj.AttrsFlat))
  		for k, v := range obj.AttrsFlat {
  			attrsFlat[k] = v
  		}
  	}
  
  	var attrsJSON []byte
  	if obj.AttrsJSON != nil {
  		attrsJSON = make([]byte, len(obj.AttrsJSON))
  		copy(attrsJSON, obj.AttrsJSON)
  	}
  
  	var private []byte
  	if obj.Private != nil {
  		private := make([]byte, len(obj.Private))
  		copy(private, obj.Private)
  	}
  
  	// Some addrs.Referencable implementations are technically mutable, but
  	// we treat them as immutable by convention and so we don't deep-copy here.
  	dependencies := make([]addrs.Referenceable, len(obj.Dependencies))
  	copy(dependencies, obj.Dependencies)
  
  	return &ResourceInstanceObjectSrc{
  		Status:        obj.Status,
  		SchemaVersion: obj.SchemaVersion,
  		Private:       private,
  		AttrsFlat:     attrsFlat,
  		AttrsJSON:     attrsJSON,
  		Dependencies:  dependencies,
  	}
  }
docs: // DeepCopy returns a new resource instance object that contains equivalent data
  // to the receiver but shares no backing memory in common.
  //
  // As with all methods on ResourceInstanceObjectSrc, this method is not safe to
  // use concurrently with writing to any portion of the recieving data structure.
  // It is the caller's responsibility to ensure mutual exclusion for the duration
  // of the operation, but may then freely modify the receiver and the returned
  // copy independently once this method returns.