.clang-format

# TdS Auto clang-format configuration file (clang-format 6.0)
#
# Use:
# - Install clang-format-6.0
#    >sudo apt-get install clang-format-6.0
#    (or sudo aptitude install, ...)
# - Put the .clang-format file in the working directory
# - For avoiding problems: put a "default" .clang-format configuration file in
#   the home repertory Either this one or a simple one with at least the
#   "Langage" and "BasedOnStyle" properties
# - Execute clang-format
#   >clang-format-6.0 -i -style=file <fileName1>.cpp
#   If several files:
#   >clang-format-6.0 -i -style=file <fileName1>.cpp <fileName2>.hpp ...
#   Note: the -i option tells clang-format to modify the file rather than
#   creating a new one
#
#   For formatting a lot of files:
#   >find . -name "*hpp" -exec clang-format-6.0 -i -style=file {} \;
#   >find . -name "*cpp" -exec clang-format-6.0 -i -style=file {} \;
#   Format all the files in the current folder (including subfolders)

# For immunizing a section against clang-format, encapsulate it with the
# the comments "clang-format off" and "clang-format on"
# // clang-format off
# ...
# // clang-format on

# For more information on the available properties and their possible value
# http://releases.llvm.org/6.0.1/tools/clang/docs/ClangFormatStyleOptions.html

# Language
Language: Cpp

# All values are set by default according to this convention
# These value are then overriden with the ones specified in this file
# -> Here we are closer to mozilla and chromium
BasedOnStyle: Chromium

# The extra indent or outdent of access modifiers, e.g. public:
# -> Set to -(the indentation) so that these modifiers are not indented
AccessModifierOffset: -4

# Alignement of inputs inside a round brackets (parentheses), angle brackets and
# square brackets
# when there is not enough space on a same line
# -> Align: stack them, one per line, vertically aligned with the first
#           character of the first input
#           someLongFunction(argument1,
#                            argument2)
AlignAfterOpenBracket: Align

# If true, aligns consecutive assignments
# -> false: since it can be strange when types with different length are near
#           each other
AlignConsecutiveAssignments: false

# If true, aligns consecutive declarations
# -> false: since it can be strange when types with different length are near
#           each other
AlignConsecutiveDeclarations: false

# Options for aligning backslashes in escaped newlines
# -> Align: escaped newlines as far left as possible
#    #define A     \
#        int aaaa; \
#        int b;    \
#        int dddddddddd;
AlignEscapedNewlines: Left

# If true, horizontally align operands of binary and ternary expressions
# -> true: aligns operands of a single expression that needs to be split over
#          multiple lines
#          int aaa = bbbbbbbbbbbbbbb +
#                    ccccccccccccccc;
AlignOperands: true

# If true, aligns trailing comments
# -> true: this is cleaner
#          int a      // Comment
#          Vector3f b // Comment
#          double* c  // Comment
AlignTrailingComments: true

# 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.
# -> false: Not allowed, split in one per line
#           void myFunction(int a,
#                           int b,
#                           int c,
#                           int d,
#                           int e);
AllowAllParametersOfDeclarationOnNextLine: false

# If true, allows contracting simple braced statements to a single line
# -> false: Not allowed for the sake of absolute clarity
AllowShortBlocksOnASingleLine: false

# If true, short case labels will be contracted to a single line
# -> false: Not allowed, only one instruction per line
AllowShortCaseLabelsOnASingleLine: false

# If true int f() { return 0; } can be put on a single line
# -> false: Not allowed, skip a line after a brace
AllowShortFunctionsOnASingleLine: false

# If true, if (a) return; can be put on a single line
# -> false: Not allowed
AllowShortIfStatementsOnASingleLine: false

# If true, while (true) continue; can be put on a single line
# -> false: Not allowed
AllowShortLoopsOnASingleLine: false

# DEPRECATED
# The function definition return type breaking style to use
# -> None: Break after return type automatically
AlwaysBreakAfterDefinitionReturnType: None

# The function declaration return type breaking style to use
# -> None: Break after return type automatically
AlwaysBreakAfterReturnType: None

# If true, always break before multiline string literals
# -> false
AlwaysBreakBeforeMultilineStrings: false

# If true, always break after the template<...> of a template declaration
# -> true: faster identification of templated objects
#    template <typename T>
#    class C {};
AlwaysBreakTemplateDeclarations: true

# If false, a function call’s arguments will either be all on the same line or
# will have one line each
# -> false, can look messy otherwise
BinPackArguments: false

# 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
# -> false, can look messy otherwise
BinPackParameters: false

# BraceWrapping: ignored since BreakBeforeBraces is not set to custom
# This field specifies how to treat each kind of braces when the property
# BreakBeforeBraces is set to custom
# In this file, BreakBeforeBraces is set to Allman which treats all the braces
# the same way: break before all braces
# See BreakBeforeBraces

# BreakAfterJavaFieldAnnotations: ignored for C++

# The way to wrap binary operators when expression are too long to hold on a
# single line
# -> All: Break before operators, so that they can easily be identified at the
#         beginning of the line
#
#    LooooooooooongType loooooooooooooooooooooongVariable
#      = someLooooooooooooooooongFunction();
#
#    bool value
#      = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#          == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#        && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#             > ccccccccccccccccccccccccccccccccccccccccc;
BreakBeforeBinaryOperators: All

# The brace breaking style to use
# -> Allman: Always break before braces, longer but clearer files
BreakBeforeBraces: Allman

# If true, in the class inheritance expression clang-format will break
# before ":" and "," if there is multiple inheritance
# -> false: breaking is overkill here most of the time
BreakBeforeInheritanceComma: false

# If true, ternary operators will be placed after line breaks
# -> true: for consistency with BreakBeforeBinaryOperators
BreakBeforeTernaryOperators: true

# The constructor initializers style to use
# -> AfterColon: Break constructor initializers after the colon and commas
#                because alone comma at the beginning of the line is ugly
BreakConstructorInitializers: AfterColon

# Allow breaking string literals when formatting
# -> true: clang format does it better than you
BreakStringLiterals: true

# Maximum number of characters per line
# -> 100: Historically 80 for C++, but quite deprecated today; it is dicutable
#         but 100 seemed to be more adequat in our case
ColumnLimit: 100

# A regular expression that describes comments with special meaning, which
# should not be split into lines or otherwise changed
# -> default value
CommentPragmas: '^ IWYU pragma:'

# If true, consecutive namespace declarations will be on the same line. If
# false, each namespace is declared on a new line
# -> false: one line per namespace, ugly otherwise
CompactNamespaces: false

# If the constructor initializers don’t fit on a line, put each initializer on
# its own line
# -> true
ConstructorInitializerAllOnOneLineOrOnePerLine: true

# The number of characters to use for indentation of constructor initializer
# lists
# -> 1 to highlight the brace at the end of the initialization and emphasize
#    that it is inside the constructor, but before any instruction
ConstructorInitializerIndentWidth: 1

# Indent width for line continuations
# -> 2: So that it is differenciable from other identations
ContinuationIndentWidth: 2

# If true, format braced lists as best suited for C++11 braced lists
# -> true
Cpp11BracedListStyle: true

# 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
# -> false: allways use the convention specified in this file
DerivePointerAlignment: false

# Disables formatting completely
# -> false
DisableFormat: false

# If true, clang-format detects whether function calls and definitions are
# formatted with one parameter per line
# -> false: allways use the convention specified in this file
ExperimentalAutoDetectBinPacking: false

# A vector of macros that should be interpreted as foreach loops instead of as
# function calls.
# -> no macro
ForEachMacros: []

# If true, clang-format adds missing namespace end comments and fixes invalid
# existing ones
# -> true: add a lot of clarity to these endless braces at the end of a file
FixNamespaceComments: true

# Indent case labels one level from the switch statement
# -> false
IndentCaseLabels: false

# The preprocessor directive indenting style to use
# -> None: never indent preprocessor directives
IndentPPDirectives: None

# The number of columns to use for indentation
# -> 4: Good compromise between visible and limiting additional spaces
IndentWidth: 4

# Indent if a function definition or declaration is wrapped after the type
# -> true: to be clear on the fact that this is not another function declaration
IndentWrappedFunctionNames: true

# If true, the empty line at the start of blocks is kept
# -> false: this is useless
KeepEmptyLinesAtTheStartOfBlocks: false

# The maximum number of consecutive empty lines to keep
# -> 1: Use comments to differenciate important parts of a big portion of code
#       (or split it into functions for instance) rather than a big block of
#       empty lines
MaxEmptyLinesToKeep: 1

# The indentation used for namespaces
# -> None: Do not add an indentation level
NamespaceIndentation: None

# Pointer and reference alignment style
# -> Left: the type of a variable is at its left, and the * or the & are part of
#          this type
PointerAlignment: Left

# If true, clang-format will attempt to re-flow comments
# -> true: because clang-format does it better than you
ReflowComments: true

# If true, clang-format will sort #includes
# -> false: see coding guidelines
SortIncludes: false

# If true, clang-format will sort using declarations
# -> false
SortUsingDeclarations: false

# If true, a space is inserted after C style casts
# -> false
SpaceAfterCStyleCast: false

# If true, a space will be inserted after the ‘template’ keyword
# -> false
SpaceAfterTemplateKeyword: false

# If false, spaces will be removed before assignment operators
# -> true
SpaceBeforeAssignmentOperators: true

# Defines in which cases to put a space before opening parentheses
# -> ControlStatements: Before if/while/for statements
SpaceBeforeParens: ControlStatements

# If true, spaces may be inserted into ()
# -> false
SpaceInEmptyParentheses: false

# The number of spaces before trailing line comments (// - comments)
# -> 1
SpacesBeforeTrailingComments: 1

# If true, spaces will be inserted after < and before > in template argument
# lists
# -> false
SpacesInAngles: false

# If true, spaces may be inserted into C style casts
# -> false
SpacesInCStyleCastParentheses: false

# If true, spaces are inserted inside container literals (e.g. ObjC and
# Javascript array and dict literals)
# -> false
SpacesInContainerLiterals: false

# If true, spaces will be inserted after ( and before )
# -> false
SpacesInParentheses: false

# If true, spaces will be inserted after [ and before ]. Lambdas or unspecified
# size array declarations will not be affected
# -> false
SpacesInSquareBrackets: false

# Format compatible with this standard, e.g. use A<A<int> > instead of A<A<int>>
# for LS_Cpp03
# Cpp11
Standard: Cpp11

# The number of columns used for tab stops
# Note: this property is not used since tabs are forbidden (see UseTab)
# -> 8
TabWidth: 8

# The way to use tab characters in the resulting file
# -> Never: Allways use spaces
UseTab: Never