// Returns the version number of the Qlik engine component.
182718
func (obj *Global) EngineVersionRaw(ctx context.Context) (json.RawMessage, error) {
	result := &struct {
		Version json.RawMessage	`json:"qVersion"`
	} {}
	err := obj.rpc(ctx, "EngineVersion", result)
	return result.Version, err 
}
373393
func (p *PKGBUILD) Version() string {
	if p.Epoch > 0 {
		return fmt.Sprintf("%d:%s-%s", p.Epoch, p.Pkgver, p.Pkgrel)
	}

	return fmt.Sprintf("%s-%s", p.Pkgver, p.Pkgrel)
}
1086334
func (ctx *HookContext) UnitWorkloadVersion() (string, error) {
	var results params.StringResults
	args := params.Entities{
		Entities: []params.Entity{{Tag: ctx.unit.Tag().String()}},
	}
	err := ctx.state.Facade().FacadeCall("WorkloadVersion", args, &results)
	if err != nil {
		return "", err
	}
	if len(results.Results) != 1 {
		return "", fmt.Errorf("expected 1 result, got %d", len(results.Results))
	}
	result := results.Results[0]
	if result.Error != nil {
		return "", result.Error
	}
	return result.Result, nil
}
10981
func (c *ClusterInfo) GetVersion(addr string) (semver.Version, error) {
	endpoint := fmt.Sprintf("http://%s/info", addr)
	var resp struct {
		Version string `json:"version"`
	}
	err := c.client.GETV1(endpoint, &resp)
	if err != nil {
		return semver.Version{}, err
	}
	if resp.Version == "" {
		resp.Version = "unknown"
	}
	return semver.Parse(resp.Version)
}
1185181
func (s *IdentityServer) Version(
	ctx context.Context,
	req *api.SdkIdentityVersionRequest,
) (*api.SdkIdentityVersionResponse, error) {

	var (
		version *api.StorageVersion
		err     error
	)
	if s.driver(ctx) == nil {
		version = &api.StorageVersion{
			Driver: "no driver running",
		}
	} else {
		version, err = s.driver(ctx).Version()
		if err != nil {
			return nil, status.Errorf(
				codes.Internal,
				"Failed to get version information: %v", err,
			)
		}
	}

	sdkVersion := &api.SdkVersion{
		Major: int32(api.SdkVersion_Major),
		Minor: int32(api.SdkVersion_Minor),
		Patch: int32(api.SdkVersion_Patch),
		Version: fmt.Sprintf("%d.%d.%d",
			api.SdkVersion_Major,
			api.SdkVersion_Minor,
			api.SdkVersion_Patch,
		),
	}

	return &api.SdkIdentityVersionResponse{
		SdkVersion: sdkVersion,
		Version:    version,
	}, nil
}
231450
func (driver *Driver) Version() (file.Version, error) {
	versions, err := driver.Versions()
	if len(versions) == 0 {
		return 0, err
	}
	return versions[0], err
}
797992
func Version(url string, kvdbOptions map[string]string) (string, error) {
	// Currently we support only v1
	return kvdb.ConsulVersion1, nil
}
170052
func findMetadataVersion(allMeta []*gui.Metadata, vers version.Number) (*gui.Metadata, error) {
	for _, metadata := range allMeta {
		if metadata.Version == vers {
			return metadata, nil
		}
	}
	return nil, errors.NotFoundf("Juju GUI release version %s", vers)
}
198976
func (c *Client) ElasticsearchVersion(url string) (string, error) {
	res, _, err := c.Ping().URL(url).Do()
	if err != nil {
		return "", err
	}
	return res.Version.Number, nil
}
575755
func (s *precheckShim) AgentVersion() (version.Number, error) {
	model, err := s.State.Model()
	if err != nil {
		return version.Zero, errors.Trace(err)
	}
	cfg, err := model.ModelConfig()
	if err != nil {
		return version.Zero, errors.Trace(err)
	}

	vers, ok := cfg.AgentVersion()
	if !ok {
		return version.Zero, errors.New("no model agent version")
	}
	return vers, nil
}
1134832
func GetHumanVersion() string {
	version := Version
	if GitDescribe != "" {
		version = GitDescribe
	}

	release := VersionPrerelease
	if GitDescribe == "" && release == "" {
		release = "dev"
	}

	if release != "" {
		if !strings.HasSuffix(version, "-"+release) {
			// if we tagged a prerelease version then the release is in the version already
			version += fmt.Sprintf("-%s", release)
		}
		if GitCommit != "" {
			version += fmt.Sprintf(" (%s)", GitCommit)
		}
	}

	// Strip off any single quotes added by the git information.
	return strings.Replace(version, "'", "", -1)
}
1078538
func Version() (int, int, int) {
	var c_major, c_minor, c_patch C.int
	C.rados_version(&c_major, &c_minor, &c_patch)
	return int(c_major), int(c_minor), int(c_patch)
}
109722
func Version() int {
	var v C.int
	if err := result(C.cuDriverGetVersion(&v)); err != nil {
		return -1
	}
	return int(v)
}
457751
func GetVersion(uuid []byte) Version {
	ver := uuid[6] >> 4
	if ver > 0 && ver < 6 {
		return Version(ver)
	}

	return VersionUnknown
}
1122887
func (md *RootMetadataV3) Version() MetadataVer {
	if md.TlfID().Type() != tlf.SingleTeam &&
		md.TypeForKeying() == tlf.TeamKeying {
		return ImplicitTeamsVer
	}
	return SegregatedKeyBundlesVer
}
783125
func GetVersion() (major, minor, micro int, err error) {
	out, err := exec.Command(iptablesPath, "--version").CombinedOutput()
	if err == nil {
		major, minor, micro = parseVersionNumbers(string(out))
	}
	return
}
1281026
func (sc *Client) Version(ctx context.Context) (string, error) {
	var result string
	err := sc.c.CallContext(ctx, &result, "shh_version")
	return result, err
}