<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>
511849
public com.google.protobuf.ByteString
      getMemberBytes() {
    java.lang.Object ref = member_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      member_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
676601
String composeMembershipId(Node groupNode, Node refUserNode, Node refTypeNode) throws RepositoryException
   {
      return groupNode.getUUID()
         + ','
         + refUserNode.getName()
         + ','
         + (refTypeNode.getName().equals(JCROrganizationServiceImpl.JOS_MEMBERSHIP_TYPE_ANY)
            ? MembershipTypeHandler.ANY_MEMBERSHIP_TYPE : refTypeNode.getName());
   }
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);
    }
349302
@Override
    public JsonEntityBean getEntity(IGroupMember member) {

        // get the type of this member entity
        EntityEnum entityEnum = getEntityType(member);

        // construct a new entity bean for this entity
        JsonEntityBean entity;
        if (entityEnum.isGroup()) {
            entity = new JsonEntityBean((IEntityGroup) member, entityEnum);
        } else {
            entity = new JsonEntityBean(member, entityEnum);
        }

        // if the name hasn't been set yet, look up the entity name
        if (entity.getName() == null) {
            entity.setName(lookupEntityName(entity));
        }

        if (EntityEnum.GROUP.equals(entity.getEntityType())
                || EntityEnum.PERSON.equals(entity.getEntityType())) {
            IAuthorizationPrincipal principal = getPrincipalForEntity(entity);
            entity.setPrincipalString(principal.getPrincipalString());
        }
        return entity;
    }
349665
public String register(RegistrationRequest req, Member registrar) throws RegistrationException {
    	if (StringUtil.isNullOrEmpty(req.getEnrollmentID())) {
    		throw new IllegalArgumentException("EntrollmentID cannot be null or empty");
    	}

    	if (registrar == null) {
    		throw new IllegalArgumentException("Registrar should be a valid member");
    	}


    	Registrar reg = Registrar.newBuilder()
    			.setId(
    					Identity.newBuilder()
    					.setId(registrar.getName())
    					.build())
    			.build(); //TODO: set Roles and Delegate Roles

    	RegisterUserReq.Builder regReqBuilder = RegisterUserReq.newBuilder();
    	regReqBuilder.setId(
    					Identity.newBuilder()
    					.setId(req.getEnrollmentID())
    					.build());
    	regReqBuilder.setRoleValue(rolesToMask(req.getRoles()));
    	regReqBuilder.setAffiliation(req.getAffiliation());
    	regReqBuilder.setRegistrar(reg);

    	RegisterUserReq registerReq = regReqBuilder.build();
    	byte[] buffer = registerReq.toByteArray();

    	try {
            java.security.PrivateKey signKey = cryptoPrimitives.ecdsaKeyFromPrivate(Hex.decode(registrar.getEnrollment().getKey()));
	    	logger.debug("Retreived private key");
            BigInteger[] signature = cryptoPrimitives.ecdsaSign(signKey, buffer);
	    	logger.debug("Signed the request with key");
            Signature sig = Signature.newBuilder().setType(CryptoType.ECDSA).setR(ByteString.copyFrom(signature[0].toString().getBytes())).setS(ByteString.copyFrom(signature[1].toString().getBytes())).build();
			regReqBuilder.setSig(sig);
	    	logger.debug("Now sendingt register request");
			Token token = this.ecaaClient.registerUser(regReqBuilder.build());
			return token.getTok().toStringUtf8();

		} catch (Exception e) {
			throw new RegistrationException("Error while registering the user", e);
		}

    }
848900
@Override
    public Object getMember(String name) {
        switch (name) {
            case "description":
                return F_description;
            case "offsetDesc":
                return F_offsetDesc;
        }
        return super.getMember(name);
    }
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;
    }
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);
    }
372107
@Override
    public Object getMember(String name) {
        switch (name) {
            case "schema":
                return F_schema;
            case "clsTag":
                return F_clsTag;
        }
        return super.getMember(name);
    }
166925
def get_member_ibutton(self, val):
        
        members = self.__con__.search_s(
            CSHMember.__ldap_user_ou__,
            ldap.SCOPE_SUBTREE,
            "(ibutton=%s)" % val,
            ['ipaUniqueID'])
        if members:
            return CSHMember(
                    self,
                    members[0][1]['ipaUniqueID'][0].decode('utf-8'),
                    False)
        return None
989809
protected Member getMember(PageContext pc, Collection.Key key, boolean dataMember, boolean superAccess) {
	// check super
	if (dataMember && key.equalsIgnoreCase(KeyConstants._super) && isPrivate(pc)) {
	    Component ac = ComponentUtil.getActiveComponent(pc, this);
	    return SuperComponent.superMember((ComponentImpl) ac.getBaseComponent());
	}
	if (superAccess) return _udfs.get(key);

	// check data
	Member member = _data.get(key);
	if (isAccessible(pc, member)) return member;
	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;
	}
995002
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return MemberInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            queue_sid=self._solution['queue_sid'],
            call_sid=self._solution['call_sid'],
        )
992181
private URI getHasMemberFromPatch(final HttpServletRequest request) throws IOException {
        final String sparqlString = IOUtils.toString(request.getInputStream(), UTF_8);
        final String baseURI = request.getRequestURL().toString().replace(request.getContextPath(), "").replaceAll(
                request.getPathInfo(), "").replaceAll("rest$", "");
        final UpdateRequest sparqlUpdate = UpdateFactory.create(sparqlString);
        // The INSERT|DELETE DATA quads
        final Stream<Quad> insertDeleteData = sparqlUpdate.getOperations().stream()
                .filter(update -> update instanceof UpdateData)
                .map(update -> (UpdateData) update)
                .flatMap(update -> update.getQuads().stream());
        // Get the UpdateModify instance to re-use below.
        final List<UpdateModify> updateModifyStream = sparqlUpdate.getOperations().stream()
                .filter(update -> (update instanceof UpdateModify))
                .peek(update -> log.debug("Inspecting update statement for DELETE clause: {}", update.toString()))
                .map(update -> (UpdateModify) update)
                .collect(toList());
        // The INSERT {} WHERE {} quads
        final Stream<Quad> insertQuadData = updateModifyStream.stream()
                .flatMap(update -> update.getInsertQuads().stream());
        // The DELETE {} WHERE {} quads
        final Stream<Quad> deleteQuadData = updateModifyStream.stream()
                .flatMap(update -> update.getDeleteQuads().stream());
        // The ldp:membershipResource triples.
        return Stream.concat(Stream.concat(insertDeleteData, insertQuadData), deleteQuadData)
                .filter(update -> update.getPredicate().equals(MEMBERSHIP_RESOURCE.asNode()) && update.getObject()
                        .isURI())
                .map(update -> update.getObject().getURI())
                .map(update -> update.replace("file:///", baseURI))
                .findFirst().map(URI::create).orElse(null);
    }
300537
public Identity getIdentity()
    {
        if(identity == null)
        {
            identity = tx.getBroker().serviceIdentity().buildIdentity(obj);
        }
        return identity;
    }
245191
@Override
    public Object getMember(String name) {
        switch (name) {
            case "_1": return F_1;
            case "_2": return F_2;
            case "_3": return F_3;
            case "_4": return F_4;
            case "_5": return F_5;
        }
        return super.getMember(name);
    }
704521
AsteriskQueueMemberImpl getMember(String location)
    {
        synchronized (members)
        {
            if (members.containsKey(location))
            {
                return members.get(location);
            }
        }
        return null;
    }