// Returns a map of all SNative contracts defined indexed by name
504022
func SNativeContracts() map[string]*SNativeContractDescription {
	contracts := []*SNativeContractDescription{
		NewSNativeContract(`
		* Interface for managing Secure Native authorizations.
		* @dev This interface describes the functions exposed by the SNative permissions layer in burrow.
		`,
			"Permissions",
			&SNativeFunctionDescription{Comment: `
			* @notice Adds a role to an account
			* @param Account account address
			* @param Role role name
			* @return result whether role was added
			`,
				Name:      "addRole",
				PermFlag:  permission.AddRole,
				Arguments: reflect.TypeOf(addRoleArgs{}),
				Returns:   reflect.TypeOf(addRoleRets{}),
				F:         addRole},

			&SNativeFunctionDescription{Comment: `
			* @notice Removes a role from an account
			* @param Account account address
			* @param Role role name
			* @return result whether role was removed
			`,
				Name:      "removeRole",
				PermFlag:  permission.RemoveRole,
				Arguments: reflect.TypeOf(removeRoleArgs{}),
				Returns:   reflect.TypeOf(removeRoleRets{}),
				F:         removeRole},

			&SNativeFunctionDescription{Comment: `
			* @notice Indicates whether an account has a role
			* @param Account account address
			* @param Role role name
			* @return result whether account has role
			`,
				Name:      "hasRole",
				PermFlag:  permission.HasRole,
				Arguments: reflect.TypeOf(hasRoleArgs{}),
				Returns:   reflect.TypeOf(hasRoleRets{}),
				F:         hasRole},

			&SNativeFunctionDescription{Comment: `
			* @notice Sets the permission flags for an account. Makes them explicitly set (on or off).
			* @param Account account address
			* @param Permission the base permissions flags to set for the account
			* @param Set whether to set or unset the permissions flags at the account level
			* @return The permission flag that was set as uint64
			`,
				Name:      "setBase",
				PermFlag:  permission.SetBase,
				Arguments: reflect.TypeOf(setBaseArgs{}),
				Returns:   reflect.TypeOf(setBaseRets{}),
				F:         setBase},

			&SNativeFunctionDescription{Comment: `
			* @notice Unsets the permissions flags for an account. Causes permissions being unset to fall through to global permissions.
      		* @param Account account address
      		* @param Permission the permissions flags to unset for the account
			* @return The permission flag that was unset as uint64
      `,
				Name:      "unsetBase",
				PermFlag:  permission.UnsetBase,
				Arguments: reflect.TypeOf(unsetBaseArgs{}),
				Returns:   reflect.TypeOf(unsetBaseRets{}),
				F:         unsetBase},

			&SNativeFunctionDescription{Comment: `
			* @notice Indicates whether an account has a subset of permissions set
			* @param Account account address
			* @param Permission the permissions flags (mask) to check whether enabled against base permissions for the account
			* @return result whether account has the passed permissions flags set
			`,
				Name:      "hasBase",
				PermFlag:  permission.HasBase,
				Arguments: reflect.TypeOf(hasBaseArgs{}),
				Returns:   reflect.TypeOf(hasBaseRets{}),
				F:         hasBase},

			&SNativeFunctionDescription{Comment: `
			* @notice Sets the global (default) permissions flags for the entire chain
			* @param Permission the permissions flags to set
			* @param Set whether to set (or unset) the permissions flags
			* @return The permission flag that was set as uint64
			`,
				Name:      "setGlobal",
				PermFlag:  permission.SetGlobal,
				Arguments: reflect.TypeOf(setGlobalArgs{}),
				Returns:   reflect.TypeOf(setGlobalRets{}),
				F:         setGlobal},
		),
	}

	contractMap := make(map[string]*SNativeContractDescription, len(contracts))
	for _, contract := range contracts {
		if _, ok := contractMap[contract.Name]; ok {
			// If this happens we have a pseudo compile time error that will be caught
			// on native.go init()
			panic(fmt.Errorf("duplicate contract with name %s defined. "+
				"Contract names must be unique", contract.Name))
		}
		contractMap[contract.Name] = contract
	}
	return contractMap
}
1257101
func (p *propRegion) GetRegionNameServers() []string {
	if p.Region == nil {
		return []string{}
	}

	return p.Region.GetNameServers()
}
807280
func indexNamespaceByRequester(obj interface{}) ([]string, error) {
	requester := obj.(*corev1.Namespace).Annotations[projectapi.ProjectRequester]
	return []string{requester}, nil
}
776658
func (c *Client) GetIDNameMap(id string) (map[string]string, error) {
	uri := fmt.Sprintf("%s/code-lists/%s/codes", c.url, id)
	resp, err := c.cli.Get(context.Background(), uri)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
		err = &ErrInvalidCodelistAPIResponse{http.StatusOK, resp.StatusCode, uri}
		return nil, err
	}

	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var vals DimensionValues
	if err = json.Unmarshal(b, &vals); err != nil {
		return nil, err
	}

	idNames := make(map[string]string)
	for _, val := range vals.Items {
		idNames[val.ID] = val.Label
	}

	return idNames, nil
}
1303504
func (c *ShardedClient) GetMulti(keys []string) map[string]GetResponse {
	return c.getMulti(c.manager.GetShardsForKeys(keys))
}
365848
func (t Term) GetAllByIndex(index interface{}, keys ...interface{}) Term {
	return constructMethodTerm(t, "GetAll", p.Term_GET_ALL, keys, map[string]interface{}{"index": index})
}
630594
func (h Home) CacheIndex(name string) string {
	target := fmt.Sprintf("%s-index.yaml", name)
	return h.Path("repository", "cache", target)
}
419014
func (v *Service) GetAnnotations() (o map[string]string) {
	if v != nil && v.Annotations != nil {
		return v.Annotations
	}

	return
}
864459
func (q *lockBasedQueryExecutor) GetStateMultipleKeys(namespace string, keys []string) ([][]byte, error) {
	return q.helper.getStateMultipleKeys(namespace, keys)
}
536523
func (r *RedisStore) GetMaps(keys []string) (map[string]map[string]interface{}, error) {
	commands, err := r.Pipeline(func(r *RedisStore) error {
		for _, key := range keys {
			r.client.HGetAll(key)
		}
		return nil

	})
	if err != nil {
		return nil, err
	}

	newValues := make(map[string]map[string]interface{}, len(keys))

	for i, key := range keys {
		cmd := commands[i]
		values, _ := cmd.(*redis.StringStringMapCmd).Result()
		if values != nil {
			valueMap := make(map[string]interface{}, len(values))
			for k, v := range values {
				valueMap[k] = v
			}

			newValues[key] = valueMap
		} else {
			newValues[key] = nil
		}
	}

	return newValues, nil
}
190444
func (obj *Doc) GetAllInfos(ctx context.Context) ([]*NxInfo, error) {
	result := &struct {
		Infos []*NxInfo	`json:"qInfos"`
	} {}
	err := obj.rpc(ctx, "GetAllInfos", result)
	return result.Infos, err 
}
286479
func (p *KeyValueServiceClient) GetAll(keys []string) (r []string, err error) {
	if err = p.sendGetAll(keys); err != nil {
		return
	}
	return p.recvGetAll()
}
13604
func (ch *CredHub) GetAllVersions(name string) ([]credentials.Credential, error) {
	query := url.Values{}
	query.Set("name", name)

	return ch.makeMultiCredentialGetRequest(query)
}
1220034
func GetTagMappings(cfg interface{}) (Mappings, error) {
	return getTagMappingsRecursive("", reflect.Indirect(reflect.ValueOf(cfg)))
}
345158
func (contract *SNativeContractDescription) FunctionByName(name string) (*SNativeFunctionDescription, error) {
	for _, f := range contract.functions {
		if f.Name == name {
			return f, nil
		}
	}
	return nil, fmt.Errorf("unknown SNative function with name %s", name)
}
166170
func (rh *HashMap) All() ([]string, error) {
	conn := rh.pool.Get(rh.dbindex)
	result, err := redis.Values(conn.Do("KEYS", rh.id+":*"))
	strs := make([]string, len(result))
	idlen := len(rh.id)
	for i := 0; i < len(result); i++ {
		strs[i] = getString(result, i)[idlen+1:]
	}
	return strs, err
}
268504
func (api *TenantsAPI) GetAll() (result *Tenants, err error) {
	uri := api.client.Endpoint + tenantUrl
	res, err := api.client.restClient.GetList(api.client.Endpoint, uri, api.client.options.TokenOptions)
	if err != nil {
		return
	}

	result = &Tenants{}
	err = json.Unmarshal(res, result)
	return
}