167937 - added entire method
428541
public boolean isBmtActive(EJBMethodInfoImpl methodInfo)
    {
        TranStrategy ts = txStrategies[methodInfo.getTransactionAttribute().getValue()];
        return ts.isBmtActive();
    }
1331629
public AnnotatedTypeBuilder<X> addToMethod(AnnotatedMethod<? super X> method, Annotation annotation) {
       return addToMethod(method.getJavaMember(), annotation);
   }
637469
protected synchronized void add(Object id, int bufferType, int cause, int source, boolean fromDepIdTemplateInvalidation, boolean fireEvent,
            boolean isAlias) {
        final String methodName = "add(Object)";
        if (id == null) {
            return;
        }
        if (bufferType == EXPLICIT_BUFFER) {
            byte info = 0;
            if (cause != 0 && source != 0) {
                info = (byte) cause;
                if (source == CachePerf.REMOTE) {
                    info = (byte) (info | STATUS_REMOTE);
                }
                if (fromDepIdTemplateInvalidation) {
                    info = (byte) (info | STATUS_FROM_DEPID_TEMPLATE);
                }
                if (isAlias) {
                    info = (byte) (info | STATUS_ALIAS);
                }
                if (fireEvent) {
                    info = (byte) (info | STATUS_FIRE_EVENT);
                }
            }
            this.explicitBuffer.put(id, new Byte(info));
            this.scanBuffer.remove(id);
        } else if (bufferType == SCAN_BUFFER) {
            if (!this.explicitBuffer.containsKey(id)) {
                this.scanBuffer.add(id);
            }
        } else if (bufferType == GC_BUFFER) {
            this.garbageCollectorBuffer.add(id);
        }

        traceDebug(methodName, "cacheName=" + this.cod.cacheName + " id=" + id + " bufferType=" + bufferType + " ExplicitBuffer="
                + this.explicitBuffer.size() + " ScanBuffer=" + this.scanBuffer.size() + " GCBuffer=" + this.garbageCollectorBuffer.size()
                + " cause=" + cause + " source=" + source + " fireEvent=" + fireEvent);

        if (isFull() || bufferType == GC_BUFFER) { // 3821 NK end
            invokeBackgroundInvalidation(!SCAN);
        }
    }
1087195
@Override public Object invokeMethod(final String name, final Object arguments) {
    if (GantState.dryRun) {
      if (GantState.verbosity > GantState.SILENT) {
        final StringBuilder sb = new StringBuilder();
        int padding = 9 - name.length();
        if (padding < 0) { padding = 0; }
        sb.append("         ".substring(0, padding) + '[' + name + "] ");
        final Object[] args = (Object[]) arguments;
        if (args[0] instanceof Map<?,?>) {
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Eclipse and IntelliJ IDEA warn that (Map) is not a proper cast but using the
          // cast (Map<?,?>) causes a type check error due to the capture algorithm.
          //
          //  TODO : Fix this rather than use a SuppressWarnings.
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          @SuppressWarnings({ "unchecked", "rawtypes" } ) final Iterator<Map.Entry<?,?>> i =((Map) args[0]).entrySet().iterator();
          while (i.hasNext()) {
            final Map.Entry<?,?> e = i.next();
            sb.append(e.getKey() + " : '" + e.getValue() + '\'');
            if (i.hasNext()) { sb.append(", "); }
          }
          sb.append('\n');
          getProject().log(sb.toString());
          if (args.length == 2) {((Closure<?>) args[1]).call(); }
        }
        else if (args[0] instanceof Closure) { ((Closure<?>) args[0]).call(); }
        else { throw new RuntimeException("Unexpected type of parameter to method " + name); }
      }
      return null;
    }
    return super.invokeMethod(name, arguments);
  }
1117928
def method_missing(symbol, *args)
      self.class.new(@components.map { |enum|enum.send(symbol, *args) })
    end
653995
public static void addGeneratedMethod(ClassNode cNode, MethodNode mNode) {
        cNode.addMethod(mNode);
        markAsGenerated(cNode, mNode);
    }
924451
@Override
    public void add(int arg0, Object arg1) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "add", new Object[] { Integer.valueOf(arg0), arg1 });

        synchronized (getMessageLockArtefact()) {
            super.add(arg0, arg1);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.exit(this, tc, "add");
    }
331966
@Override
    public void setMethod(byte[] method) throws UnsupportedMethodException {
        MethodValues val = MethodValues.match(method, 0, method.length);
        if (null == val) {
            throw new UnsupportedMethodException("Illegal method " + GenericUtils.getEnglishString(method));
        }
        setMethod(val);
    }
973575
function addMethod (char, method) {
  var keyIsBound = hasKeybinding(char);
  var listener = keyupHandler.bind(null, char, method);

  bindings[char] = bindings[char] || {methods: [], listeners: []};

  if (keyIsBound) window.removeEventListener('keyup', bindings[char].listeners[0]);

  bindings[char].methods.unshift(method);
  bindings[char].listeners.unshift(listener);
  window.addEventListener('keyup', listener);
}
1323562
public void add(ManagedObject managedObject,
                    boolean requiresCurrentCheckpoint)
                    throws ObjectManagerException
    {
        final String methodName = "add";
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this,
                        cclass,
                        methodName,
                        new Object[] { managedObject, new Boolean(requiresCurrentCheckpoint) });

        super.add(managedObject, requiresCurrentCheckpoint);

        inMemoryManagedObjects.put(new Long(managedObject.owningToken.storedObjectIdentifier),
                                   managedObject);

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this,
                       cclass,
                       methodName);
    }
1069719
private void addMethodDefTriples(URIReference objURI,
                                     DOReader reader,
                                     Set<Triple> set)
            throws ResourceIndexException {
        try {
            for (MethodDef element : getAbstractMethods(reader)) {
                add(objURI, MODEL.DEFINES_METHOD, element.methodName, set);
            }
        } catch (ResourceIndexException e) {
            throw e;
        } catch (Exception e) {
            throw new ResourceIndexException("Error adding method def "
                    + "triples", e);
        }
    }
1083835
private void requirePkInitialized(CodeBuilder b, String methodName) {
        // Add code to call method which we are about to define.
        b.loadThis();
        b.invokeVirtual(methodName, null, null);

        // Now define new method, discarding original builder object.
        b = new CodeBuilder(mClassFile.addMethod(Modifiers.PROTECTED, methodName, null, null));
        b.loadThis();
        b.invokeVirtual(IS_REQUIRED_PK_INITIALIZED_METHOD_NAME, TypeDesc.BOOLEAN, null);
        Label pkInitialized = b.createLabel();
        b.ifZeroComparisonBranch(pkInitialized, "!=");
        CodeBuilderUtil.throwException
            (b, IllegalStateException.class, "Primary key not fully specified");
        pkInitialized.setLocation();
        b.returnVoid();
    }
793028
def method_added(meth_name)
      @deferred ||= {}
      unless @deferred.empty?
        @deferred.each do |k, v|
          case k
          when :before, :after, :around
            define_condition meth_name, k, v
          when :contract
            define_contract meth_name, v
          end
        end
        @deferred.clear
      end
    end
219971
@Override
  public <V> MethodVault<V> newMethod(Class<?> type, 
                                      String methodName,
                                      Class<?> []paramTypes)
  {
    Objects.requireNonNull(type);
    
    MethodVault<V> method = newMethodRec(type, methodName, paramTypes);

    if (method != null) {
      return method;
    }
    
    throw new IllegalStateException(L.l("Unknown method {0}.{1} {2}",
                                        type.getSimpleName(),
                                        methodName,
                                        Arrays.asList(paramTypes)));
  }
278325
function addMethod(name, method) {
        if (method !== undefined) {
            methods[name] = method;
        }
        return methods[name];
    }
370528
public void addMethod(final String resource, final ResourceMethod method) {
        resources.putIfAbsent(resource, new HashSet<>());
        resources.get(resource).add(method);
    }
1271153
private void _addActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__addActionPerformed
        JFileChooser fc = new JFileChooser();
        fc.setMultiSelectionEnabled(true);
        fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
        fc.setFileFilter(new FileFilter() {

            @Override
            public boolean accept(File f) {
                return f.isDirectory() || f.getName().endsWith(".R") || f.getName().endsWith(".Rdata");
            }

            @Override
            public String getDescription() {
                return "R object file";
            }
        });
        if (fc.showOpenDialog(this) == JFileChooser.APPROVE_OPTION && fc.getSelectedFiles() != null) {
            File[] files = fc.getSelectedFiles();
            for (File file : files) {
                if (file.getName().endsWith(".R")) {
                    if (R != null) {
                        R.source(file);
                    }
                } else if (file.getName().endsWith(".Rdata")) {
                    if (R != null) {
                        R.load(file);
                    }
                } else {
                    Log.Out.println("Not loading/sourcing " + file.getName());
                }
            }
        }
        update();
    }