Extract the mechanism necessary for this reaction.

@param entry  The EntryReact object
517768
private void extractMechanism(EntryReact entry) {
        String mechanismName = "org.openscience.cdk.reaction.mechanism." + entry.getMechanism();
        try {
            mechanism = (IReactionMechanism) this.getClass().getClassLoader().loadClass(mechanismName).newInstance();
            logger.info("Loaded mechanism: ", mechanismName);
        } catch (ClassNotFoundException exception) {
            logger.error("Could not find this IReactionMechanism: ", mechanismName);
            logger.debug(exception);
        } catch (InstantiationException | IllegalAccessException exception) {
            logger.error("Could not load this IReactionMechanism: ", mechanismName);
            logger.debug(exception);
        }
    }
426850
public final boolean remove(E entry) {
        TreeEntry<E> e = getEntry(entry);

        if (e == null) {
            return false;
        } else {
            deleteEntry(e);
        }

        return true;
    }
585841
private synchronized void makeOrphan(Entry<K, V> entry) {
    Preconditions.checkNotNull(entry);
    Preconditions.checkState(!entry.isOrphan);
    entry.isOrphan = true;
  }
1325379
@Override
	public void process(String xmlString, ITempelEntryProcessor entryProcessor) throws Exception {
		process(new ByteArrayInputStream(xmlString.getBytes()), entryProcessor);
	}
140888
private void fromEntryPoint(PatternDescrBuilder<?> pattern) throws RecognitionException {
        String ep = "";

        match(input,
                DRL6Lexer.ID,
                DroolsSoftKeywords.ENTRY,
                null,
                DroolsEditorType.KEYWORD);
        if (state.failed)
            return;

        match(input,
                DRL6Lexer.MINUS,
                null,
                null,
                DroolsEditorType.KEYWORD);
        if (state.failed)
            return;

        match(input,
                DRL6Lexer.ID,
                DroolsSoftKeywords.POINT,
                null,
                DroolsEditorType.KEYWORD);
        if (state.failed)
            return;

        ep = stringId();

        if (state.backtracking == 0) {
            pattern.from().entryPoint(ep);
            if (input.LA(1) != DRL6Lexer.EOF) {
                helper.emit(Location.LOCATION_LHS_BEGIN_OF_CONDITION);
            }
        }
    }
578375
public void remove(EventQueueEntry entry) {
		List<EventQueueEntry> container = queue.get(entry.getPriority());
		if (container == null) {
			return;
		}
		
		container.remove(entry);
		
		// TODO: can we remove an empty container safely?
	}
1018849
public final DSLMappingEntry entry() throws RecognitionException {
		entry_stack.push(new entry_scope());
		DSLMappingEntry mappingEntry = null;



		    entry_stack.peek().retval = new AntlrDSLMappingEntry() ;
		    entry_stack.peek().variables = new HashMap<String,Integer>();
		    entry_stack.peek().keybuffer = new StringBuilder();
		    entry_stack.peek().valuebuffer = new StringBuilder();
		    entry_stack.peek().sentenceKeyBuffer = new StringBuilder();
		    entry_stack.peek().sentenceValueBuffer = new StringBuilder();

		try {
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:51:5: ( ^( VT_ENTRY scope_section ( meta_section )? key_section ( value_section )? ) )
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:51:7: ^( VT_ENTRY scope_section ( meta_section )? key_section ( value_section )? )
			{
			match(input,VT_ENTRY,FOLLOW_VT_ENTRY_in_entry130); 
			match(input, Token.DOWN, null); 
			pushFollow(FOLLOW_scope_section_in_entry132);
			scope_section();
			state._fsp--;

			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:51:32: ( meta_section )?
			int alt2=2;
			int LA2_0 = input.LA(1);
			if ( (LA2_0==VT_META) ) {
				alt2=1;
			}
			switch (alt2) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:51:32: meta_section
					{
					pushFollow(FOLLOW_meta_section_in_entry134);
					meta_section();
					state._fsp--;

					}
					break;

			}

			pushFollow(FOLLOW_key_section_in_entry137);
			key_section();
			state._fsp--;

			    entry_stack.peek().retval.setVariables( entry_stack.peek().variables );
			                 entry_stack.peek().retval.setMappingKey(entry_stack.peek().sentenceKeyBuffer.toString());
			                 entry_stack.peek().retval.setKeyPattern(entry_stack.peek().keybuffer.toString());
			            
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:56:9: ( value_section )?
			int alt3=2;
			int LA3_0 = input.LA(1);
			if ( (LA3_0==VT_ENTRY_VAL) ) {
				alt3=1;
			}
			switch (alt3) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:56:9: value_section
					{
					pushFollow(FOLLOW_value_section_in_entry161);
					value_section();
					state._fsp--;

					}
					break;

			}

			match(input, Token.UP, null); 


			        entry_stack.peek().retval.setMappingValue(entry_stack.peek().sentenceValueBuffer.toString());
			        entry_stack.peek().retval.setValuePattern(entry_stack.peek().valuebuffer.toString());
			        mappingEntry = entry_stack.peek().retval;
			        mapping_file_stack.peek().retval.addEntry(mappingEntry);
			    
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			entry_stack.pop();
		}
		return mappingEntry;
	}
812079
@Override
    public boolean accept( final AuditLogEntry entry ) {
        if ( !acceptedTypes.containsKey( entry.getGenericType() ) ) {
            return false;
        }
        return acceptedTypes.get( entry.getGenericType() );
    }
575564
protected Object processEntry(BinaryEntry entry) {
        Binary binCurrent = entry.getBinaryValue();
        if (binCurrent == null && !fAllowInsert) {
            return fReturn ? null : NO_RESULT;
        }

        PofValue pvCurrent = getPofValue(binCurrent);
        PofValue pvNew = getPofValue("newValue");

        Integer versionCurrent = (Integer) get(pvCurrent);
        Integer versionNew = (Integer) get(pvNew);

        if (versionCurrent.equals(versionNew)) {
            set(pvNew, versionNew + 1);
            entry.updateBinaryValue(pvNew.applyChanges());
            return NO_RESULT;
        }

        return fReturn ? pvCurrent.getValue() : NO_RESULT;
    }
62767
private void initiateParameterMap2(EntryReact entry) {
        List<List<String>> paramDic = entry.getParameterClass();

        paramsMap2 = new ArrayList<IParameterReact>();
        for (Iterator<List<String>> it = paramDic.iterator(); it.hasNext();) {
            List<String> param = it.next();
            String paramName = "org.openscience.cdk.reaction.type.parameters." + param.get(0);
            try {
                IParameterReact ipc = (IParameterReact) this.getClass().getClassLoader().loadClass(paramName)
                        .newInstance();
                ipc.setParameter(Boolean.parseBoolean(param.get(1)));
                ipc.setValue(param.get(2));

                logger.info("Loaded parameter class: ", paramName);
                paramsMap2.add(ipc);
            } catch (ClassNotFoundException exception) {
                logger.error("Could not find this IParameterReact: ", paramName);
                logger.debug(exception);
            } catch (InstantiationException | IllegalAccessException exception) {
                logger.error("Could not load this IParameterReact: ", paramName);
                logger.debug(exception);
            }
        }
    }
1241111
private void registerEntry(String source,
                               String target,
                               String variant,
                               Object entry,
                               boolean visible) {
        String s = source;
        if (s.length() == 0) {
            s = ANY;
        }
        String ID = TransliteratorIDParser.STVtoID(source, target, variant);
        registerEntry(ID, s, target, variant, entry, visible);
    }
582134
final protected Entry<K, V> peekEntryInternal(K key) {
    int hc = modifiedHash(key.hashCode());
    return peekEntryInternal(key, hc, extractIntKeyValue(key, hc));
  }
135560
@Override
  final public TraceMethod entry(String returnType, Class clazz, String methodSignature) {
    return null;
  }
1255476
@Override
    public IReaction getReaction(int position) {

        if (!hashMapChain.containsValue(position)) return null;

        Set<Entry<IReaction, Integer>> entries = hashMapChain.entrySet();
        for (Iterator<Entry<IReaction, Integer>> it = entries.iterator(); it.hasNext();) {
            Entry<IReaction, Integer> entry = it.next();
            if (entry.getValue().equals(position)) return entry.getKey();
        }

        return null;
    }
163737
public static boolean executeDeleteOperation(final ConnectionFactory connectionFactory, final LdapEntry entry) {
        try (val connection = createConnection(connectionFactory)) {
            val delete = new DeleteOperation(connection);
            val request = new DeleteRequest(entry.getDn());
            request.setReferralHandler(new DeleteReferralHandler());
            val res = delete.execute(request);
            return res.getResultCode() == ResultCode.SUCCESS;
        } catch (final LdapException e) {
            LOGGER.error(e.getMessage(), e);
        }
        return false;
    }
483359
private TreeEntry<E> getEntry(Entry<?> entry) {
        TreeEntry<E> t = root;
        while (t != null) {
            int cmp = compareLongs(getLow(entry), t.low);
            if (cmp == 0)
                cmp = compareLongs(getHigh(entry), t.high);
            if (cmp == 0)
                cmp = entry.hashCode() - t.value.hashCode();

            if (cmp < 0) {
                t = t.left;
            } else if (cmp > 0) {
                t = t.right;
            } else {
                return t;
            }
        }

        return null;
    }
1067841
public synchronized void remove(Entry entry)
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "remove", new Object[] { entry });

    super.remove(entry);
    DestinationHandler dh = (DestinationHandler) entry.data;
    HashMap<String, Entry> busMap = getBusMap(dh.getBus());
    DestinationEntry destEntry = (DestinationEntry) busMap.get(dh.getName());
    if(destEntry == entry)
    {
      busMap.remove(dh.getName());
    }    
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "remove");
  }