Intentionally not documented.
507408
function (className, functionName, message) {
            var msg = this.messageTable[message] ? this.messageTable[message] : message;

            return className + "." + functionName + ": " + msg;
        }
46012
public Map<String, Exception> unexportAllAndReportMissing()
    {
        Map<String, Exception> errors = new HashMap<>();

        synchronized(exportedObjects) {
            List<ObjectName> toRemove = new ArrayList<>(exportedObjects.size());
            for (ObjectName objectName : exportedObjects.keySet()) {
                try {
                    server.unregisterMBean(objectName);
                    toRemove.add(objectName);
                }
                catch(InstanceNotFoundException e) {
                    // ignore ... mbean has already been unregistered elsewhere
                    toRemove.add(objectName);
                }
                catch (MBeanRegistrationException e) {
                    //noinspection ThrowableResultOfMethodCallIgnored
                    errors.put(objectName.toString(), e);
                }
            }

            exportedObjects.keySet().removeAll(toRemove);
        }

        return errors;
    }
988491
def has_documented_fields(self, include_inherited_fields=False):
        """"""
        fields = self.all_fields if include_inherited_fields else self.fields
        for field in fields:
            if field.doc:
                return True
        return False
1164161
def not_implemented(self, func_name):
        '''
        
        '''
        msg = '%s is not overridden by %s' % (func_name, type(self).__name__)
        self.logger.error(msg)
        raise NotImplementedError(msg)
718888
def is_marked?(id, ignore_errors = false)
      (blob = find_blob(id)) && blob.is_marked?(id, ignore_errors)
    end
345517
def _ReportSameIdButNotMerged(self, entity_id, reason):
    
    self.feed_merger.problem_reporter.SameIdButNotMerged(self,
                                                         entity_id,
                                                         reason)
749718
function isHidden(option) {
  return option.hidden === true ||
         (option.value != null && option.value.hidden);
}
540227
function(t, explicit, notUsingValid) {
        if(explicit === undefined) {
            explicit = true;
        }
        return new Fact(t.predicate.toString(), t.subject.toString(), t.object.toString()/*.format()*/, [], explicit, [], [], notUsingValid, t.toString())
    }
1210615
function NotAppropriate(message, code_id) {
    Error.call(this);
    this.message = message || "not appropriate";
    this.code_id = code_id || null;
    this.statusCode = 403;
}
1111491
def p_not_expression(tok):
        """"""
        if len(tok) == 3:
            tok[0] = UnaryOperationRule(tok[1], tok[2])
        else:
            tok[0] = tok[1]
163753
private static boolean illegalSchemasFound(Collection<File> schemaFiles) {
    for (final File f : schemaFiles) {
      final Path parent = Paths.get(f.getParent()).toAbsolutePath();
      List<File> matches = FluentIterable.from(schemaFiles).filter(new Predicate<File>() {
        @Override public boolean apply(@Nullable File file) {
          return file != null && file != f && Paths.get(file.getParent()).startsWith(parent);
        }
      }).toList();

      if (!matches.isEmpty()) {
        return true;
      }
    }
    return false;
  }
709531
def undocumented(scope = :modified)
      return [] unless scope != :ignore && File.exist?(undocumented_path)
      @undocumented = { modified: [], all: [] } if @undocumented.nil?
      load_undocumented(scope) if @undocumented[scope].empty?
      @undocumented[scope]
    end
561207
def _node_not_implemented(node_name, cls):
    

    def f(self, *args, **kwargs):
        raise NotImplementedError("{name!r} nodes are not "
                                  "implemented".format(name=node_name))
    return f
47653
def _traverse_unobserved(stream,negative_filter,of):
  """"""
  observed = set()
  for line in stream:
    name = PacBioReadName(_nameprog.match(line).group(1))
    if name.get_molecule() not in negative_filter: of.write(line)
    observed.add(name.get_molecule())
  return negative_filter|observed
980159
function notGetOrPost(tuple) {
        var v = tuple[0].toLowerCase()
        if (v === 'get') return false
        if (v === 'post') return false
        if (v === 'put') return false
        if (v === 'patch') return false
        if (v === 'delete') return false
        return true
      }
529058
def not_files(self):
        """"""

        _args = []

        for arg in self.all:
            if not len(expand_path(arg)):
                if not os.path.exists(arg):
                    _args.append(arg)

        return Args(_args, no_argv=True)
1247430
def unallocated():
    
    app = AppAggregate()
    app.logger = logger
    unalloc = app.find_unallocated_holdings()

    if not unalloc:
        print(f"No unallocated holdings.")

    for item in unalloc:
        print(item)