{@inheritDoc}

@see org.modeshape.sequencer.ddl.StandardDdlParser#consumeIdentifier(org.modeshape.sequencer.ddl.DdlTokenStream)
965944
@Override
    protected String consumeIdentifier( DdlTokenStream tokens ) throws ParsingException {
        Position startPosition = tokens.nextPosition();
        String id = super.consumeIdentifier(tokens);
        if (!tokens.hasNext()) return id;
        Position nextPosition = tokens.nextPosition();

        while (((nextPosition.getIndexInContent() - startPosition.getIndexInContent() - id.length()) == 0)) {
            // allowed symbols in an identifier: underscore, dollar sign, pound sign, at sign
            if (tokens.matches(DdlTokenizer.SYMBOL)) {
                if (tokens.matches('$') || tokens.matches('#') || tokens.matches('@')) {
                    id += tokens.consume(); // consume symbol
                } else {
                    break; // not a valid ID symbol
                }
            } else {
                id += tokens.consume(); // consume text
            }

            nextPosition = tokens.nextPosition();
        }

        return id;
    }
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;
    }
48753
public static base_responses update(nitro_service client, streamidentifier resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			streamidentifier updateresources[] = new streamidentifier[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new streamidentifier();
				updateresources[i].name = resources[i].name;
				updateresources[i].selectorname = resources[i].selectorname;
				updateresources[i].interval = resources[i].interval;
				updateresources[i].samplecount = resources[i].samplecount;
				updateresources[i].sort = resources[i].sort;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1016088
@Override
	public String getIdentifier() {
		if (ranges.isEmpty()) return pdbId;
		return pdbId + "." + ResidueRange.toString(ranges);
	}
289557
def consume(self):
        '''
        
        '''
        generic_consume = getattr(self, 'generic_consume', None)
        
        for instr in disassembler(self.code):
            method_name = 'consume_%s' % (instr.opname)
            method = getattr(self, method_name, generic_consume)
            if not method:
                raise AttributeError("class %r has no method %r" % (type(self).__name__, method_name))
            
            self.instruction_pre(instr)
            method(instr)
            self.instruction_post(instr)
949877
private static Node checkUserIdentifier(final HttpServletRequest request,
			final ReadResponse response) {
		final String userId = request
				.getParameter(ProtocolConstants.Parameters.Read.USER_IDENTIFIER);
		if (userId != null) {
			final Node user = NeoUtils.getUserByIdentifier(userId);
			if (user != null) {
				return user;
			}
			response.userIdentifierInvalid(userId);
		} else {
			response.userIdentifierMissing();
		}

		return null;
	}
1178008
protected final Object getIdentifier(Object value, SessionFactoryImplementor sessionFactory) throws HibernateException {
		if ( value == null ) {
			return null;
		}

		final EntityPersister persister = sessionFactory.getMetamodel().entityPersister( delegate.getAssociatedEntityName() );
		final String uniqueKeyPropertyName = delegate.getRHSUniqueKeyPropertyName();

		if ( StringHelper.isEmpty( uniqueKeyPropertyName ) ) {
			return persister.getIdentifier( value, null );
		}
		else {
			Object propertyValue = persister.getPropertyValue( value, uniqueKeyPropertyName );
			// We now have the value of the property-ref we reference.  However,
			// we need to dig a little deeper, as that property might also be
			// an entity type, in which case we need to resolve its identifier
			Type type = persister.getPropertyType( uniqueKeyPropertyName );
			GridType gridType = typeTranslator.getType( type );
			if ( gridType.isEntityType() ) {
				propertyValue = getIdentifier( propertyValue, sessionFactory );
			}

			return propertyValue;
		}
	}
1259322
@Override
  protected String consumeDecimal() {

    StringBuilder builder = null;
    boolean noSign = false;
    boolean noExponent = false;
    boolean noDot = false;
    boolean done = false;
    char c = 0;
    hasNext();
    while (true) {
      int start = this.offset;
      while (this.offset < this.limit) {
        c = this.buffer[this.offset];
        if ((c == '+') || (c == '-')) {
          if (noSign) {
            done = true;
            break;
          } else {
            noSign = true;
          }
        } else if (c == 'e') {
          if (noExponent) {
            done = true;
            break;
          } else {
            noExponent = true;
            noSign = false;
            noDot = true;
          }
        } else if (c == '.') {
          if (noDot) {
            done = true;
            break;
          } else {
            noDot = true;
          }
        } else if ((c >= '0') && (c <= '9')) {
          noSign = true;
        } else {
          done = true;
          break;
        }
        this.offset++;
      }
      if (done) {
        return getAppended(builder, start, this.offset);
      }
      int len = this.offset - start;
      if (len > 0) {
        builder = append(builder, start, this.offset);
      }
      if (done || !fill()) {
        if (builder == null) {
          throw new IllegalStateException("Invalid character for decimal number: " + c);
        }
        return builder.toString();
      }
    }
  }
235961
public void consumeUntilGreedy(Parser recognizer, IntervalSet follow, CSSLexerState.RecoveryMode mode, CSSLexerState ls) {
        consumeUntil(recognizer, follow, mode, ls);
        recognizer.getInputStream().consume();
    }
1083125
public static base_responses add(nitro_service client, streamidentifier resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			streamidentifier addresources[] = new streamidentifier[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new streamidentifier();
				addresources[i].name = resources[i].name;
				addresources[i].selectorname = resources[i].selectorname;
				addresources[i].interval = resources[i].interval;
				addresources[i].samplecount = resources[i].samplecount;
				addresources[i].sort = resources[i].sort;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
1288570
@Override
    public boolean registerConsumerSetMonitor(
                                              SIDestinationAddress destinationAddress,
                                              String discriminatorExpression,
                                              ConsumerSetChangeCallback callback)
                    throws SIResourceException,
                    SINotPossibleInCurrentConfigurationException,
                    SIConnectionUnavailableException,
                    SIConnectionDroppedException,
                    SIIncorrectCallException,
                    SICommandInvocationFailedException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "registerConsumerSetMonitor",
                        new Object[] { destinationAddress,
                                      discriminatorExpression,
                                      callback });

        // Check that a listener has been specified
        if (callback == null)
        {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "registerConsumerSetMonitor", "SIIncorrectCallException");
            // Parameter is null, throw an excepiton
            throw new SIIncorrectCallException(nls.getFormattedMessage("NULL_CONSUMERSETCHANGECALLBACK_CWSIP0667", null, null));
        } else if (destinationAddress == null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "registerConsumerSetMonitor", "SIIncorrectCallException");
            // Parameter is null, throw an excepiton
            throw new SIIncorrectCallException(nls.getFormattedMessage("NULL_DESTINATIONADDRESS_CWSIP0668", null, null));

        } else if (discriminatorExpression == null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "registerConsumerSetMonitor", "SIIncorrectCallException");
            // Parameter is null, throw an excepiton
            throw new SIIncorrectCallException(nls.getFormattedMessage("NULL_DISCRIMINATOREXPRESSION_CWSIP0669", null, null));

        }
        boolean areConsumers = false;
        try
        {
            DestinationHandler topicSpace =
                            _destinationManager.getDestination((JsDestinationAddress) destinationAddress, false);

            areConsumers =
                            _messageProcessor.
                                            getMessageProcessorMatching().
                                            registerConsumerSetMonitor(topicSpace,
                                                                       discriminatorExpression,
                                                                       this,
                                                                       callback);
        } catch (Exception e)
        {
            // FFDC
            FFDCFilter
                            .processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.ConnectionImpl.registerConsumerSetMonitor",
                                              "1:7378:1.347.1.25",
                                              this);

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                SibTr.exception(tc, e);

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "registerConsumerSetMonitor", "SIErrorException");
            //SIErrorException is RuntimeExcetion hence catching this exception in StaticCATConnection
            throw new SIErrorException(e);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "registerConsumerSetMonitor", Boolean.valueOf(areConsumers));
        return areConsumers;
    }
1340290
public synchronized ProviderLoader getLoaderForIdent(final ProviderIdent ident) throws ProviderLoaderException {
        final cacheItem cacheItem = cache.get(ident);
        if (null == cacheItem) {
            return rescanForItem(ident);
        }

        final File file = cacheItem.getFirst();
        if (cacheItem.getSecond().isExpired(ident, file)) {
            remove(ident);
            return rescanForItem(ident);
        } else {
            return loadFileProvider(cacheItem);
        }
    }
624747
public void setConsumerDispatcher(ConsumerDispatcher consumerDispatcher)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setConsumerDispatcher", consumerDispatcher);

        this.consumerDispatcher = consumerDispatcher;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "setConsumerDispatcher");
    }
1066462
@Override
    public long dispose(long channelIdentifier) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "dispose", Long.valueOf(channelIdentifier));
        }
        long rc = 0L;
        synchronized (oneAtATime) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "have lock");
            }

            if (aioInitialized == AIO_INITIALIZED) {

                try {
                    rc = aio_dispose(channelIdentifier);
                } catch (AsyncException ae) {
                    // just log any errors
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "Error disposing channel: " + channelIdentifier + ", error: " + ae.getMessage());
                    }
                } catch (Throwable t) {
                    if (aioInitialized != AIO_SHUTDOWN) {
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "caught throwable:" + t);
                        }
                        throw new RuntimeException("Throwable caught from aio dll: aio_dispose: " + t.getMessage());
                    }
                }
            }
        } // end-sync
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "dispose");
        }
        return rc;
    }
926678
@Override
    public DigestCalculator get(final AlgorithmIdentifier algorithmIdentifier) throws OperatorCreationException
    {
        final Digest digest = getFactory(algorithmIdentifier.getAlgorithm()).getInstance();

        if (digest instanceof DigestCalculator) {
            return (DigestCalculator) digest;
        } else {
            return new DigestCalculator()
            {
                @Override
                public AlgorithmIdentifier getAlgorithmIdentifier()
                {
                    return algorithmIdentifier;
                }

                @Override
                public OutputStream getOutputStream()
                {
                    return digest.getOutputStream();
                }

                @Override
                public byte[] getDigest()
                {
                    return digest.digest();
                }
            };
        }
    }
91032
public final hqlParser.identifier_return identifier() throws RecognitionException {
		hqlParser.identifier_return retval = new hqlParser.identifier_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token IDENT305=null;

		CommonTree IDENT305_tree=null;

		try {
			// hql.g:720:2: ( IDENT )
			// hql.g:720:4: IDENT
			{
			root_0 = (CommonTree)adaptor.nil();


			IDENT305=(Token)match(input,IDENT,FOLLOW_IDENT_in_identifier3634);
			IDENT305_tree = (CommonTree)adaptor.create(IDENT305);
			adaptor.addChild(root_0, IDENT305_tree);

			}

			retval.stop = input.LT(-1);

			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException ex) {

					//retval.Tree = HandleIdentifierError(input.LT(1),ex);
			                retval.tree = HandleIdentifierError(input.LT(1),ex);

		}

		finally {
			// do for sure before leaving
		}
		return retval;
	}
871515
public void setIdentifier(String identifier) {
        assertNotNull(identifier);
        this.identifier = identifier;
        setLength(identifier.length());
    }