fly/flightgear
1
0
Fork 0
Code Activity
flightgear/.clang-format
Edward d'Auvergne 930fb214b1 Clang-format: Added a configuration file for FlightGear code formatting. 
This .clang-format file is configured to both match the "average flightgear
coding style", defined as the minimal diff when formatting all sources and
headers, while also largely preserving meticulously formatted code present in
the repository.
2018-04-11 11:52:09 +02:00

1826 lines
55 KiB
YAML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Clang-format configuration file for FlightGear.
#
# The settings below were chosen based largely on two criteria:
#
# 1) The "average flightgear coding style", defined as producing a minimal diff
# in the flightgear repository when running the following commands:
#
# $ find src/ -type f \( -iname *.c -o -iname *.cxx -o -iname *.h \
# -o -iname *.hxx \) -exec clang-format -i {} \;
# $ git diff --shortstat
#
# 2) The preservation of meticulously formatted code found in many files.
#
# This file should be considered as a style-guide for new code.
#
# The comments before each option are reStructuredText formatted text converted
# from the https://clang.llvm.org/docs/ClangFormatStyleOptions.html web page.
---
# **Language** (``LanguageKind``)
# Language, this format style is targeted at.
#
# Possible values:
#
# * ``LK_None`` (in configuration: ``None``) Do not use.
# * ``LK_Cpp`` (in configuration: ``Cpp``) Should be used for C, C++.
# * ``LK_Java`` (in configuration: ``Java``) Should be used for Java.
# * ``LK_JavaScript`` (in configuration: ``JavaScript``) Should be used for JavaScript.
# * ``LK_ObjC`` (in configuration: ``ObjC``) Should be used for Objective-C, Objective-C++.
# * ``LK_Proto`` (in configuration: ``Proto``) Should be used for Protocol Buffers (https://developers.google.com/protocol-buffers/).
# * ``LK_TableGen`` (in configuration: ``TableGen``) Should be used for TableGen code.
# * ``LK_TextProto`` (in configuration: ``TextProto``) Should be used for Protocol Buffer messages in text format (https://developers.google.com/protocol-buffers/).
Language: Cpp
# **BasedOnStyle** (``string``)
# The style used for all options not specifically set in the configuration.
#
# This option is supported only in the **clang-format** configuration (both within ``-style='{...}'`` and the ``.clang-format`` file).
#
# Possible values:
#
# * ``LLVM`` A style complying with the `LLVM coding standards`_
# * ``Google`` A style complying with `Google's C++ style guide`_
# * ``Chromium`` A style complying with `Chromium's style guide`_
# * ``Mozilla`` A style complying with `Mozilla's style guide`_
# * ``WebKit`` A style complying with `WebKit's style guide`_
#
#
# .. _LLVM coding standards: http://llvm.org/docs/CodingStandards.html
# .. _Google's C++ style guide: http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
# .. _Chromium's style guide: http://www.chromium.org/developers/coding-style
# .. _Mozilla's style guide: https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style
# .. _WebKit's style guide: http://www.webkit.org/coding/coding-style.html
# Rational: Not needed as all options are manually set.
#BasedOnStyle: LLVM
# **AccessModifierOffset** (``int``)
# The extra indent or outdent of access modifiers, e.g. ``public:``.
# Rational: Average FG style with minimal diff.
AccessModifierOffset: -4
# **AlignAfterOpenBracket** (``BracketAlignmentStyle``)
# If ``true``, horizontally aligns arguments after an open bracket.
#
# This applies to round brackets (parentheses), angle brackets and square brackets.
#
# Possible values:
#
# * ``BAS_Align`` (in configuration: ``Align``) Align parameters on the open bracket, e.g.:
#
# .. parsed-literal::
#
# someLongFunction(argument1,
# argument2);
#
# * ``BAS_DontAlign`` (in configuration: ``DontAlign``) Don't align, instead use ``ContinuationIndentWidth``, e.g.:
#
# .. parsed-literal::
#
# someLongFunction(argument1,
# argument2);
#
# * ``BAS_AlwaysBreak`` (in configuration: ``AlwaysBreak``) Always break after an open bracket, if the parameters don't fit on a single line, e.g.:
#
# .. parsed-literal::
#
# someLongFunction(
# argument1, argument2);
# Rational: Average FG style with minimal diff.
#AlignAfterOpenBracket: AlwaysBreak
# Rational: Preservation of formatting.
AlignAfterOpenBracket: Align
# **AlignConsecutiveAssignments** (``bool``)
# If ``true``, aligns consecutive assignments.
#
# This will align the assignment operators of consecutive lines. This will result in formattings like
#
# .. parsed-literal::
#
# int aaaa = 12;
# int b = 23;
# int ccc = 23;
# Rational: Average FG style with minimal diff.
#AlignConsecutiveAssignments: false
# Rational: Preservation of formatting.
AlignConsecutiveAssignments: true
# **AlignConsecutiveDeclarations** (``bool``)
# If ``true``, aligns consecutive declarations.
#
# This will align the declaration names of consecutive lines. This will result in formattings like
#
# .. parsed-literal::
#
# int aaaa = 12;
# float b = 23;
# std::string ccc = 23;
# Rational: Average FG style with minimal diff.
# Rational: Preservation of formatting.
AlignConsecutiveDeclarations: true
# **AlignEscapedNewlines** (``EscapedNewlineAlignmentStyle``)
# Options for aligning backslashes in escaped newlines.
#
# Possible values:
#
# * ``ENAS_DontAlign`` (in configuration: ``DontAlign``) Don't align escaped newlines.
#
# .. parsed-literal::
#
# #define A \\
# int aaaa; \\
# int b; \\
# int dddddddddd;
#
# * ``ENAS_Left`` (in configuration: ``Left``) Align escaped newlines as far left as possible.
#
# .. parsed-literal::
#
# true:
# #define A \\
# int aaaa; \\
# int b; \\
# int dddddddddd;
#
# false:
#
# * ``ENAS_Right`` (in configuration: ``Right``) Align escaped newlines in the right-most column.
#
# .. parsed-literal::
#
# #define A \\
# int aaaa; \\
# int b; \\
# int dddddddddd;
# Clang version >= 5.
# Rational: Average FG style with minimal diff.
#AlignEscapedNewlines: Left
# Rational: Preservation of formatting.
#AlignEscapedNewlines: Left
# **AlignEscapedNewlinesLeft** (``bool``)
# If ``true``, aligns escaped newlines as far left as possible. Otherwise puts them into the right-most column.
# Clang version < 5.
# Rational: Average FG style with minimal diff.
# Rational: Preservation of formatting.
AlignEscapedNewlinesLeft: true
# **AlignOperands** (``bool``)
# If ``true``, horizontally align operands of binary and ternary expressions.
#
# Specifically, this aligns operands of a single expression that needs to be split over multiple lines, e.g.:
#
# .. parsed-literal::
#
# int aaa = bbbbbbbbbbbbbbb +
# ccccccccccccccc;
# Rational: Average FG style with minimal diff.
#AlignOperands: false
# Rational: Preservation of formatting.
AlignOperands: true
# **AlignTrailingComments** (``bool``)
# If ``true``, aligns trailing comments.
#
# .. parsed-literal::
#
# true: false:
# int a; // My comment a vs. int a; // My comment a
# int b = 2; // comment b int b = 2; // comment about b
# Rational: Average FG style with minimal diff.
#AlignTrailingComments: false
# Rational: Preservation of formatting.
AlignTrailingComments: true
# **AllowAllParametersOfDeclarationOnNextLine** (``bool``)
# If the function declaration doesn't fit on a line, allow putting all parameters of a function declaration onto the next line even if ``BinPackParameters`` is ``false``.
#
# .. parsed-literal::
#
# true:
# void myFunction(
# int a, int b, int c, int d, int e);
#
# false:
# void myFunction(int a,
# int b,
# int c,
# int d,
# int e);
# Rational: Average FG style with minimal diff.
# Rational: Preservation of formatting.
AllowAllParametersOfDeclarationOnNextLine: true
# **AllowShortBlocksOnASingleLine** (``bool``)
# Allows contracting simple braced statements to a single line.
#
# E.g., this allows ``if (a) { return; }`` to be put on a single line.
# Rational: Average FG style with minimal diff.
AllowShortBlocksOnASingleLine: true
# **AllowShortCaseLabelsOnASingleLine** (``bool``)
# If ``true``, short case labels will be contracted to a single line.
#
# .. parsed-literal::
#
# true: false:
# switch (a) { vs. switch (a) {
# case 1: x = 1; break; case 1:
# case 2: return; x = 1;
# } break;
# case 2:
# return;
# }
# Rational: Average FG style with minimal diff.
AllowShortCaseLabelsOnASingleLine: true
# **AllowShortFunctionsOnASingleLine** (``ShortFunctionStyle``)
# Dependent on the value, ``int f() { return 0; }`` can be put on a single line.
#
# Possible values:
#
# * ``SFS_None`` (in configuration: ``None``) Never merge functions into a single line.
#
# * ``SFS_InlineOnly`` (in configuration: ``InlineOnly``) Only merge functions defined inside a class. Same as “inline”, except it does not implies “empty”: i.e. top level empty functions are not merged either.
#
# .. parsed-literal::
#
# class Foo {
# void f() { foo(); }
# };
# void f() {
# foo();
# }
# void f() {
# }
#
# * ``SFS_Empty`` (in configuration: ``Empty``) Only merge empty functions.
#
# .. parsed-literal::
#
# void f() {}
# void f2() {
# bar2();
# }
#
# * ``SFS_Inline`` (in configuration: ``Inline``) Only merge functions defined inside a class. Implies “empty”.
#
# .. parsed-literal::
#
# class Foo {
# void f() { foo(); }
# };
# void f() {
# foo();
# }
# void f() {}
#
# * ``SFS_All`` (in configuration: ``All``) Merge all functions fitting on a single line.
#
# .. parsed-literal::
#
# class Foo {
# void f() { foo(); }
# };
# void f() { bar(); }
# Rational: Average FG style with minimal diff.
AllowShortFunctionsOnASingleLine: All
# **AllowShortIfStatementsOnASingleLine** (``bool``)
# If ``true``, ``if (a) return;`` can be put on a single line.
# Rational: Average FG style with minimal diff.
AllowShortIfStatementsOnASingleLine: true
# **AllowShortLoopsOnASingleLine** (``bool``)
# If ``true``, ``while (true) continue;`` can be put on a single line.
# Rational: Average FG style with minimal diff.
AllowShortLoopsOnASingleLine: true
# **AlwaysBreakAfterReturnType** (``ReturnTypeBreakingStyle``)
# The function declaration return type breaking style to use.
#
# Possible values:
#
# * ``RTBS_None`` (in configuration: ``None``) Break after return type automatically. ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
#
# .. parsed-literal::
#
# class A {
# int f() { return 0; };
# };
# int f();
# int f() { return 1; }
#
# * ``RTBS_All`` (in configuration: ``All``) Always break after the return type.
#
# .. parsed-literal::
#
# class A {
# int
# f() {
# return 0;
# };
# };
# int
# f();
# int
# f() {
# return 1;
# }
#
# * ``RTBS_TopLevel`` (in configuration: ``TopLevel``) Always break after the return types of top-level functions.
#
# .. parsed-literal::
#
# class A {
# int f() { return 0; };
# };
# int
# f();
# int
# f() {
# return 1;
# }
#
# * ``RTBS_AllDefinitions`` (in configuration: ``AllDefinitions``) Always break after the return type of function definitions.
#
# .. parsed-literal::
#
# class A {
# int
# f() {
# return 0;
# };
# };
# int f();
# int
# f() {
# return 1;
# }
#
# * ``RTBS_TopLevelDefinitions`` (in configuration: ``TopLevelDefinitions``) Always break after the return type of top-level definitions.
#
# .. parsed-literal::
#
# class A {
# int f() { return 0; };
# };
# int f();
# int
# f() {
# return 1;
# }
# Rational: Average FG style with minimal diff.
AlwaysBreakAfterReturnType: None
# **AlwaysBreakBeforeMultilineStrings** (``bool``)
# If ``true``, always break before multiline string literals.
#
# This flag is mean to make cases where there are multiple multiline strings in a file look more consistent. Thus, it will only take effect if wrapping the string at that point leads to it being indented ``ContinuationIndentWidth`` spaces from the start of the line.
#
# .. parsed-literal::
#
# true: false:
# aaaa = vs. aaaa = "bbbb"
# "bbbb" "cccc";
# "cccc";
# Rational: Average FG style with minimal diff.
AlwaysBreakBeforeMultilineStrings: false
# **AlwaysBreakTemplateDeclarations** (``bool``)
# If ``true``, always break after the ``template<...>`` of a template declaration.
#
# .. parsed-literal::
#
# true: false:
# template <typename T> vs. template <typename T> class C {};
# class C {};
# Rational: Average FG style with minimal diff.
AlwaysBreakTemplateDeclarations: false
# **BinPackArguments** (``bool``)
# If ``false``, a function call's arguments will either be all on the same line or will have one line each.
#
# .. parsed-literal::
#
# true:
# void f() {
# f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
# }
#
# false:
# void f() {
# f(aaaaaaaaaaaaaaaaaaaa,
# aaaaaaaaaaaaaaaaaaaa,
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
# }
# Rational: Average FG style with minimal diff.
BinPackArguments: true
# **BinPackParameters** (``bool``)
# If ``false``, a function declaration's or function definition's parameters will either all be on the same line or will have one line each.
#
# .. parsed-literal::
#
# true:
# void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
# int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
#
# false:
# void f(int aaaaaaaaaaaaaaaaaaaa,
# int aaaaaaaaaaaaaaaaaaaa,
# int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
# Rational: Average FG style with minimal diff.
BinPackParameters: true
# **BraceWrapping** (``BraceWrappingFlags``)
# Control of individual brace wrapping cases.
#
# If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how each individual brace case should be handled. Otherwise, this is ignored.
#
# .. parsed-literal::
#
# # Example of usage:
# BreakBeforeBraces: Custom
# BraceWrapping:
# AfterEnum: true
# AfterStruct: false
# SplitEmptyFunction: false
#
# Nested configuration flags:
#
# * ``bool AfterClass`` Wrap class definitions.
#
# .. parsed-literal::
#
# true:
# class foo {};
#
# false:
# class foo
# {};
#
# * ``bool AfterControlStatement`` Wrap control statements (``if``/``for``/``while``/``switch``/..).
#
# .. parsed-literal::
#
# true:
# if (foo())
# {
# } else
# {}
# for (int i = 0; i < 10; ++i)
# {}
#
# false:
# if (foo()) {
# } else {
# }
# for (int i = 0; i < 10; ++i) {
# }
#
# * ``bool AfterEnum`` Wrap enum definitions.
#
# .. parsed-literal::
#
# true:
# enum X : int
# {
# B
# };
#
# false:
# enum X : int { B };
#
# * ``bool AfterFunction`` Wrap function definitions.
#
# .. parsed-literal::
#
# true:
# void foo()
# {
# bar();
# bar2();
# }
#
# false:
# void foo() {
# bar();
# bar2();
# }
#
# * ``bool AfterNamespace`` Wrap namespace definitions.
#
# .. parsed-literal::
#
# true:
# namespace
# {
# int foo();
# int bar();
# }
#
# false:
# namespace {
# int foo();
# int bar();
# }
#
# * ``bool AfterObjCDeclaration`` Wrap ObjC definitions (interfaces, implementations…). @autoreleasepool and @synchronized blocks are wrapped according to *AfterControlStatement* flag.
#
# * ``bool AfterStruct`` Wrap struct definitions.
#
# .. parsed-literal::
#
# true:
# struct foo
# {
# int x;
# };
#
# false:
# struct foo {
# int x;
# };
#
# * ``bool AfterUnion`` Wrap union definitions.
#
# .. parsed-literal::
#
# true:
# union foo
# {
# int x;
# }
#
# false:
# union foo {
# int x;
# }
#
# * ``bool AfterExternBlock`` Wrap extern blocks.
#
# .. parsed-literal::
#
# true:
# extern "C"
# {
# int foo();
# }
#
# false:
# extern "C" {
# int foo();
# }
#
# * ``bool BeforeCatch`` Wrap before ``catch``.
#
# .. parsed-literal::
#
# true:
# try {
# foo();
# }
# catch () {
# }
#
# false:
# try {
# foo();
# } catch () {
# }
#
# * ``bool BeforeElse`` Wrap before ``else``.
#
# .. parsed-literal::
#
# true:
# if (foo()) {
# }
# else {
# }
#
# false:
# if (foo()) {
# } else {
# }
#
# * ``bool IndentBraces`` Indent the wrapped braces themselves.
#
# * ``bool SplitEmptyFunction`` If ``false``, empty function body can be put on a single line. This option is used only if the opening brace of the function has already been wrapped, i.e. the *AfterFunction* brace wrapping mode is set, and the function could/should not be put on a single line (as per *AllowShortFunctionsOnASingleLine* and constructor formatting options).
#
# .. parsed-literal::
#
# int f() vs. inf f()
# {} {
# }
#
# * ``bool SplitEmptyRecord`` If ``false``, empty record (e.g. class, struct or union) body can be put on a single line. This option is used only if the opening brace of the record has already been wrapped, i.e. the *AfterClass* (for classes) brace wrapping mode is set.
#
# .. parsed-literal::
#
# class Foo vs. class Foo
# {} {
# }
#
# * ``bool SplitEmptyNamespace`` If ``false``, empty namespace body can be put on a single line. This option is used only if the opening brace of the namespace has already been wrapped, i.e. the *AfterNamespace* brace wrapping mode is set.
#
# .. parsed-literal::
#
# namespace Foo vs. namespace Foo
# {} {
# }
# Rational: Average FG style with minimal diff.
BraceWrapping:
AfterClass: true
AfterControlStatement: false
AfterEnum: false
AfterFunction: true
AfterNamespace: false
AfterStruct: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
# Clang version >= 6.
# AfterExternBlock: false
# SplitEmptyFunction: false
# SplitEmptyRecord: false
# SplitEmptyNamespace: false
# **BreakBeforeBinaryOperators** (``BinaryOperatorStyle``)
# The way to wrap binary operators.
#
# Possible values:
#
# * ``BOS_None`` (in configuration: ``None``) Break after operators.
#
# .. parsed-literal::
#
# LooooooooooongType loooooooooooooooooooooongVariable =
# someLooooooooooooooooongFunction();
#
# bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
# aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
# ccccccccccccccccccccccccccccccccccccccccc;
# * ``BOS_NonAssignment`` (in configuration: ``NonAssignment``) Break before operators that aren't assignments.
#
# .. parsed-literal::
#
# LooooooooooongType loooooooooooooooooooooongVariable =
# someLooooooooooooooooongFunction();
#
# bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# > ccccccccccccccccccccccccccccccccccccccccc;
# * ``BOS_All`` (in configuration: ``All``) Break before operators.
#
# .. parsed-literal::
#
# LooooooooooongType loooooooooooooooooooooongVariable
# = someLooooooooooooooooongFunction();
#
# bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# > ccccccccccccccccccccccccccccccccccccccccc;
# Rational: Average FG style with minimal diff.
BreakBeforeBinaryOperators: None
# **BreakBeforeBraces** (``BraceBreakingStyle``)
# The brace breaking style to use.
#
# Possible values:
#
# * ``BS_Attach`` (in configuration: ``Attach``) Always attach braces to surrounding context.
#
# .. parsed-literal::
#
# try {
# foo();
# } catch () {
# }
# void foo() { bar(); }
# class foo {};
# if (foo()) {
# } else {
# }
# enum X : int { A, B };
#
# * ``BS_Linux`` (in configuration: ``Linux``) Like ``Attach``, but break before braces on function, namespace and class definitions.
#
# .. parsed-literal::
#
# try {
# foo();
# } catch () {
# }
# void foo() { bar(); }
# class foo
# {
# };
# if (foo()) {
# } else {
# }
# enum X : int { A, B };
#
# * ``BS_Mozilla`` (in configuration: ``Mozilla``) Like ``Attach``, but break before braces on enum, function, and record definitions.
#
# .. parsed-literal::
#
# try {
# foo();
# } catch () {
# }
# void foo() { bar(); }
# class foo
# {
# };
# if (foo()) {
# } else {
# }
# enum X : int { A, B };
#
# * ``BS_Stroustrup`` (in configuration: ``Stroustrup``) Like ``Attach``, but break before function definitions, ``catch``, and ``else``.
#
# .. parsed-literal::
#
# try {
# foo();
# } catch () {
# }
# void foo() { bar(); }
# class foo
# {
# };
# if (foo()) {
# } else {
# }
# enum X : int
# {
# A,
# B
# };
#
# * ``BS_Allman`` (in configuration: ``Allman``) Always break before braces.
#
# .. parsed-literal::
#
# try {
# foo();
# }
# catch () {
# }
# void foo() { bar(); }
# class foo {
# };
# if (foo()) {
# }
# else {
# }
# enum X : int { A, B };
#
# * ``BS_GNU`` (in configuration: ``GNU``) Always break before braces and add an extra level of indentation to braces of control statements, not to those of class, function or other definitions.
#
# .. parsed-literal::
#
# try
# {
# foo();
# }
# catch ()
# {
# }
# void foo() { bar(); }
# class foo
# {
# };
# if (foo())
# {
# }
# else
# {
# }
# enum X : int
# {
# A,
# B
# };
#
# * ``BS_WebKit`` (in configuration: ``WebKit``) Like ``Attach``, but break before functions.
#
# .. parsed-literal::
#
# try {
# foo();
# } catch () {
# }
# void foo() { bar(); }
# class foo {
# };
# if (foo()) {
# } else {
# }
# enum X : int { A, B };
#
# * ``BS_Custom`` (in configuration: ``Custom``) Configure each individual brace in *BraceWrapping*.
# Rational: Average FG style with minimal diff.
BreakBeforeBraces: Custom
# **BreakBeforeInheritanceComma** (``bool``)
# If ``true``, in the class inheritance expression clang-format will break before ``:`` and ``,`` if there is multiple inheritance.
#
# .. parsed-literal::
#
# true: false:
# class MyClass vs. class MyClass : public X, public Y {
# : public X };
# , public Y {
# };
# Clang version >= 5.
#BreakBeforeInheritanceComma: false
# **BreakBeforeTernaryOperators** (``bool``)
# If ``true``, ternary operators will be placed after line breaks.
#
# .. parsed-literal::
#
# true:
# veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
# ? firstValue
# : SecondValueVeryVeryVeryVeryLong;
#
# false:
# veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
# firstValue :
# SecondValueVeryVeryVeryVeryLong;
# Rational: Average FG style with minimal diff.
BreakBeforeTernaryOperators: true
# **BreakConstructorInitializers** (``BreakConstructorInitializersStyle``)
# The constructor initializers style to use.
#
# Possible values:
#
# * ``BCIS_BeforeColon`` (in configuration: ``BeforeColon``) Break constructor initializers before the colon and after the commas.
#
# Constructor()
# : initializer1(),
# initializer2()
#
# * ``BCIS_BeforeComma`` (in configuration: ``BeforeComma``) Break constructor initializers before the colon and commas, and align the commas with the colon.
#
# Constructor()
# : initializer1() , initializer2()
#
# * ``BCIS_AfterColon`` (in configuration: ``AfterColon``) Break constructor initializers after the colon and commas.
#
# Constructor() :
# initializer1(), initializer2()
# Clang version >= 5.
# Rational: Average FG style with minimal diff.
#BreakConstructorInitializers: None
# **BreakConstructorInitializersBeforeComma** (``bool``)
# Always break constructor initializers before commas and align the commas with the colon.
# Clang version < 5.
# Rational: Average FG style with minimal diff.
BreakConstructorInitializersBeforeComma: false
# **BreakStringLiterals** (``bool``)
# Allow breaking string literals when formatting.
# Rational: Average FG style with minimal diff.
BreakStringLiterals: false
# **ColumnLimit** (``unsigned``)
# The column limit.
#
# A column limit of ``0`` means that there is no column limit. In this case, clang-format will respect the input's line breaking decisions within statements unless they contradict other rules.
# Rational: Average FG style with minimal diff.
ColumnLimit: 0
# **CommentPragmas** (``std::string``)
# A regular expression that describes comments with special meaning, which should not be split into lines or otherwise changed.
#
# .. parsed-literal::
#
# // CommentPragmas: '^ FOOBAR pragma:'
# // Will leave the following line unaffected
# #include <vector> // FOOBAR pragma: keep
# Rational: Average FG style with minimal diff.
CommentPragmas: None
# **CompactNamespaces** (``bool``)
# If ``true``, consecutive namespace declarations will be on the same line. If ``false``, each namespace is declared on a new line.
#
# .. parsed-literal::
#
# true:
# namespace Foo { namespace Bar {
# }}
#
# false:
# namespace Foo {
# namespace Bar {
# }
# }
#
# If it does not fit on a single line, the overflowing namespaces get wrapped:
#
# .. parsed-literal::
#
# namespace Foo { namespace Bar {
# namespace Extra {
# }}}
# Clang version >= 5.
# Rational: Average FG style with minimal diff.
#CompactNamespaces: false
# **ConstructorInitializerAllOnOneLineOrOnePerLine** (``bool``)
# If the constructor initializers don't fit on a line, put each initializer on its own line.
#
# .. parsed-literal::
#
# true:
# SomeClass\:\:Constructor()
# : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
# return 0;
# }
#
# false:
# SomeClass\:\:Constructor()
# : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa),
# aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
# return 0;
# }
# Rational: Average FG style with minimal diff.
ConstructorInitializerAllOnOneLineOrOnePerLine: false
# **ConstructorInitializerIndentWidth** (``unsigned``)
# The number of characters to use for indentation of constructor initializer lists.
# Rational: Preservation of formatting.
ConstructorInitializerIndentWidth: 4
# **ContinuationIndentWidth** (``unsigned``)
# Indent width for line continuations.
#
# .. parsed-literal::
#
# ContinuationIndentWidth: 2
#
# int i = // VeryVeryVeryVeryVeryLongComment
# longFunction( // Again a long comment
# arg);
# Rational: Average FG style with minimal diff.
ContinuationIndentWidth: 4
# **Cpp11BracedListStyle** (``bool``)
# If ``true``, format braced lists as best suited for C++11 braced lists.
#
# Important differences: - No spaces inside the braced list. - No line break before the closing brace. - Indentation with the continuation indent, not with the block indent.
#
# Fundamentally, C++11 braced lists are formatted exactly like function calls would be formatted in their place. If the braced list follows a name (e.g. a type or variable name), clang-format formats as if the ``{}`` were the parentheses of a function call with that name. If there is no name, a zero-length name is assumed.
#
# .. parsed-literal::
#
# true: false:
# vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 };
# vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} };
# f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]);
# new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 };
# Rational: Switch to the C++11 braced lists format.
Cpp11BracedListStyle: true
# **DerivePointerAlignment** (``bool``)
# If ``true``, analyze the formatted file for the most common alignment of ``&`` and ``*``. Pointer and reference alignment styles are going to be updated according to the preferences found in the file. ``PointerAlignment`` is then used only as fallback.
# Rational: Do not override PointerAlignment!
DerivePointerAlignment: false
# **DisableFormat** (``bool``)
# Disables formatting completely.
# Rational: N/A.
DisableFormat: false
# **ExperimentalAutoDetectBinPacking** (``bool``)
# If ``true``, clang-format detects whether function calls and definitions are formatted with one parameter per line.
#
# Each call can be bin-packed, one-per-line or inconclusive. If it is inconclusive, e.g. completely on one line, but a decision needs to be made, clang-format analyzes whether there are other bin-packed cases in the input file and act accordingly.
#
# NOTE: This is an experimental flag, that might go away or be renamed. Do not use this in config files, etc. Use at your own risk.
# Rational: N/A.
#ExperimentalAutoDetectBinPacking: false
# **FixNamespaceComments** (``bool``)
# If ``true``, clang-format adds missing namespace end comments and fixes invalid existing ones.
#
# .. parsed-literal::
#
# true: false:
# namespace a { vs. namespace a {
# foo(); foo();
# } // namespace a; }
# Clang version >= 5.
# Rational: This should be set to ``true`` when possible.
#FixNamespaceComments: true
# **ForEachMacros** (``std::vector<std::string>``)
# A vector of macros that should be interpreted as foreach loops instead of as function calls.
#
# These are expected to be macros of the form:
#
# .. parsed-literal::
#
# FOREACH(<variable-declaration>, ...)
# <loop-body>
#
# In the .clang-format configuration file, this can be configured like:
#
# .. parsed-literal::
#
# ForEachMacros: \['RANGES_FOR', 'FOREACH']
#
# For example: BOOST_FOREACH.
# Rational: Average FG style with minimal diff.
ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
# **IncludeBlocks** (``IncludeBlocksStyle``)
# Dependent on the value, multiple ``#include`` blocks can be sorted as one and divided based on category.
#
# Possible values:
#
# * ``IBS_Preserve`` (in configuration: ``Preserve``) Sort each ``#include`` block separately.
#
# .. parsed-literal::
#
# #include "b.h" into #include "b.h"
#
# #include <lib/main.h> #include "a.h"
# #include "a.h" #include <lib/main.h>
#
# * ``IBS_Merge`` (in configuration: ``Merge``) Merge multiple ``#include`` blocks together and sort as one.
#
# .. parsed-literal::
#
# #include "b.h" into #include "a.h"
# #include "b.h"
# #include <lib/main.h> #include <lib/main.h>
# #include "a.h"
#
# * ``IBS_Regroup`` (in configuration: ``Regroup``) Merge multiple ``#include`` blocks together and sort as one. Then split into groups based on category priority. See ``IncludeCategories``.
#
# .. parsed-literal::
#
# #include "b.h" into #include "a.h"
# #include "b.h"
# #include <lib/main.h>
# #include "a.h" #include <lib/main.h>
# Clang version >= 6.
# Rational: Formatting clean up.
#IncludeBlocks: Regroup
# **IncludeCategories** (``std::vector<IncludeCategory>``)
# Regular expressions denoting the different ``#include`` categories used for ordering ``#includes``.
#
# These regular expressions are matched against the filename of an include (including the <> or “”) in order. The value belonging to the first matching regular expression is assigned and ``#includes`` are sorted first according to increasing category number and then alphabetically within each category.
#
# If none of the regular expressions match, INT_MAX is assigned as category. The main header for a source file automatically gets category 0. so that it is generally kept at the beginning of the ``#includes`` (http://llvm.org/docs/CodingStandards.html#include-style). However, you can also assign negative priorities if you have certain headers that always need to be first.
#
# To configure this in the .clang-format file, use:
#
# .. parsed-literal::
#
# IncludeCategories:
# - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
# Priority: 2
# - Regex: '^(<|"(gtest|gmock|isl|json)/)'
# Priority: 3
# - Regex: '.*'
# Priority: 1
# Rational: Left on the default LLVM values.
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|isl|json)/)'
Priority: 3
- Regex: '.*'
Priority: 1
# **IncludeIsMainRegex** (``std::string``)
# Specify a regular expression of suffixes that are allowed in the file-to-main-include mapping.
#
# When guessing whether a #include is the “main” include (to assign category 0, see above), use this regex of allowed suffixes to the header stem. A partial match is done, so that: - “” means “arbitrary suffix” - “$” means “no suffix”
#
# For example, if configured to “(_test)?$”, then a header a.h would be seen as the “main” include in both a.cc and a_test.cc.
# Rational: Average FG style with minimal diff.
IncludeIsMainRegex: '$'
# **IndentCaseLabels** (``bool``)
# Indent case labels one level from the switch statement.
#
# When ``false``, use the same indentation level as for the switch statement. Switch statement body is always indented one level more than case labels.
#
# .. parsed-literal::
#
# false: true:
# switch (fool) { vs. switch (fool) {
# case 1: case 1:
# bar(); bar();
# break; break;
# default: default:
# plop(); plop();
# } }
# Rational: Average FG style with minimal diff.
IndentCaseLabels: false
# **IndentPPDirectives** (``PPDirectiveIndentStyle``)
# The preprocessor directive indenting style to use.
#
# Possible values:
#
# * ``PPDIS_None`` (in configuration: ``None``) Does not indent any directives.
#
# .. parsed-literal::
#
# #if FOO
# #if BAR
# #include <foo>
# #endif
# #endif
#
# * ``PPDIS_AfterHash`` (in configuration: ``AfterHash``) Indents directives after the hash.
#
# .. parsed-literal::
#
# #if FOO
# # if BAR
# # include <foo>
# # endif
# #endif
# Clang version >= 6.
# Rational: Average FG style with minimal diff.
#IndentPPDirectives: AfterHash
# **IndentWidth** (``unsigned``)
# The number of columns to use for indentation.
#
# .. parsed-literal::
#
# IndentWidth: 3
#
# void f() {
# someFunction();
# if (true, false) {
# f();
# }
# }
# Rational: Average FG style with minimal diff.
IndentWidth: 4
# **IndentWrappedFunctionNames** (``bool``)
# Indent if a function definition or declaration is wrapped after the type.
#
# .. parsed-literal::
#
# true:
# LoooooooooooooooooooooooooooooooooooooooongReturnType
# LoooooooooooooooooooooooooooooooongFunctionDeclaration();
#
# false:
# LoooooooooooooooooooooooooooooooooooooooongReturnType
# LoooooooooooooooooooooooooooooooongFunctionDeclaration();
# Rational: Average FG style with minimal diff.
IndentWrappedFunctionNames: false
# **KeepEmptyLinesAtTheStartOfBlocks** (``bool``)
# If true, the empty line at the start of blocks is kept.
#
# .. parsed-literal::
#
# true: false:
# if (foo) { vs. if (foo) {
# bar();
# bar(); }
# }
# Rational: Average FG style with minimal diff.
KeepEmptyLinesAtTheStartOfBlocks: false
# **MacroBlockBegin** (``std::string``)
# A regular expression matching macros that start a block.
#
# .. parsed-literal::
#
# # With:
# MacroBlockBegin: "^NS_MAP_BEGIN|\\
# NS_TABLE_HEAD$"
# MacroBlockEnd: "^\\
# NS_MAP_END|\\
# NS_TABLE\_.*_END$"
#
# NS_MAP_BEGIN
# foo();
# NS_MAP_END
#
# NS_TABLE_HEAD
# bar();
# NS_TABLE_FOO_END
#
# # Without:
# NS_MAP_BEGIN
# foo();
# NS_MAP_END
#
# NS_TABLE_HEAD
# bar();
# NS_TABLE_FOO_END
# Rational: Average FG style with minimal diff.
MacroBlockBegin: ''
# **MacroBlockEnd** (``std::string``)
# A regular expression matching macros that end a block.
# Rational: Average FG style with minimal diff.
MacroBlockEnd: ''
# **MaxEmptyLinesToKeep** (``unsigned``)
# The maximum number of consecutive empty lines to keep.
#
# .. parsed-literal::
#
# MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0
# int f() { int f() {
# int = 1; int i = 1;
# i = foo();
# i = foo(); return i;
# }
# return i;
# }
# Rational: Avoid 3 or more empty lines.
MaxEmptyLinesToKeep: 2
# **NamespaceIndentation** (``NamespaceIndentationKind``)
# The indentation used for namespaces.
#
# Possible values:
#
# * ``NI_None`` (in configuration: ``None``) Don't indent in namespaces.
#
# .. parsed-literal::
#
# namespace out {
# int i;
# namespace in {
# int i;
# }
# }
#
# * ``NI_Inner`` (in configuration: ``Inner``) Indent only in inner namespaces (nested in other namespaces).
#
# .. parsed-literal::
#
# namespace out {
# int i;
# namespace in {
# int i;
# }
# }
#
# * ``NI_All`` (in configuration: ``All``) Indent in all namespaces.
#
# .. parsed-literal::
#
# namespace out {
# int i;
# namespace in {
# int i;
# }
# }
#
# Rational: Average FG style with minimal diff.
NamespaceIndentation: None
# **PenaltyBreakAssignment** (``unsigned``)
# The penalty for breaking around an assignment operator.
# Clang version >= 5.
#PenaltyBreakAssignment:
# **PenaltyBreakBeforeFirstCallParameter** (``unsigned``)
# The penalty for breaking a function call after ``call(``.
# Rational: Left to default.
PenaltyBreakBeforeFirstCallParameter: 19
# **PenaltyBreakComment** (``unsigned``)
# The penalty for each line break introduced inside a comment.
# Rational: Left to default.
PenaltyBreakComment: 300
# **PenaltyBreakFirstLessLess** (``unsigned``)
# The penalty for breaking before the first ``<<``.
# Rational: Left to default.
PenaltyBreakFirstLessLess: 120
# **PenaltyBreakString** (``unsigned``)
# The penalty for each line break introduced inside a string literal.
# Rational: Left to default.
PenaltyBreakString: 1000
# **PenaltyExcessCharacter** (``unsigned``)
# The penalty for each character outside of the column limit.
# Rational: Left to default.
PenaltyExcessCharacter: 1000000
# **PenaltyReturnTypeOnItsOwnLine** (``unsigned``)
# Penalty for putting the return type of a function onto its own line.
# Rational: Left to default.
PenaltyReturnTypeOnItsOwnLine: 60
# **PointerAlignment** (``PointerAlignmentStyle``)
# Pointer and reference alignment style.
#
# Possible values:
#
# * ``PAS_Left`` (in configuration: ``Left``) Align pointer to the left.
#
# .. parsed-literal::
#
# int* a;
#
# * ``PAS_Right`` (in configuration: ``Right``) Align pointer to the right.
#
# .. parsed-literal::
#
# int \*a;
#
# * ``PAS_Middle`` (in configuration: ``Middle``) Align pointer in the middle.
#
# .. parsed-literal::
#
# int * a;
# Rational: Average FG style with minimal diff.
PointerAlignment: Left
# **RawStringFormats** (``std::vector<RawStringFormat>``)
# Defines hints for detecting supported languages code blocks in raw strings.
#
# A raw string with a matching delimiter or a matching enclosing function name will be reformatted assuming the specified language based on the style for that language defined in the .clang-format file. If no style has been defined in the .clang-format file for the specific language, a predefined style given by ‘BasedOnStyle' is used. If ‘BasedOnStyle' is not found, the formatting is based on llvm style. A matching delimiter takes precedence over a matching enclosing function name for determining the language of the raw string contents.
#
# If a canonical delimiter is specified, occurrences of other delimiters for the same language will be updated to the canonical if possible.
#
# There should be at most one specification per language and each delimiter and enclosing function should not occur in multiple specifications.
#
# To configure this in the .clang-format file, use:
#
# .. parsed-literal::
#
# RawStringFormats:
# - Language: TextProto
# Delimiters:
# - 'pb'
# - 'proto'
# EnclosingFunctions:
# - 'PARSE_TEXT_PROTO'
# BasedOnStyle: google
# - Language: Cpp
# Delimiters:
# - 'cc'
# - 'cpp'
# BasedOnStyle: llvm
# CanonicalDelimiter: 'cc'
# Clang version >= 6.
#RawStringFormats:
# **ReflowComments** (``bool``)
# If ``true``, clang-format will attempt to re-flow comments.
#
# .. parsed-literal::
#
# false:
# // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
# /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information \*/
#
# true:
# // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
# // information
# /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
# * information \*/
# Rational: Seems to require ColumnLimit to be set.
ReflowComments: false
# **SortIncludes** (``bool``)
# If ``true``, clang-format will sort ``#includes``.
#
# .. parsed-literal::
#
# false: true:
# #include "b.h" vs. #include "a.h"
# #include "a.h" #include "b.h"
# Rational: Formatting clean up.
SortIncludes: true
# **SortUsingDeclarations** (``bool``)
# If ``true``, clang-format will sort using declarations.
#
# The order of using declarations is defined as follows: Split the strings by “\:\:” and discard any initial empty strings. The last element of each list is a non-namespace name; all others are namespace names. Sort the lists of names lexicographically, where the sort order of individual names is that all non-namespace names come before all namespace names, and within those groups, names are in case-insensitive lexicographic order.
#
# .. parsed-literal::
#
# false: true:
# using std::cout; vs. using std::cin;
# using std::cin; using std::cout;
# Clang version >= 5.
# Rational: Formatting clean up.
#SortUsingDeclarations: true
# **SpaceAfterCStyleCast** (``bool``)
# If ``true``, a space is inserted after C style casts.
#
# .. parsed-literal::
#
# true: false:
# (int) i; vs. (int)i;
# Rational: Average FG style with minimal diff.
SpaceAfterCStyleCast: false
# **SpaceAfterTemplateKeyword** (``bool``)
# If ``true``, a space will be inserted after the ‘template' keyword.
#
# .. parsed-literal::
#
# true: false:
# template <int> void foo(); vs. template<int> void foo();
# Clang version >= 4.
# Rational: Average FG style with minimal diff.
#SpaceAfterTemplateKeyword: true
# **SpaceBeforeAssignmentOperators** (``bool``)
# If ``false``, spaces will be removed before assignment operators.
#
# .. parsed-literal::
#
# true: false:
# int a = 5; vs. int a=5;
# a += 42 a+=42;
# Rational: Average FG style with minimal diff.
SpaceBeforeAssignmentOperators: true
# **SpaceBeforeCtorInitializerColon** (``bool``)
# If ``false``, spaces will be removed before constructor initializer colon.
#
# .. parsed-literal::
#
# true: false:
# Foo::Foo() : a(a) {} Foo::Foo(): a(a) {}
# Clang version >= 7.
# Rational: Average FG style with minimal diff.
#SpaceBeforeCtorInitializerColon: true
# **SpaceBeforeInheritanceColon** (``bool``)
# If ``false``, spaces will be removed before inheritance colon.
#
# .. parsed-literal::
#
# true: false:
# class Foo : Bar {} vs. class Foo: Bar {}
# Clang version >= 7.
# Rational: Average FG style with minimal diff.
#SpaceBeforeInheritanceColon: true
# **SpaceBeforeParens** (``SpaceBeforeParensOptions``)
# Defines in which cases to put a space before opening parentheses.
#
# Possible values:
#
# * ``SBPO_Never`` (in configuration: ``Never``) Never put a space before opening parentheses.
#
# .. parsed-literal::
#
# void f() {
# if(true) {
# f();
# }
# }
#
# * ``SBPO_ControlStatements`` (in configuration: ``ControlStatements``) Put a space before opening parentheses only after control statement keywords (``for/if/while...``).
#
# .. parsed-literal::
#
# void f() {
# if (true) {
# f();
# }
# }
#
# * ``SBPO_Always`` (in configuration: ``Always``) Always put a space before opening parentheses, except when it's prohibited by the syntax rules (in function-like macro definitions) or when determined by other style rules (after unary operators, opening parentheses, etc.)
#
# .. parsed-literal::
#
# void f () {
# if (true) {
# f ();
# }
# }
#
# Rational: Average FG style with minimal diff.
SpaceBeforeParens: ControlStatements
# **SpaceBeforeRangeBasedForLoopColon** (``bool``)
# If ``false``, spaces will be removed before range-based for loop colon.
#
# .. parsed-literal::
#
# true: false:
# for (auto v : values) {} vs. for(auto v: values) {}
# Clang version >= 7.
# Rational: Average FG style with minimal diff.
#SpaceBeforeRangeBasedForLoopColon: true
# **SpaceInEmptyParentheses** (``bool``)
# If ``true``, spaces may be inserted into ``()``.
#
# .. parsed-literal::
#
# true: false:
# void f( ) { vs. void f() {
# int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()};
# if (true) { if (true) {
# f( ); f();
# } }
# } }
# Rational: Average FG style with minimal diff.
SpaceInEmptyParentheses: false
# **SpacesBeforeTrailingComments** (``unsigned``)
# The number of spaces before trailing line comments (``//`` - comments).
#
# This does not affect trailing block comments (``/*`` - comments) as those commonly have different usage patterns and a number of special cases.
#
# .. parsed-literal::
#
# SpacesBeforeTrailingComments: 3
# void f() {
# if (true) { // foo1
# f(); // bar
# } // foo
# }
# Rational: Average FG style with minimal diff.
SpacesBeforeTrailingComments: 1
# **SpacesInAngles** (``bool``)
# If ``true``, spaces will be inserted after ``<`` and before ``>`` in template argument lists.
#
# .. parsed-literal::
#
# true: false:
# static_cast< int >(arg); vs. static_cast<int>(arg);
# std\:\:function< void(int) > fct; std\:\:function<void(int)> fct;
# Rational: Average FG style with minimal diff.
SpacesInAngles: false
# **SpacesInContainerLiterals** (``bool``)
# If ``true``, spaces are inserted inside container literals (e.g. ObjC and Javascript array and dict literals).
#
# .. parsed-literal::
#
# true: false:
# var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3];
# f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3});
# Rational: Average FG style with minimal diff.
SpacesInContainerLiterals: false
# **SpacesInCStyleCastParentheses** (``bool``)
# If ``true``, spaces may be inserted into C style casts.
#
# .. parsed-literal::
#
# true: false:
# x = ( int32 )y vs. x = (int32)y
# Rational: Average FG style with minimal diff.
SpacesInCStyleCastParentheses: false
# **SpacesInParentheses** (``bool``)
# If ``true``, spaces will be inserted after ``(`` and before ``)``.
#
# .. parsed-literal::
#
# true: false:
# t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete;
# Rational: Average FG style with minimal diff.
SpacesInParentheses: false
# **SpacesInSquareBrackets** (``bool``)
# If ``true``, spaces will be inserted after ``[`` and before ``]``. Lambdas or unspecified size array declarations will not be affected.
#
# .. parsed-literal::
#
# true: false:
# int a[ 5 ]; vs. int a[5];
# std::unique_ptr<int[]> foo() {} // Won't be affected
# Rational: Average FG style with minimal diff.
SpacesInSquareBrackets: false
# **Standard** (``LanguageStandard``)
# Format compatible with this standard, e.g. use ``A<A<int> >`` instead of ``A<A<int>>`` for ``LS_Cpp03``.
#
# Possible values:
#
# * ``LS_Cpp03`` (in configuration: ``Cpp03``) Use C++03-compatible syntax.
# * ``LS_Cpp11`` (in configuration: ``Cpp11``) Use features of C++11, C++14 and C++1z (e.g. ``A<A<int>>`` instead of ``A<A<int> >``).
# * ``LS_Auto`` (in configuration: ``Auto``) Automatic detection based on the input.
# Rational: FlightGear currently uses the C++11 standard.
Standard: Cpp11
# **TabWidth** (``unsigned``)
# The number of columns used for tab stops.
# Rational: Average FG style with minimal diff.
TabWidth: 4
# **UseTab** (``UseTabStyle``)
# The way to use tab characters in the resulting file.
#
# Possible values:
#
# * ``UT_Never`` (in configuration: ``Never``) Never use tab.
# * ``UT_ForIndentation`` (in configuration: ``ForIndentation``) Use tabs only for indentation.
# * ``UT_ForContinuationAndIndentation`` (in configuration: ``ForContinuationAndIndentation``) Use tabs only for line continuation and indentation.
# * ``UT_Always`` (in configuration: ``Always``) Use tabs whenever we need to fill whitespace that spans at least from one tab stop to the next one.
# Rational: Don't use "\t".
UseTab: Never
...
View git blame Copy permalink