github.com/vmware/go-vcloud-director/v2@v2.24.0/govcd/openapi_generic_outer_entities.go (about)

     1  package govcd
     2  
     3  import (
     4  	"fmt"
     5  	"net/http"
     6  )
     7  
     8  // Generic type explanations
     9  // Common generic parameter names seen in this code
    10  // O - Outer type that is in the `govcd` package. (e.g. 'IpSpace')
    11  // I - Inner type the type that is being marshalled/unmarshalled (usually in `types` package. E.g. `types.IpSpace`)
    12  
    13  // outerEntityWrapper is a type constraint that outer entities must implement in order to
    14  // use generic CRUD functions defined in this file
    15  type outerEntityWrapper[O any, I any] interface {
    16  	// wrap is a value receiver function that must implement one thing for a concrete type - wrap
    17  	// pointer to innter entity I and return pointer to outer entity O
    18  	wrap(inner *I) *O
    19  }
    20  
    21  // createOuterEntity creates an outer entity with given inner entity config
    22  func createOuterEntity[O outerEntityWrapper[O, I], I any](client *Client, outerEntity O, c crudConfig, innerEntityConfig *I) (*O, error) {
    23  	if innerEntityConfig == nil {
    24  		return nil, fmt.Errorf("entity config '%s' cannot be empty for create operation", c.entityLabel)
    25  	}
    26  
    27  	createdInnerEntity, err := createInnerEntity(client, c, innerEntityConfig)
    28  	if err != nil {
    29  		return nil, err
    30  	}
    31  
    32  	return outerEntity.wrap(createdInnerEntity), nil
    33  }
    34  
    35  // updateOuterEntity updates an outer entity with given inner entity config
    36  func updateOuterEntity[O outerEntityWrapper[O, I], I any](client *Client, outerEntity O, c crudConfig, innerEntityConfig *I) (*O, error) {
    37  	if innerEntityConfig == nil {
    38  		return nil, fmt.Errorf("entity config '%s' cannot be empty for update operation", c.entityLabel)
    39  	}
    40  
    41  	updatedInnerEntity, err := updateInnerEntity(client, c, innerEntityConfig)
    42  	if err != nil {
    43  		return nil, err
    44  	}
    45  
    46  	return outerEntity.wrap(updatedInnerEntity), nil
    47  }
    48  
    49  // getOuterEntity retrieves a single outer entity
    50  func getOuterEntity[O outerEntityWrapper[O, I], I any](client *Client, outerEntity O, c crudConfig) (*O, error) {
    51  	retrievedInnerEntity, err := getInnerEntity[I](client, c)
    52  	if err != nil {
    53  		return nil, err
    54  	}
    55  
    56  	return outerEntity.wrap(retrievedInnerEntity), nil
    57  }
    58  
    59  // getOuterEntity retrieves a single outer entity
    60  func getOuterEntityWithHeaders[O outerEntityWrapper[O, I], I any](client *Client, outerEntity O, c crudConfig) (*O, http.Header, error) {
    61  	retrievedInnerEntity, headers, err := getInnerEntityWithHeaders[I](client, c)
    62  	if err != nil {
    63  		return nil, nil, err
    64  	}
    65  
    66  	return outerEntity.wrap(retrievedInnerEntity), headers, nil
    67  }
    68  
    69  // getAllOuterEntities retrieves all outer entities
    70  func getAllOuterEntities[O outerEntityWrapper[O, I], I any](client *Client, outerEntity O, c crudConfig) ([]*O, error) {
    71  	retrievedAllInnerEntities, err := getAllInnerEntities[I](client, c)
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  
    76  	wrappedOuterEntities := make([]*O, len(retrievedAllInnerEntities))
    77  	for index, singleInnerEntity := range retrievedAllInnerEntities {
    78  		// outerEntity.wrap() is a value receiver, therefore it creates a shallow copy for each call
    79  		wrappedOuterEntities[index] = outerEntity.wrap(singleInnerEntity)
    80  	}
    81  
    82  	return wrappedOuterEntities, nil
    83  }