Returns the specified parameters for the given message based on the parser associated with the
first context found that includes the URL for the message, or the default parser if it is not
in a context
@param msg
@param type
@return
498145
public Map<String, String> getParams(HttpMessage msg, HtmlParameter.Type type) {
		switch (type) {
		case form:	return this.getFormParamParser(msg.getRequestHeader().getURI().toString()).getParams(msg, type);
		case url:	return this.getUrlParamParser(msg.getRequestHeader().getURI().toString()).getParams(msg, type);
		default:
					throw new InvalidParameterException("Type not supported: " + type);
		}
	}
979166
static MessageFiller parseMessageParameter(String wrappedParameter, String trimmedParameter) {
    if (trimmedParameter.equals(PARAMETER_MESSAGE)) {
      return new MessageFiller(wrappedParameter, trimmedParameter);
    }
    return null;
  }
602551
@SuppressWarnings("unchecked")
    public <E> MessageHandler<? super E> addSentMessageHandler(Class<E> type,
            MessageHandler<? super E> handler) {
        sentMessageHandlerCache.clear();
        return (MessageHandler<? super E>) sentMessageHandlers.put(type, handler);
    }
394096
function(msg) {
				msg.addOption(new Option(Message.Option.URI_PATH, new Buffer("c")));
				msg.addOption(new Option(Message.Option.URI_QUERY, encodedCrc));
				if (includeIndex) {
					var idxBin = messages.ToBinary(chunkIndex, "uint16");
					msg.addOption(new Option(Message.Option.URI_QUERY, idxBin));
				}
				return msg;
			}
103328
protected WsMessageRouterImpl getMessageRouter() {
        if (msgRouter == null) {
            // First activation.
            msgRouter = MessageRouterSingleton.singleton;

            // Pass the MessageRouter to the TrService via the TrConfigurator.
            TrConfigurator.setMessageRouter(msgRouter);

            // Register this guy as a BundleListener, looking for new Bundles as they
            // are added to the framework.  Then process the already-installed bundles. 
            // We are looking for any /META-INF/MessageRouter.properties files defined
            // in the bundles.  Note: it's possible (tho unlikely) that multiple threads
            // could be running this code at the same time.  This is not a problem.
            // The msgRouter will be informed of duplicate MessageRouter.properties
            // entries, but it can handle that. One thing to note, howerver, is that the 
            // natural ordering of Bundles may get messed up by the BundleListener. The 
            // BundleListener is registered before we process the initial bundle set 
            // (which we must do, otherwise we risk missing the arrival of a bundle between 
            // the time we're processing the initial set and the time we register the 
            // BundleListener). However, if the BundleListener receives a "bundle installed" 
            // event asynchronously while we're still processing the initial set, that newly 
            // installed bundle's MessageRouter properties may get overridden by a bundle 
            // from the initial set, which would violate the policy that the properties are 
            // applied in the order by which the bundles were started. So we're stuck between 
            // a rock and a hard place. Not sure what to do about that. 
            bundleContext.addBundleListener(this);
            processInitialBundles();
        }

        return msgRouter;
    }
209401
public Collection<Subscription> getSubscriptionsByMessageType(Class messageType) {
        Set<Subscription> subscriptions = new TreeSet<Subscription>(Subscription.SubscriptionByPriorityDesc);
        ReadLock readLock = readWriteLock.readLock();
        try {
            readLock.lock();

            Subscription subscription;
            ArrayList<Subscription> subsPerMessage = subscriptionsPerMessage.get(messageType);

            if (subsPerMessage != null) {
                subscriptions.addAll(subsPerMessage);
            }

            Class[] types = ReflectionUtils.getSuperTypes(messageType);
            for (int i=0, n=types.length; i<n; i++) {
                Class eventSuperType = types[i];
                
                ArrayList<Subscription> subs = subscriptionsPerMessage.get(eventSuperType);
                if (subs != null) {
                    for (int j = 0,m=subs.size(); j<m; j++) {
                        subscription = subs.get(j);

                        if (subscription.handlesMessageType(messageType)) {
                            subscriptions.add(subscription);
                        }
                    }
                }
            }
        }finally{
            readLock.unlock();
        }
        return subscriptions;
    }
356143
function getContextualTypeForArgument(callTarget, arg) {
            var args = getEffectiveCallArguments(callTarget);
            var argIndex = ts.indexOf(args, arg);
            if (argIndex >= 0) {
                var signature = getResolvedOrAnySignature(callTarget);
                return getTypeAtPosition(signature, argIndex);
            }
            return undefined;
        }
882748
private static List<TypeElement> fetchAllNestedTypes(MessageElement type) {
        List<TypeElement> ret = new ArrayList<TypeElement>();

        List<TypeElement> nestedTypes = type.nestedElements();
        ret.addAll(nestedTypes);
        for (TypeElement t : nestedTypes) {
            if (t instanceof MessageElement) {
                List<TypeElement> subNestedTypes = fetchAllNestedTypes((MessageElement) t);
                ret.addAll(subNestedTypes);
            }
        }
        return ret;
    }
300499
public static Type getTypeArgument(Type type) {
        if (!(type instanceof ParameterizedType)) {
            return null;
        }
        return ((ParameterizedType) type).getActualTypeArguments()[0];
    }
340030
public static List<GraphQLArgument> getGraphQLArgumentsForType(final Type type) {

		final List<GraphQLArgument> arguments = new LinkedList<>();

		switch (type) {

			case String:
				arguments.add(GraphQLArgument.newArgument().name("_equals").type(Scalars.GraphQLString).build());
				arguments.add(GraphQLArgument.newArgument().name("_contains").type(Scalars.GraphQLString).build());
				arguments.add(GraphQLArgument.newArgument().name("_conj").type(Scalars.GraphQLString).build());
				break;

			case Integer:
				arguments.add(GraphQLArgument.newArgument().name("_equals").type(Scalars.GraphQLInt).build());
				arguments.add(GraphQLArgument.newArgument().name("_conj").type(Scalars.GraphQLString).build());
				break;

			case Long:
				arguments.add(GraphQLArgument.newArgument().name("_equals").type(Scalars.GraphQLLong).build());
				arguments.add(GraphQLArgument.newArgument().name("_conj").type(Scalars.GraphQLString).build());
				break;
		}

		return arguments;
	}
556023
function messageHandler( msg ) {
  switch (msg.type) {
    case 'load'   : return handleLoadMsg(msg);
    case 'search' : return handleSearch(msg);
    case 'lookupById': return handleLookupById(msg);
    default       : logger.error('Unknown message:', msg);
  }
}
821828
public final TypeParser.typeParameterization_return typeParameterization() throws RecognitionException {
        TypeParser.typeParameterization_return retval = new TypeParser.typeParameterization_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token UNKNOWN8=null;
        Token UNKNOWN9=null;
        Token EXTENDS10=null;
        Token UNKNOWN11=null;
        Token SUPER12=null;
        TypeParser.typeExpression_return typExp = null;

        TypeParser.typeExpression_return typeExpression7 = null;


        CommonTree UNKNOWN8_tree=null;
        CommonTree UNKNOWN9_tree=null;
        CommonTree EXTENDS10_tree=null;
        CommonTree UNKNOWN11_tree=null;
        CommonTree SUPER12_tree=null;
        RewriteRuleTokenStream stream_SUPER=new RewriteRuleTokenStream(adaptor,"token SUPER");
        RewriteRuleTokenStream stream_UNKNOWN=new RewriteRuleTokenStream(adaptor,"token UNKNOWN");
        RewriteRuleTokenStream stream_EXTENDS=new RewriteRuleTokenStream(adaptor,"token EXTENDS");
        RewriteRuleSubtreeStream stream_typeExpression=new RewriteRuleSubtreeStream(adaptor,"rule typeExpression");
        try {
            // org/javaruntype/type/parser/Type.g:112:5: ( typeExpression | UNKNOWN | UNKNOWN EXTENDS typExp= typeExpression -> ^( EXT $typExp) | UNKNOWN SUPER typExp= typeExpression -> ^( SUP $typExp) )
            int alt5=4;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==CLASSNAME) ) {
                alt5=1;
            }
            else if ( (LA5_0==UNKNOWN) ) {
                switch ( input.LA(2) ) {
                case EXTENDS:
                    {
                    alt5=3;
                    }
                    break;
                case SUPER:
                    {
                    alt5=4;
                    }
                    break;
                case ENDTYPEPARAM:
                case COMMA:
                    {
                    alt5=2;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 5, 2, input);

                    throw nvae;
                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // org/javaruntype/type/parser/Type.g:112:7: typeExpression
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_typeExpression_in_typeParameterization291);
                    typeExpression7=typeExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, typeExpression7.getTree());

                    }
                    break;
                case 2 :
                    // org/javaruntype/type/parser/Type.g:113:7: UNKNOWN
                    {
                    root_0 = (CommonTree)adaptor.nil();

                    UNKNOWN8=(Token)match(input,UNKNOWN,FOLLOW_UNKNOWN_in_typeParameterization299); 
                    UNKNOWN8_tree = (CommonTree)adaptor.create(UNKNOWN8);
                    adaptor.addChild(root_0, UNKNOWN8_tree);


                    }
                    break;
                case 3 :
                    // org/javaruntype/type/parser/Type.g:114:7: UNKNOWN EXTENDS typExp= typeExpression
                    {
                    UNKNOWN9=(Token)match(input,UNKNOWN,FOLLOW_UNKNOWN_in_typeParameterization307);  
                    stream_UNKNOWN.add(UNKNOWN9);

                    EXTENDS10=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameterization309);  
                    stream_EXTENDS.add(EXTENDS10);

                    pushFollow(FOLLOW_typeExpression_in_typeParameterization313);
                    typExp=typeExpression();

                    state._fsp--;

                    stream_typeExpression.add(typExp.getTree());


                    // AST REWRITE
                    // elements: typExp
                    // token labels: 
                    // rule labels: retval, typExp
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_typExp=new RewriteRuleSubtreeStream(adaptor,"rule typExp",typExp!=null?typExp.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 114:45: -> ^( EXT $typExp)
                    {
                        // org/javaruntype/type/parser/Type.g:114:48: ^( EXT $typExp)
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(EXT, "EXT"), root_1);

                        adaptor.addChild(root_1, stream_typExp.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;
                case 4 :
                    // org/javaruntype/type/parser/Type.g:115:7: UNKNOWN SUPER typExp= typeExpression
                    {
                    UNKNOWN11=(Token)match(input,UNKNOWN,FOLLOW_UNKNOWN_in_typeParameterization330);  
                    stream_UNKNOWN.add(UNKNOWN11);

                    SUPER12=(Token)match(input,SUPER,FOLLOW_SUPER_in_typeParameterization332);  
                    stream_SUPER.add(SUPER12);

                    pushFollow(FOLLOW_typeExpression_in_typeParameterization336);
                    typExp=typeExpression();

                    state._fsp--;

                    stream_typeExpression.add(typExp.getTree());


                    // AST REWRITE
                    // elements: typExp
                    // token labels: 
                    // rule labels: retval, typExp
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
                    RewriteRuleSubtreeStream stream_typExp=new RewriteRuleSubtreeStream(adaptor,"rule typExp",typExp!=null?typExp.tree:null);

                    root_0 = (CommonTree)adaptor.nil();
                    // 115:43: -> ^( SUP $typExp)
                    {
                        // org/javaruntype/type/parser/Type.g:115:46: ^( SUP $typExp)
                        {
                        CommonTree root_1 = (CommonTree)adaptor.nil();
                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SUP, "SUP"), root_1);

                        adaptor.addChild(root_1, stream_typExp.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;
                    }
                    break;

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

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

        }

            catch (RecognitionException e) {
            	throw e;
            }
        finally {
        }
        return retval;
    }
1166924
public LoggingScope getNewLoggingScope(final String msg, final Object[] params) {
    return new LoggingScopeImpl(LOG, logLevel, msg, params);
  }
150196
public static <T> Class<FieldParser<T>> getParserForType(Class<T> type) {
		Class<? extends FieldParser<?>> parser = PARSERS.get(type);
		if (parser == null) {
			return null;
		} else {
			@SuppressWarnings("unchecked")
			Class<FieldParser<T>> typedParser = (Class<FieldParser<T>>) parser;
			return typedParser;
		}
	}
1276409
def _execFilters(self, type, msg):
        
        for filter in self.FILTERS:
            msg = filter(type, msg)
        return msg
1338153
public static function setTypeMsg($type, $msg=null)
    {
        if (is_array($type)) {
            self::$typeMsg=array_merge(self::$typeMsg, $type);
        } else {
            self::$typeMsg[$type]=$msg;
        }
    }
936024
function getContextuallyTypedParameterType(parameter) {
            var func = parameter.parent;
            if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
                var iife = ts.getImmediatelyInvokedFunctionExpression(func);
                if (iife) {
                    var indexOfParameter = ts.indexOf(func.parameters, parameter);
                    if (iife.arguments && indexOfParameter < iife.arguments.length) {
                        if (parameter.dotDotDotToken) {
                            var restTypes = [];
                            for (var i = indexOfParameter; i < iife.arguments.length; i++) {
                                restTypes.push(getTypeOfExpression(iife.arguments[i]));
                            }
                            return createArrayType(getUnionType(restTypes));
                        }
                        var links = getNodeLinks(iife);
                        var cached = links.resolvedSignature;
                        links.resolvedSignature = anySignature;
                        var type = checkExpression(iife.arguments[indexOfParameter]);
                        links.resolvedSignature = cached;
                        return type;
                    }
                }
                var contextualSignature = getContextualSignature(func);
                if (contextualSignature) {
                    var funcHasRestParameters = ts.hasRestParameter(func);
                    var len = func.parameters.length - (funcHasRestParameters ? 1 : 0);
                    var indexOfParameter = ts.indexOf(func.parameters, parameter);
                    if (indexOfParameter < len) {
                        return getTypeAtPosition(contextualSignature, indexOfParameter);
                    }
                    // If last parameter is contextually rest parameter get its type
                    if (funcHasRestParameters &&
                        indexOfParameter === (func.parameters.length - 1) &&
                        isRestParameterIndex(contextualSignature, func.parameters.length - 1)) {
                        return getTypeOfSymbol(ts.lastOrUndefined(contextualSignature.parameters));
                    }
                }
            }
            return undefined;
        }