CHECKSTYLE.ON: FinalClass
423397
@Override
    protected void collectMetrics(final Metrics metrics) {
        for (final Map.Entry<String, ExecutorService> entry : _executorServices.entrySet()) {
            final String name = entry.getKey();
            final ExecutorService executorService = entry.getValue();
            if (executorService instanceof ForkJoinPool) {
                processForkJoinPool(metrics, name, (ForkJoinPool) executorService);
            }
            if (executorService instanceof ThreadPoolExecutor) {
                // NOTE: That a ScheduledThreadPoolExecutor is a ThreadPoolExecutor
                processThreadPoolExecutor(metrics, name, (ThreadPoolExecutor) executorService);
            }
        }
    }
978144
private void finalization() {
        Map<String, Object> dataModel = newHashMap();
        dataModel.put("cppFormatter", new SourceFormatter());
        Set<ClassModel> dependencies = newHashSet();
        for (Java4CppType type : context.getClassesAlreadyDone()) {
            Class<?> clazz = type.getRawClass();
            if (isValid(clazz)) {
                dependencies.add(context.getClassModel(clazz));
            }
        }
        dataModel.put("classes", dependencies);
        dataModel.put("symbols", context.getFileManager().getSymbols().getSymbols());

        context.getTemplateManager().processGlobalTemplates(dataModel);

        context.getTemplateManager().copyFiles();
    }
871315
function hasClass(element, className) {
    !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSS.hasClass takes only a single class name.') : invariant(false) : void 0;
    if (element.classList) {
      return !!className && element.classList.contains(className);
    }
    return (' ' + element.className + ' ').indexOf(' ' + className + ' ') > -1;
  }
1167087
private static String getStyleClasses(AbstractNavLink link, boolean isResponsive) {
		StringBuilder sb;
		sb = new StringBuilder(20); // optimize int

		String look = null;
		if (link instanceof Link) {
			look = ((Link) link).getLook();
		} else if (link instanceof CommandLink) {
			look = ((CommandLink) link).getLook();
		}

		if (look != null) {
			sb.append("btn btn-").append(look);
			if (isResponsive) {
				sb.append(" btn-block");
			}
		}

		return sb.toString().trim();
	}
990211
function createFinalClass(params, constructor) {
        var def = Class.$create(params, constructor);
        def[$class].finalClass = true;

        return def;
    }
1146202
function checkIfStyleCanBeChildOf( def, currentParent, elementName, isUnknownElement ) {
		return currentParent &&
			( ( currentParent.getDtd() || CKEDITOR.dtd.span )[ elementName ] || isUnknownElement ) &&
			( !def.parentRule || def.parentRule( currentParent ) );
	}
203189
def _is_final(meta, arg):
        
        if inspect.isclass(arg) and not isinstance(arg, ObjectMetaclass):
            return False  # of classes, only subclasses of Object can be final

        # account for method wrappers, such as the one introduced by @override
        from taipan.objective.modifiers import _WrappedMethod
        if isinstance(arg, _WrappedMethod):
            arg = arg.method

        return getattr(arg, '__final__', False)
103159
private void analyseAdditionalStepImplementations(final Class<?> loadedClass, final Syntax syntax,
        final Class<?>[] additionalStepImplementationClasses) {
        for (final Class<?> stepImplClass : additionalStepImplementationClasses) {
            analyseClass(stepImplClass, syntax);
        }
    }
1241214
def get_final_attrs(self, classes=True):
        """"""
        final_attrs = copy.copy(self.get_default_attrs())
        final_attrs.update(self.attrs)
        if classes:
            final_attrs['class'] = self.get_final_css()
        else:
            final_attrs.pop('class', None)

        return final_attrs
887268
function checkClass(i) {
  let l;

  if (i >= tokensLength) return 0;

  if (tokens[i].class_l) return tokens[i].class_l;

  if (tokens[i++].type === TokenType.FullStop) {
    if (l = checkInterpolatedVariable(i)) tokens[i].class_child = 1;
    else if (l = checkIdent(i)) tokens[i].class_child = 2;
    else return 0;

    tokens[i].class_l = l + 1;
    return l + 1;
  }

  return 0;
}
266681
function checkMemberSeparatorStyle(node) {
            const isInterface = node.type === "TSInterfaceBody";
            const isSingleLine = node.loc.start.line === node.loc.end.line;

            const members = isInterface ? node.body : node.members;

            const typeOpts = isInterface
                ? interfaceOptions
                : typeLiteralOptions;
            const opts = isSingleLine
                ? typeOpts.singleline
                : typeOpts.multiline;

            members.forEach((member, index) => {
                checkLastToken(member, opts, index === members.length - 1);
            });
        }
811506
function checkClass(i) {
  const start = i;
  let l;

  if (i >= tokensLength) return 0;

  if (tokens[i].class_l) return tokens[i].class_l;

  // Skip `.`.
  if (tokens[i].type === TokenType.FullStop) i++;
  else return 0;

  if (l = checkIdentOrInterpolation(i)) i += l;
  else return 0;

  while (i < tokensLength) {
    if (l = checkIdentOrInterpolation(i)) {
      tokens[start].class_l = l + 1;
      i += l;
    } else break;
  }

  tokens[start].classEnd = i;

  return i - start;
}
1120108
function fixDefaultChecked( elem ) {
	if ( rcheckableType.test( elem.type ) ) {
		elem.defaultChecked = elem.checked;
	}
}
894917
def _pretty_access_flags_gen(self):
        

        if self.is_public():
            yield "public"
        if self.is_final():
            yield "final"
        if self.is_abstract():
            yield "abstract"
        if self.is_interface():
            if self.is_annotation():
                yield "@interface"
            else:
                yield "interface"
        if self.is_enum():
            yield "enum"
452446
def finalize(self):
        
        self.spinBox.valueChanged.disconnect(self.commitChangedValue)
        super(IntCtiEditor, self).finalize()
1158471
function checkStylesheet(i) {
  const start = i;
  let l;

  while (i < tokensLength) {
    if (l = checkSC(i)) tokens[i].stylesheet_child = 1;
    else if (l = checkRuleset(i)) tokens[i].stylesheet_child = 2;
    else if (l = checkAtrule(i)) tokens[i].stylesheet_child = 3;
    else if (l = checkDeclDelim(i)) tokens[i].stylesheet_child = 4;
    else throwError(i);

    i += l;
  }

  return i - start;
}
1301811
function checkIfClassHasReactRender(currentClass) {
  try {
    var getRenderMethod = currentClass.body.body.filter(function (id) {
      return id.type === 'ClassMethod' && id.key.name === 'render';
    });
    return getRenderMethod[0].body.body.filter(function (child) {
      return child.type === 'ReturnStatement';
    }).map(function (stat) {
      return stat.argument.type;
    })[0] === 'JSXElement';
  } catch (e) {
    return false;
  }
}