// Project retrieves the ProjectClient
354171
func (c *Clientset) Project() projectinternalversion.ProjectInterface {
	return &fakeprojectinternalversion.FakeProject{Fake: &c.Fake}
}
904337
func ProjectID(projectID string) Option {
	return func(c *Client) error {
		c.projectID = projectID
		return nil
	}
}
257005
func ProjectFromNamespace(ns string) types.ProjectName {
	if !strings.HasPrefix(ns, ProjectNamespacePrefix) {
		return ""
	}
	return types.ProjectName(ns[len(ProjectNamespacePrefix):])
}
974035
func (c *ProjectsClient) Create(ctx context.Context, createProject *CreateProject) (*Project, error) {
	p := "/projects"

	req, err := c.backend.NewRequest(http.MethodPost, p, nil, createProject)
	if err != nil {
		return nil, err
	}

	var resp Project
	_, err = c.backend.Do(ctx, req, &resp, func(code int) error {
		return &Error{}
	})
	if err != nil {
		return nil, err
	}

	return &resp, nil
}
710304
func (c *projectRequests) Create(projectRequest *project.ProjectRequest) (result *project.Project, err error) {
	result = &project.Project{}
	err = c.client.Post().
		Resource("projectrequests").
		Body(projectRequest).
		Do().
		Into(result)
	return
}
21389
func (p *Polyline) Project(point Point) (Point, int) {
	if len(*p) == 1 {
		// If there is only one vertex, it is always closest to any given point.
		return (*p)[0], 1
	}

	// Initial value larger than any possible distance on the unit sphere.
	minDist := 10 * s1.Radian
	minIndex := -1

	// Find the line segment in the polyline that is closest to the point given.
	for i := 1; i < len(*p); i++ {
		if dist := DistanceFromSegment(point, (*p)[i-1], (*p)[i]); dist < minDist {
			minDist = dist
			minIndex = i
		}
	}

	// Compute the point on the segment found that is closest to the point given.
	closest := Project(point, (*p)[minIndex-1], (*p)[minIndex])
	if closest == (*p)[minIndex] {
		minIndex++
	}

	return closest, minIndex
}
347893
func (m Matrix) Project(u Vec) Vec {
	return Vec{m[0]*u.X + m[2]*u.Y + m[4], m[1]*u.X + m[3]*u.Y + m[5]}
}
1302311
func (c *Client) UpdateProject(projectName string, project *ProjectModel) (result ResultModel, err error) {

	postObjContent, _ := json.Marshal(project)
	postJson := string(postObjContent)

	requestUrl := c.GetUrl("projects", "", projectName)
	requestPath := GetRequestPath("projects", "", projectName)

	responseResult, err := c.GetResponseJson("PUT", requestUrl, requestPath, postJson)

	if err != nil {
		return result, err
	}

	err = json.Unmarshal([]byte(responseResult), &result)

	return result, err
}
1026297
func (p *Path) Project(point *Point) float64 {
	return p.Measure(point) / p.Distance()
}
207178
func (p *InvitationProjector) Project(ctx context.Context, event eh.Event, entity eh.Entity) (eh.Entity, error) {
	i, ok := entity.(*Invitation)
	if !ok {
		return nil, errors.New("model is of incorrect type")
	}

	// Apply the changes for the event.
	switch event.EventType() {
	case InviteCreatedEvent:
		data, ok := event.Data().(*InviteCreatedData)
		if !ok {
			return nil, fmt.Errorf("projector: invalid event data type: %v", event.Data())
		}
		i.ID = event.AggregateID()
		i.Name = data.Name
		i.Age = data.Age

	case InviteAcceptedEvent:
		i.Status = "accepted"

	case InviteDeclinedEvent:
		i.Status = "declined"

	case InviteConfirmedEvent:
		i.Status = "confirmed"

	case InviteDeniedEvent:
		i.Status = "denied"

	default:
		return nil, errors.New("could not handle event: " + event.String())
	}

	i.Version++
	return i, nil
}
1240025
func (p *MercatorProjection) Project(pt Point) r2.Point {
	return p.FromLatLng(LatLngFromPoint(pt))
}
347160
func (s *GetProjectOutput) SetProject(v *Project) *GetProjectOutput {
	s.Project = v
	return s
}
303084
func (c *FakeProjectRequests) Create(projectRequest *project.ProjectRequest) (result *project.Project, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewRootCreateAction(projectrequestsResource, projectRequest), &project.Project{})
	if obj == nil {
		return nil, err
	}
	return obj.(*project.Project), err
}
1154251
func ProjectStop(p project.APIProject, c *cli.Context) error {
	err := p.Stop(context.Background(), c.Int("timeout"), c.Args()...)
	if err != nil {
		return cli.NewExitError(err.Error(), 1)
	}
	return nil
}
1029993
func (p *ProjectFactory) Create(c *cli.Context) (project.APIProject, error) {
	context := &ctx.Context{}
	context.LoggerFactory = logger.NewColorLoggerFactory()
	Populate(context, c)
	return docker.NewProject(context, nil)
}
96647
func (c *Clientset) Myproject() myprojectv1alpha1.MyprojectV1alpha1Interface {
	return &fakemyprojectv1alpha1.FakeMyprojectV1alpha1{Fake: &c.Fake}
}
1233662
func NewProjectFromEnv() (*Project, error) {
	cli, err := client.NewEnvClient()
	if err != nil {
		return nil, err
	}
	ping := types.Ping{APIVersion: CurrentAPIVersion}
	cli.NegotiateAPIVersionPing(ping)
	return NewProject(cli), nil
}