// AddDI adds a NewDimensionInfo of which configurations needs to be taken
501333
func AddDI(dimensionInfo string) (map[string]string, error) {
	config, err := factory.AddByDimensionInfo(dimensionInfo)
	return config, err
}
978040
func (s *GetIntegrationInput) SetIntegrationId(v string) *GetIntegrationInput {
	s.IntegrationId = &v
	return s
}
1302216
func (s *MultipartUpload) SetUploadId(v string) *MultipartUpload {
	s.UploadId = &v
	return s
}
161917
func (s *DeleteIntegrationInput) SetIntegrationId(v string) *DeleteIntegrationInput {
	s.IntegrationId = &v
	return s
}
322347
func (c *RedisClient) AddMulti(rs []AddRequest) ([]string, error) {
	for _, r := range rs {
		if err := c.conn.Send("ADDJOB", addArgs(r)...); err != nil {
			return nil, err
		}
	}
	// flush the output buffer and receive pending replies
	replies, err := redis.Values(c.conn.Do(""))
	ids := make([]string, len(replies))
	for i, val := range replies {
		if id, ok := val.(string); ok {
			ids[i] = id
		}
	}
	return ids, err
}
958186
func (s *UpdateIntegrationOutput) SetIntegrationId(v string) *UpdateIntegrationOutput {
	s.IntegrationId = &v
	return s
}
1038654
func (s *DeleteIntegrationResponseInput) SetIntegrationId(v string) *DeleteIntegrationResponseInput {
	s.IntegrationId = &v
	return s
}
1288728
func (s *InitiateLayerUploadOutput) SetUploadId(v string) *InitiateLayerUploadOutput {
	s.UploadId = &v
	return s
}
1353194
func (c *Client) AddNIC(machineID, networkID string) (*NIC, error) {
	resp := new(NIC)
	req := request{
		method:         client.POST,
		url:            makeURL(apiMachines, machineID, apiNICs),
		reqValue:       addNICOptions{networkID},
		resp:           resp,
		expectedStatus: http.StatusCreated,
	}
	if _, err := c.sendRequest(req); err != nil {
		return nil, errors.Newf(err, "failed to add NIC to machine %s on network: %s", machineID, networkID)
	}
	return resp, nil
}
112820
func (t *Topology) addID(nodeID string) bool {
	t.mu.Lock()
	defer t.mu.Unlock()
	if t.containsID(nodeID) {
		return false
	}
	t.nodeIDs = append(t.nodeIDs, nodeID)

	sort.Slice(t.nodeIDs,
		func(i, j int) bool {
			return t.nodeIDs[i] < t.nodeIDs[j]
		})

	return true
}
665671
func HyperxlNicAdd(ctx LibxlCtxPtr, domid uint32, ip, bridge, gatewaydev, ifname string, mac []byte) int {
	var nic *HyperxlNicConfig = &HyperxlNicConfig{
		ip:         C.CString(ip),
		bridge:     C.CString(bridge),
		gatewaydev: C.CString(gatewaydev),
		mac:        (*C.char)(unsafe.Pointer(&mac[0])),
		ifname:     C.CString(ifname),
	}
	return (int)(C.hyperxl_nic_add((*C.struct_libxl__ctx)(ctx), (C.uint32_t)(domid), (*C.struct_hyperxl_nic_config)(nic)))
}
234549
func (d *Domain) AddIOThread(id uint, flags DomainModificationImpact) error {
	if C.LIBVIR_VERSION_NUMBER < 1002015 {
		return makeNotImplementedError("virDomainAddIOThread")
	}
	var err C.virError
	ret := C.virDomainAddIOThreadWrapper(d.ptr, C.uint(id), C.uint(flags), &err)
	if ret == -1 {
		return makeError(&err)
	}

	return nil
}
1075065
func (d *DashboardsStore) AddIDs(ctx context.Context, boards []chronograf.Dashboard) error {
	for _, board := range boards {
		update := false
		for i, cell := range board.Cells {
			// If there are is no id set, we generate one and update the dashboard
			if cell.ID == "" {
				id, err := d.IDs.Generate()
				if err != nil {
					return err
				}
				cell.ID = id
				board.Cells[i] = cell
				update = true
			}
		}
		if !update {
			continue
		}
		if err := d.Update(ctx, board); err != nil {
			return err
		}
	}
	return nil
}
995883
func (s *CreateIntegrationResponseInput) SetIntegrationId(v string) *CreateIntegrationResponseInput {
	s.IntegrationId = &v
	return s
}
290235
func (s *UpdateConfigurationRequest) SetConfigurationId(v string) *UpdateConfigurationRequest {
	s.ConfigurationId = &v
	return s
}
1256144
func (s *GetIntegrationOutput) SetIntegrationId(v string) *GetIntegrationOutput {
	s.IntegrationId = &v
	return s
}
326395
func (c *Client) AddDimensionValue(ctx context.Context, filterID, name, value string) error {
	uri := fmt.Sprintf("%s/filters/%s/dimensions/%s/options/%s", c.url, filterID, name, value)

	clientlog.Do(ctx, "adding dimension option to filter job", service, uri, log.Data{
		"method": "POST",
		"value":  value,
	})

	req, err := http.NewRequest("POST", uri, nil)
	if err != nil {
		return err
	}

	resp, err := c.cli.Do(ctx, req)
	if err != nil {
		return err
	}

	if resp.StatusCode != http.StatusCreated {
		return &ErrInvalidFilterAPIResponse{http.StatusCreated, resp.StatusCode, uri}
	}
	return nil
}