Add a java:module binding to the map.
Lock not required since the the map is unique to one module.

@param mmd module meta data
@param name lookup name
@param bindingObject
165213
public void addModuleBinding(ModuleMetaData mmd, String name, EJBBinding bindingObject) {
        JavaColonNamespaceBindings<EJBBinding> bindingMap = getModuleBindingMap(mmd);
        bindingMap.bind(name, bindingObject);
    }
737788
@SuppressWarnings("unchecked")
    protected void bindManyToOne(Association property, ManyToOne manyToOne,
                                 String path, InFlightMetadataCollector mappings, String sessionFactoryBeanName) {

        NamingStrategy namingStrategy = getNamingStrategy(sessionFactoryBeanName);

        bindManyToOneValues(property, manyToOne);
        PersistentEntity refDomainClass = property instanceof ManyToMany ? property.getOwner() : property.getAssociatedEntity();
        Mapping mapping = getMapping(refDomainClass);
        boolean isComposite = hasCompositeIdentifier(mapping);
        if (isComposite) {
            CompositeIdentity ci = (CompositeIdentity) mapping.getIdentity();
            bindCompositeIdentifierToManyToOne(property, manyToOne, ci, refDomainClass, path, sessionFactoryBeanName);
        }
        else {
            if (property.isCircular() && (property instanceof ManyToMany)) {
                PropertyConfig pc = getPropertyConfig(property);

                if (pc.getColumns().isEmpty()) {
                    mapping.getColumns().put(property.getName(), pc);
                }
                if (!hasJoinKeyMapping(pc) ) {
                    JoinTable jt = new JoinTable();
                    final ColumnConfig columnConfig = new ColumnConfig();
                    columnConfig.setName(namingStrategy.propertyToColumnName(property.getName()) +
                            UNDERSCORE + FOREIGN_KEY_SUFFIX);
                    jt.setKey(columnConfig);
                    pc.setJoinTable(jt);
                }
                bindSimpleValue(property, manyToOne, path, pc, sessionFactoryBeanName);
            }
            else {
                // bind column
                bindSimpleValue(property, null, manyToOne, path, mappings, sessionFactoryBeanName);
            }
        }

        PropertyConfig config = getPropertyConfig(property);
        if ((property instanceof org.grails.datastore.mapping.model.types.OneToOne) && !isComposite) {
            manyToOne.setAlternateUniqueKey(true);
            Column c = getColumnForSimpleValue(manyToOne);
            if (config != null && !config.isUniqueWithinGroup()) {
                c.setUnique(config.isUnique());
            }
            else if (property.isBidirectional() && isHasOne(property.getInverseSide())) {
                c.setUnique(true);
            }
        }
    }
1281459
private Object processJavaColonApp(String lookupName) throws NamingException {

        ComponentMetaData cmd = getComponentMetaData(JavaColonNamespace.APP, lookupName);
        ModuleMetaData mmd = cmd.getModuleMetaData();
        ApplicationMetaData amd = mmd.getApplicationMetaData();

        Lock readLock = javaColonLock.readLock();
        readLock.lock();

        EJBBinding binding = null;
        try {
            JavaColonNamespaceBindings<EJBBinding> appMap = getAppBindingMap(amd);
            if (appMap != null) {
                binding = appMap.lookup(lookupName);
            }
        } finally {
            readLock.unlock();
        }

        return processJavaColon(binding, JavaColonNamespace.APP, lookupName);
    }
821016
@Override
    public final void setObjectProperty(String name, Object value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setObjectProperty", new Object[] { name, value });

        /* If the property is either JMSXUserID or JMSXAppID, we set it into the */
        /* message regardless of whether it is null. We know the value is a */
        /* String as the JMS API layer has vetted it. Moved code under d325186.1 */
        if (SIProperties.JMSXAppID.equals(name)) {
            setJmsxAppId((String) value);
        }
        else if (SIProperties.JMSXUserID.equals(name)) {
            setUserid((String) value);
        }
        /* Ditto for JMS_IBM_ArmCorrelator & JMS_TOG_ARM_Correlator */
        else if (SIProperties.JMS_IBM_ArmCorrelator.equals(name)) {
            setARMCorrelator((String) value);
        }
        else if (SIProperties.JMS_TOG_ARM_Correlator.equals(name)) {
            setARMCorrelator((String) value);
        }

        /* else, if the value is not null, set the Property */
        else if (value != null) {
            setNonNullProperty(name, value);
        }

        /* Otherwise, remove it */
        else {

            /* Maelstrom's transportVersion has its own field - the rest are in the */
            /* JmsPropertyMap */
            if (!name.startsWith(JMS_PREFIX)) {
                if (name.equals(MfpConstants.PRP_TRANSVER)) {
                    clearTransportVersion();
                }
                else {
                    if (mayHaveJmsUserProperties()) {
                        getJmsUserPropertyMap().remove(name);
                    }
                }
            }
            else {
                if (name.startsWith(JMS_IBM_MQMD_PREFIX)) {
                    deleteMQMDProperty(name);
                }
                else {
                    if (mayHaveMappedJmsSystemProperties()) {
                        getJmsSystemPropertyMap().remove(name); // 234893
                    }
                    // JMS_IBM_Character_Set and JMS_IBM_Encoding need to be cleared in the
                    // message itself too.                                          d395685
                    if (name.equals(SIProperties.JMS_IBM_Character_Set)) {
                        setCcsid(null);
                    }
                    else if (name.equals(SIProperties.JMS_IBM_Encoding)) {
                        setEncoding(null);
                    }
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setObjectProperty");
    }
318394
public void addObjectReferenceDescriptor(ObjectReferenceDescriptor ord)
    {
        m_ObjectReferenceDescriptors.add(ord);
        ord.setClassDescriptor(this); // BRJ

        m_objectReferenceDescriptorsNameMap = null;
    }
676299
public LWMConfig getMQLink(String name) {

        String thisMethodName = "getMQLink";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, name);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName, null);
        }

        return null;
    }
423112
@Override
	public void bind(Name name, Object obj) throws NamingException
    {
        if (name.isEmpty())
            throw new InvalidNameException("Cannot bind empty name");

        // Extract components that belong to this namespace
        String nm = name.toString();

        // Find object in internal hash table
        if (bindings.get(nm) != null)
        {
            throw new NameAlreadyBoundException("Use rebind to override");
        }

        // Add object to internal hash table
        bindings.put(nm, obj);
    }
221019
void bindInjectedObject() throws InjectionException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "bindInjectedObject: " + toSimpleString(), bindingObjectToString(ivBindingObject));

        // d660700 - resolveJndiName will set a scope if the JNDI name starts
        // with "java:", including "java:comp/".  However, JNDI names starting
        // with "java:comp/env/" will not have a scope because that prefix is
        // removed by setJndiName.
        InternalInjectionEngine ie = InjectionEngineAccessor.getInternalInstance();
        ie.bindJavaNameSpaceObject(ivNameSpaceConfig, ivInjectionScope, ivJavaNameSpaceName, this, ivBindingObject);

        // Store this binding object in the caller's map, if provided.  d473811
        if (ivJavaColonCompEnvMap != null &&
            ivInjectionScope == null)
        {
            ivJavaColonCompEnvMap.put(ivJndiName, this);
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "bindInjectedObject");
    }
33377
protected Binding bindAnnotatedWithNameToInstance(TypeReference bind, String name, String to,
			String functionName) {
		String tmpName = Strings.emptyIfNull(name);
		if (tmpName.startsWith(REFERENCE_PREFIX)) {
			tmpName = tmpName.substring(REFERENCE_PREFIX.length()).trim();
		} else {
			tmpName = "\"" + tmpName + "\""; //$NON-NLS-1$//$NON-NLS-2$
		}
		final String unferencedName = tmpName;
		final StringConcatenationClient client = new StringConcatenationClient() {
			@Override
			protected void appendTo(TargetStringConcatenation builder) {
				builder.append("binder.bind("); //$NON-NLS-1$
				builder.append(bind);
				builder.append(".class).annotatedWith(Names.named("); //$NON-NLS-1$
				builder.append(unferencedName);
				builder.append(")).toInstance("); //$NON-NLS-1$
				builder.append(to);
				builder.append(".class);"); //$NON-NLS-1$
			}
		};
		String fctname = functionName;
		if (Strings.isEmpty(fctname)) {
			fctname = name;
		}
		final BindKey key = new GuiceModuleAccess.BindKey(formatFunctionName(fctname), null, false, false);
		final BindValue statements = new BindValue(null, null, false, Collections.singletonList(client));
	    return new Binding(key, statements, true, this.name);
	}
622035
function addPropertyToModelMeta(modelName, property, meta) {
    if (!exports.propertiesByModel[modelName]) {
        exports.propertiesByModel[modelName] = {};
    }
    // TODO: investigate why we need to genericize to model (from <T>)
    exports.propertiesByModel[modelName][property] = meta;
}
1033040
@Override
	public void bind(ServiceBindingDescriptor bindingDescriptor) {
        String servicePlusMajorVersion=bindingDescriptor.getServiceName() +
                "-v" + bindingDescriptor.getServiceVersion().getMajor();

        if (serviceBindingDescriptors.containsKey(servicePlusMajorVersion)) {
                throw new PanicInTheCougar("More than one version of service [" + bindingDescriptor.getServiceName() +
                        "] is attempting to be bound for the same major version. The clashing versions are [" +
                        serviceBindingDescriptors.get(servicePlusMajorVersion).getServiceVersion() + ", " +
                        bindingDescriptor.getServiceVersion() +
                        "] - only one instance of a service is permissable for each major version");
        }
		serviceBindingDescriptors.put(servicePlusMajorVersion, bindingDescriptor);
	}
865706
public void stoppingModule(EJBModuleMetaDataImpl mmd) { // F743-26072
        boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "stoppingModule: " + mmd.getJ2EEName());

        // If the application is stopping (rather than a single module), then
        // we don't need to do anything special.
        if (!ivStopping) {
            mmd.ivStopping = true;
            ivModules.remove(mmd);

            try {
                beginStopping(false, mmd.getJ2EEName(), Collections.singletonList(mmd));
            } finally {
                // If fine-grained module start failed, be sure to clear
                // internal state.
                ivSingletonDependencies = null;
                ivStartupSingletonList = null;
                ivQueuedNonPersistentTimers = null;
            }
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "stoppingModule");
    }
859975
@Override
    public void bindJavaGlobal(String name, EJBBinding bindingObject) {
        String bindingName = buildJavaGlobalName(name);
        ejbJavaColonHelper.addGlobalBinding(bindingName, bindingObject);
    }
468519
Object lookup(String key) throws ObjectNameNotFoundException
    {
        Object result = null;
        NamedEntry entry = localLookup(key);
        // can't find local bound object
        if(entry == null)
        {
            try
            {
                PersistenceBroker broker = tx.getBroker();
                // build Identity to lookup entry
                Identity oid = broker.serviceIdentity().buildIdentity(NamedEntry.class, key);
                entry = (NamedEntry) broker.getObjectByIdentity(oid);
            }
            catch(Exception e)
            {
                log.error("Can't materialize bound object for key '" + key + "'", e);
            }
        }
        if(entry == null)
        {
            log.info("No object found for key '" + key + "'");
        }
        else
        {
            Object obj = entry.getObject();
            // found a persistent capable object associated with that key
            if(obj instanceof Identity)
            {
                Identity objectIdentity = (Identity) obj;
                result = tx.getBroker().getObjectByIdentity(objectIdentity);
                // lock the persistance capable object
                RuntimeObject rt = new RuntimeObject(result, objectIdentity, tx, false);
                tx.lockAndRegister(rt, Transaction.READ, tx.getRegistrationList());
            }
            else
            {
                // nothing else to do
                result = obj;
            }
        }
        if(result == null) throw new ObjectNameNotFoundException("Can't find named object for name '" + key + "'");
        return result;
    }
662822
@Override
    public void bindJavaModule(String name, EJBBinding bindingObject) {
        ejbJavaColonHelper.addModuleBinding(moduleMetaData, name, bindingObject);
    }
843203
public void binding(Map map)
	{
		Map<String, Object> values = map;
		if(values==null) return ;
		for (Entry<String,Object> entry : values.entrySet())
		{
			this.binding(entry.getKey(), entry.getValue());
		}
		
	}
364626
public synchronized void addGlobalBinding(String name, EJBBinding bindingObject) {
        Lock writeLock = javaColonLock.writeLock();
        writeLock.lock();

        try {
            javaColonGlobalBindings.bind(name, bindingObject);
        } finally {
            writeLock.unlock();
        }
    }