<pre>
A single identity requesting access for a Cloud Platform resource.
Follows the same format of Binding.members.
Required
</pre>

<code>string member = 3;</code>
774182
public java.lang.String getMember() {
    java.lang.Object ref = member_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      member_ = s;
      return s;
    }
  }
1195512
public String getIdentity() {
    try {
        return BouncyCastleUtil.getIdentity(this.certChain);
    } catch (CertificateException e) {
            logger.debug("Error getting certificate identity.", e);
        return null;
    }
    }
926367
public AccountAcquisition getAccountAcquisition(final String accountCode) {
        final String path = Account.ACCOUNT_RESOURCE + "/" + accountCode + AccountAcquisition.ACCOUNT_ACQUISITION_RESOURCE;
        return doGET(path, AccountAcquisition.class);
    }
86300
public String getMemberId(String nodePath) {
    MorePreconditions.checkNotBlank(nodePath);
    if (!nodePath.startsWith(path + "/")) {
      throw new IllegalArgumentException(
          String.format("Not a member of this group[%s]: %s", path, nodePath));
    }

    String memberId = StringUtils.substringAfterLast(nodePath, "/");
    if (!nodeScheme.isMember(memberId)) {
      throw new IllegalArgumentException(
          String.format("Not a group member: %s", memberId));
    }

    return memberId;
  }
416512
public SpaceMember getSpaceMembership(int spaceId, int userId) {
		return getResourceFactory().getApiResource(
				"/space/" + spaceId + "/member/" + userId).get(
				SpaceMember.class);
	}
44606
@Override
    public Object getMember(String name) {
        switch (name) {
            case "user": return F_user;
            case "product": return F_product;
            case "rating": return F_rating;
        }
        return super.getMember(name);
    }
519307
@Override
    public String getIdentity() {
        return protocol + Constants.PROTOCOL_SEPARATOR + host + ":" + port +
                "/" + getParameter(URLParamType.group.getName(), URLParamType.group.getValue()) + "/" +
                getPath() + "/" + getParameter(URLParamType.version.getName(), URLParamType.version.getValue()) +
                "/" + getParameter(URLParamType.nodeType.getName(), URLParamType.nodeType.getValue());
    }
1348836
public static String getAccountId() throws IOException {
        // Get the MAC address of the machine.
        String macUrl = getMetadataUrl() + "/network/interfaces/macs/";
        String mac = invokeUrl(macUrl).trim();

        // Use the MAC address to obtain the owner-id or the
        // AWS AccountId.
        String idUrl = macUrl + mac + "owner-id";
        String acctId = invokeUrl(idUrl).trim();

        assert  acctId != null;
        return acctId;
    }
252875
@Override
    public Object getMember(String name) {
        switch (name) {
            case "BOOLEAN":
                return F_BOOLEAN;
//            case "BYTE":
//                return F_BYTE;
//            case "SHORT":
//                return F_SHORT;
            case "INT":
                return F_INT;
//            case "LONG":
//                return F_LONG;
            case "FLOAT":
               // return F_FLOAT;
            case "DOUBLE":
                return F_DOUBLE;
            case "STRING":
                return F_STRING;
//            case "DECIMAL":
//                return F_DECIMAL;
            case "DATE":
                return F_DATE;
            case "TIMESTAMP":
                return F_TIMESTAMP;
//            case "BINARY":
//                return F_BINARY;
            case "tuple2":
                return F_tuple2;
            case "tuple3":
                return F_tuple3;
            case "tuple4":
                return F_tuple4;
            case "tuple5":
                return F_tuple5;

        }
        return super.getMember(name);
    }
1074699
@Override
    public Object getMember(String name) {
        switch (name) {
            case "wrapRDD": return F_wrapRDD;
            case "cache": return F_cache;
            case "persist": return F_persist;
            case "unpersist": return F_unpersist;
            case "distinct": return F_distinct;
            case "filter": return F_filter;
            case "coalesce": return F_coalesce;
            case "repartition": return F_repartition;
            case "subtract": return F_subtract;
            case "sample": return F_sample;
            case "union": return F_union;
            case "intersection": return F_intersection;
            case "sum": return F_sum;
            case "min": return F_min;
            case "max": return F_max;
            case "stats": return F_stats;
            case "mean": return F_mean;
            case "variance": return F_variance;
            case "stdev": return F_stdev;
            case "sampleStdev": return F_sampleStdev;
            case "sampleVariance": return F_sampleVariance;
            case "meanApprox": return F_meanApprox;
            case "sumApprox": return F_sumApprox;
            case "histogram": return F_histogram;
            case "setName": return F_setName;


        }
        return super.getMember(name);
    }
704521
AsteriskQueueMemberImpl getMember(String location)
    {
        synchronized (members)
        {
            if (members.containsKey(location))
            {
                return members.get(location);
            }
        }
        return null;
    }
974509
@Override
	public Certificate[] engineGetCertificateChain(String s) {
		CredentialWrapper credential = getKeyEntry(s);
		X509Certificate[] chain = new X509Certificate[0];
		if (credential != null) {
			try {
				chain = credential.getCredential().getCertificateChain();
			} catch (ResourceStoreException e) {
				logger.warn(e.getMessage(), e);
				chain = null;
			}
		}
		return chain;
	}
1040940
def getMember(self, address, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member/"+address
        return self.client.get(uri, None, headers, query_params, content_type)
188157
@Override
    public IAuthorizationPrincipal newPrincipal(IGroupMember groupMember) throws GroupsException {
        String key = groupMember.getKey();
        Class type = groupMember.getType();

        logger.debug("AuthorizationImpl.newPrincipal(): for {} ({})", type, key);

        return newPrincipal(key, type);
    }
519755
public String getRelyingPartyIdentifier(final Service service, final WsFederationConfiguration configuration) {
        val relyingPartyIdentifier = configuration.getRelyingPartyIdentifier();
        if (service != null) {
            val registeredService = this.servicesManager.findServiceBy(service);
            RegisteredServiceAccessStrategyUtils.ensureServiceAccessIsAllowed(service, registeredService);
            if (RegisteredServiceProperty.RegisteredServiceProperties.WSFED_RELYING_PARTY_ID.isAssignedTo(registeredService)) {
                LOGGER.debug("Determined relying party identifier from service [{}] to be [{}]", service, relyingPartyIdentifier);
                return RegisteredServiceProperty.RegisteredServiceProperties.WSFED_RELYING_PARTY_ID.getPropertyValue(registeredService).getValue();
            }
        }
        LOGGER.debug("Determined relying party identifier to be [{}]", relyingPartyIdentifier);
        return relyingPartyIdentifier;
    }
1270718
public static String accessToken(String key) {
		if (isKeyParam(key)) {
			String[] keys = key.split(KEY_JOIN);
			if (keys.length == 2) {
				return apiHandler.accessToken(keys[0], keys[1]);
			} else if (keys.length == 1) {
				return apiHandler.accessToken(keys[0]);
			}
		}
		return key;
	}
300537
public Identity getIdentity()
    {
        if(identity == null)
        {
            identity = tx.getBroker().serviceIdentity().buildIdentity(obj);
        }
        return identity;
    }