// CreationTsLow sets the optional parameter "creation_ts_low":
517600
func (c *SearchCall) CreationTsLow(creationTsLow int64) *SearchCall {
	c.urlParams_.Set("creation_ts_low", fmt.Sprint(creationTsLow))
	return c
}
1224777
func (gce *Cloud) CreateTargetHTTPSProxy(urlMap *compute.UrlMap, sslCert *compute.SslCertificate, name string) (*compute.TargetHttpsProxy, error) {
	proxy := &compute.TargetHttpsProxy{
		Name:            name,
		UrlMap:          urlMap.SelfLink,
		SslCertificates: []string{sslCert.SelfLink},
	}
	op, err := gce.service.TargetHttpsProxies.Insert(gce.projectID, proxy).Do()
	if err != nil {
		return nil, err
	}
	if err = gce.waitForGlobalOp(op); err != nil {
		return nil, err
	}
	return gce.GetTargetHTTPSProxy(name)
}
587433
func (b *BigIP) CreateTrunk(name, interfaces string, lacp bool) error {
	rawInts := strings.Split(interfaces, ",")
	ints := []string{}

	for _, i := range rawInts {
		ints = append(ints, strings.Trim(i, " "))
	}

	config := &Trunk{
		Name:       name,
		Interfaces: ints,
	}

	if lacp {
		config.LACP = "enabled"
	}

	return b.post(config, uriNet, uriTrunk)
}
1298912
func (st *StatsConn) Create(ctx context.Context, filePath string, contents []byte) (Version, error) {
	startTime := time.Now()
	statsKey := []string{"Create", st.cell}
	defer topoStatsConnTimings.Record(statsKey, startTime)
	res, err := st.conn.Create(ctx, filePath, contents)
	if err != nil {
		topoStatsConnErrors.Add(statsKey, int64(1))
		return res, err
	}
	return res, err
}
436573
func (c *Client) CreateDNSRecord(domain, name, rtype, data string, priority, ttl int) error {
	values := url.Values{
		"domain":   {domain},
		"name":     {name},
		"type":     {rtype},
		"data":     {data},
		"priority": {fmt.Sprintf("%v", priority)},
		"ttl":      {fmt.Sprintf("%v", ttl)},
	}

	if err := c.post(`dns/create_record`, values, nil); err != nil {
		return err
	}
	return nil
}
669451
func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) {
	if cfg == nil {
		cfg = new(Config)
	}
	setDefaults(cfg)

	if cfg.State == nil {
		cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()))
	}
	var (
		vmenv  = NewEnv(cfg)
		sender = vm.AccountRef(cfg.Origin)
	)

	// Call the code with the given configuration.
	code, address, leftOverGas, err := vmenv.Create(
		sender,
		input,
		cfg.GasLimit,
		cfg.Value,
	)
	return code, address, leftOverGas, err
}
1179566
func CreateTLSConfig(remoteCAs *x509.CertPool, cert *tls.Certificate) *tls.Config {
	var certs []tls.Certificate
	if cert != nil {
		certs = []tls.Certificate{*cert}
	}
	return &tls.Config{
		Certificates: certs,
		RootCAs:      remoteCAs,
	}
}
133875
func (g *gatewayCfg) saveTLSHostname(u *url.URL) {
	if g.TLSConfig != nil && g.tlsName == "" && net.ParseIP(u.Hostname()) == nil {
		g.tlsName = u.Hostname()
	}
}
140334
func (s *VLANService) CreateVlanIpRange(p *CreateVlanIpRangeParams) (*CreateVlanIpRangeResponse, error) {
	resp, err := s.cs.newRequest("createVlanIpRange", p.toURLValues())
	if err != nil {
		return nil, err
	}

	var r CreateVlanIpRangeResponse
	if err := json.Unmarshal(resp, &r); err != nil {
		return nil, err
	}

	return &r, nil
}
669316
func (v *azureVolumeSource) CreateVolumes(ctx context.ProviderCallContext, params []storage.VolumeParams) (_ []storage.CreateVolumesResult, err error) {
	results := make([]storage.CreateVolumesResult, len(params))
	for i, p := range params {
		if err := v.ValidateVolumeParams(p); err != nil {
			results[i].Error = err
			continue
		}
	}
	if v.maybeStorageClient == nil {
		v.createManagedDiskVolumes(ctx, params, results)
		return results, nil
	}
	return results, v.createUnmanagedDiskVolumes(ctx, params, results)
}
599338
func (tgz *TarGz) Create(out io.Writer) error {
	tgz.wrapWriter()
	return tgz.Tar.Create(out)
}
94392
func (cs *TeamService) Create(team Team) (*TeamResponse, error) {
	if err := team.Valid(); err != nil {
		return nil, err
	}

	req, err := cs.client.NewRequest("POST", "/teams", team.PostParams())
	if err != nil {
		return nil, err
	}

	t := &TeamResponse{}
	_, err = cs.client.Do(req, t)
	if err != nil {
		return nil, err
	}
	return t, err
}
176285
func (c *Client) CreateSSHKey(name, key string) (SSHKey, error) {
	values := url.Values{
		"name":    {name},
		"ssh_key": {key},
	}

	var sshKey SSHKey
	if err := c.post(`sshkey/create`, values, &sshKey); err != nil {
		return SSHKey{}, err
	}
	sshKey.Name = name
	sshKey.Key = key

	return sshKey, nil
}
346071
func (p *PacketFlow) GenerateTCPFlow(pt PacketFlowType) (PacketFlowManipulator, error) {

	if pt == 0 {
		//Create a SYN packet to initialize the flow
		firstPacket := NewPacket()
		if err := firstPacket.AddEthernetLayer(p.sMAC, p.dMAC); err != nil {
			return nil, fmt.Errorf("unable tp add ethernet layer: %s", err)
		}
		if err := firstPacket.AddIPLayer(p.sIP, p.dIP); err != nil {
			return nil, fmt.Errorf("unable to add ip layer: %s", err)
		}
		if err := firstPacket.AddTCPLayer(p.sPort, p.dPort); err != nil {
			return nil, fmt.Errorf("unable to add tcp layer: %s", err)
		}
		firstPacket.SetTCPSyn()
		firstPacket.SetTCPSequenceNumber(firstPacket.GetTCPSequenceNumber())
		firstPacket.SetTCPAcknowledgementNumber(firstPacket.GetTCPAcknowledgementNumber())
		synPacket, _ := firstPacket.(*Packet)

		p.flow = append(p.flow, synPacket)

		//Create a SynAck packet
		secondPacket := NewPacket()
		if err := secondPacket.AddEthernetLayer(p.sMAC, p.dMAC); err != nil {
			return nil, fmt.Errorf("unable to add ethernet layer: %s", err)
		}
		if err := secondPacket.AddIPLayer(p.dIP, p.sIP); err != nil {
			return nil, fmt.Errorf("unable to add ip layer: %s", err)
		}
		if err := secondPacket.AddTCPLayer(p.dPort, p.sPort); err != nil {
			return nil, fmt.Errorf("unable to add tcp layer: %s", err)
		}
		secondPacket.SetTCPSynAck()
		secondPacket.SetTCPSequenceNumber(0)
		secondPacket.SetTCPAcknowledgementNumber(firstPacket.GetTCPSequenceNumber() + 1)
		synackPacket, _ := secondPacket.(*Packet)

		p.flow = append(p.flow, synackPacket)

		//Create an Ack Packet
		thirdPacket := NewPacket()
		if err := thirdPacket.AddEthernetLayer(p.sMAC, p.dMAC); err != nil {
			return nil, fmt.Errorf("unable tp add ethernet layer: %s", err)
		}
		if err := thirdPacket.AddIPLayer(p.sIP, p.dIP); err != nil {
			return nil, fmt.Errorf("unable to add ip layer: %s", err)
		}
		if err := thirdPacket.AddTCPLayer(p.sPort, p.dPort); err != nil {
			return nil, fmt.Errorf("unable to add tcp layer: %s", err)
		}
		thirdPacket.SetTCPAck()
		thirdPacket.SetTCPSequenceNumber(secondPacket.GetTCPAcknowledgementNumber())
		thirdPacket.SetTCPAcknowledgementNumber(secondPacket.GetTCPSequenceNumber() + 1)
		ackPacket, _ := thirdPacket.(*Packet)

		p.flow = append(p.flow, ackPacket)

		return p, nil

	} else if pt == 1 {

		for i := 0; i < len(PacketFlowTemplate1); i++ {
			//Create a Packet type variable to store decoded packet
			newPacket := NewPacket()
			packet := gopacket.NewPacket(PacketFlowTemplate1[i], layers.LayerTypeEthernet, gopacket.Default)
			newPacket.AddPacket(packet)

			p.flow = append(p.flow, newPacket.DecodePacket())

		}

		return p, nil
	} else if pt == 2 {

		for i := 0; i < len(PacketFlowTemplate2); i++ {

			//Create a Packet type variable to store decoded packet
			newPacket := NewPacket()
			packet := gopacket.NewPacket(PacketFlowTemplate2[i], layers.LayerTypeEthernet, gopacket.Default)
			newPacket.AddPacket(packet)

			p.flow = append(p.flow, newPacket.DecodePacket())

		}

		return p, nil
	} else if pt == 3 {

		for i := 0; i < len(PacketFlowTemplate3); i++ {

			//Create a Packet type variable to store decoded packet
			newPacket := NewPacket()
			packet := gopacket.NewPacket(PacketFlowTemplate3[i], layers.LayerTypeEthernet, gopacket.Default)
			newPacket.AddPacket(packet)

			p.flow = append(p.flow, newPacket.DecodePacket())

		}

		return p, nil
	}

	return nil, nil
}
683377
func (s *SSHService) NewCreateSSHKeyPairParams(name string) *CreateSSHKeyPairParams {
	p := &CreateSSHKeyPairParams{}
	p.p = make(map[string]interface{})
	p.p["name"] = name
	return p
}
940992
func (client *Client) SslCreate(productType string, years int) (*SslCreateResult, error) {
	requestInfo := &ApiRequest{
		command: sslCreate,
		method:  "POST",
		params:  url.Values{},
	}
	requestInfo.params.Set("Type", productType)
	requestInfo.params.Set("Years", strconv.Itoa(years))

	resp, err := client.do(requestInfo)
	if err != nil {
		return nil, err
	}

	return resp.SslCreate, nil
}
315239
func (p *PullRequestsService) Create(params interface{}) (pull *PullRequest, result *Result) {
	result = p.client.post(p.URL, params, &pull)
	return
}