.clang-format

---
# Updated for clang-format 12.0.1, some commented values are there
# for when we update to clang-format 13
Language:        Cpp
Standard: Latest #Cpp20
# BasedOnStyle:  LLVM
# The extra indent or outdent of access modifiers (e.g., public)
AccessModifierOffset: -2
# Align parameters on the open bracket
# someLongFunction(argument1,
#                  argument2);
AlignAfterOpenBracket: Align
# Align array column and right justify the columns
#AlignArayOfStructures: Right
# Do not align equals signs of consecutive assignments
AlignConsecutiveAssignments: None
# Do not align the value of consecutive macros
AlignConsecutiveMacros: None
# Do not align the colons of consecutive bitfields
AlignConsecutiveBitFields: None
# Do not align the variable names of consecutive declarations
AlignConsecutiveDeclarations: None
# Align escaped newlines in macros - as far left as possible
AlignEscapedNewlinesLeft: Left
# Horizontally align operands of binary and ternary expressions
# Keeping the operand on the right edge of the upper line
AlignOperands:   Align
# Do not align consecutive comments that follow a line of code
AlignTrailingComments: false
# If a function call or braced initializer list doesn’t fit on a line,
# allow putting all arguments onto the next line, even if BinPackArguments is false.
AllowAllArgumentsOnNextLine: true
# If a constructor definition with a member initializer list doesn’t fit on a
# single line, allow putting all member initializers onto the next line, if
# `ConstructorInitializerAllOnOneLineOrOnePerLine` is true. Note that this parameter
# has no effect if `ConstructorInitializerAllOnOneLineOrOnePerLine` is false.
AllowAllConstructorInitializersOnNextLine: 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.
AllowAllParametersOfDeclarationOnNextLine: true
# Short blocks (e.g., empty while loop, or a for loop that just continues) are
# never merged into a single line
AllowShortBlocksOnASingleLine: Never
# Short case labels are not contracted into a single line
AllowShortCaseLabelsOnASingleLine: false
# Short enums are not contracted into a single line
AllowShortEnumsOnASingleLine: false
# Short functions are not contracted into a single line
AllowShortFunctionsOnASingleLine: None
# Short If Statements are not contracted into a single line
AllowShortIfStatementsOnASingleLine: Never
# Short lambdas are not contracted into a single line
AllowShortLambdasOnASingleLine: None
# short loops are not contracted to a single line
AllowShortLoopsOnASingleLine: false
# Do not break after the return type
AlwaysBreakAfterReturnType: None
# do not always break before multiline string literals
AlwaysBreakBeforeMultilineStrings: false
# Always break after a template declaration
AlwaysBreakTemplateDeclarations: Yes
# A vector of strings that should be interpreted as attributes/qualifiers instead of identifiers.
# This can be useful for language extensions or static analyzer annotations
AttributeMacros: ['__capability', '__unused']
# Function call arguments do not always have to have their own line if they don't
# fit on one line
BinPackArguments: true
# Function parameters do not always have to have their own line if they don't
# fit on one line
BinPackParameters: true
# Add one space on each side of the :
BitFieldColonSpacing: Both
# Configure each individual brace in BraceWrapping.
BreakBeforeBraces: Custom
BraceWrapping:
  # Opening brace under case label
  AfterCaseLabel: true
  # Class brace opens on the same line as the class name
  AfterClass:      true
  # Braces are under control statement
  AfterControlStatement: Always
  # Braces are under enum
  AfterEnum:       true
  # Braces are under function prototype
  AfterFunction:   true
  # Braces are under namespace
  AfterNamespace:  true
  # Braces are under struct keyword
  AfterStruct:     true
  # Braces are under union keyword
  AfterUnion:      true
  # Braces are under extern keyword
  AfterExternBlock: true
  # Braces are under catch keyword
  BeforeCatch:     true
  # else keyword is placed under if close brace
  BeforeElse:      true
  # Do not place a trailing while loop below the close brace
  BeforeWhile: false
  # Do not indent wrapped braces
  IndentBraces:    false
  # Empty function body braces are on multiple lines
  SplitEmptyFunction: true
  # Empty class/struct/union body braces are on multiple lines
  SplitEmptyRecord: true
  # empty namespace body braces are on multiple lines
  SplitEmptyNamespace: true
# For splitting long binary operations, break after the operator
BreakBeforeBinaryOperators: None
# Place concept declaration on a new line
BreakBeforeConceptDeclarations: true
# Break after the ternary operator - ?
BreakBeforeTernaryOperators: false
# Break constructor initializers after the colon and commas
BreakConstructorInitializers: AfterColon
# Break inheritance list after the colon and comma
BreakInheritanceList: AfterColon
# Allow breaking long string literals into multiple lines
BreakStringLiterals: true
# Max Width of a line when formatting
ColumnLimit:     100
# A regular expression that describes comments with special meaning,
# which should not be split into lines or otherwise changed.
CommentPragmas:  '^ IWYU pragma:'
# Each namespace declaration is placed on a new line
CompactNamespaces: false
# Do not require initializers to be on their own lines when breaking
ConstructorInitializerAllOnOneLineOrOnePerLine: false
# The number of characters to use for indentation of constructor initializer
# lists as well as inheritance lists.
ConstructorInitializerIndentWidth: 4
# Indent width for line continuations.
ContinuationIndentWidth: 4
# format braced lists as best suited for C++11 braced lists
Cpp11BracedListStyle: true
# Analyze the formatted file for the most used line ending (\r\n or \n).
# UseCRLF is only used as a fallback if none can be derived.
DeriveLineEnding: true
# Do not read the file to derive pointer alignment requirements. Uses PointerAlignment value.
DerivePointerAlignment: false
# Do not completely disable formatting
DisableFormat:   false
# Remove all empty lines after access modifiers
#EmptyLineAfterAccessModifier: Never
#  Add empty line only when access modifier starts a new logical block.
# Logical block is a group of one or more member fields or functions.
EmptyLineBeforeAccessModifier: LogicalBlock
# add missing namespace end comments for short namespaces and fixes invalid existing ones.
FixNamespaceComments: true
# A vector of macros that should be interpreted as foreach loops instead of as function calls.
ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
# Sort each #include block separately (blocks of includes are separated by empty lines)
IncludeBlocks:   Preserve
# Regular expressions denoting the different #include categories used for ordering #includes.
IncludeCategories:
  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
    Priority:        2
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '^(<|"(gtest|gmock|isl|json|catch2|cmocka)/)'
    Priority:        3
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '.*'
    Priority:        1
    SortPriority:    0
    CaseSensitive:   false
# Specify a regular expression of suffixes that are allowed in the file-to-main-include mapping.
# use this regex of allowed suffixes to the header stem.
# A partial match is done, so that: - “” means “arbitrary suffix” - “$” means “no suffix”
IncludeIsMainRegex: '$'
# Specify a regular expression for files being formatted that are allowed to be considered
# “main” in the file-to-main-include mapping.
IncludeIsMainSourceRegex: ''
# access modifiers are indented (or outdented) relative to the record members,
# respecting the AccessModifierOffset
#IndentAccessModifiers: false
# Do not indent case blocks one level from case label
IndentCaseBlocks: false
# Do indent case labels within a switch block
IndentCaseLabels: true
# Use AfterExternBlock's indenting rule
IndentExternBlock: AfterExternBlock
# Goto labels are indented to proper level
IndentGotoLabels: true
# Indents preprocessor directives before the hash.
IndentPPDirectives: BeforeHash
# Indent requires clause in a template
IndentRequires: true
# Number of coluns to use for indentation
IndentWidth:     4
# Indent if a function definition or declaration is wrapped after the type.
IndentWrappedFunctionNames: true
# Remove empty lines at the start of a block
KeepEmptyLinesAtTheStartOfBlocks: false
# Align lambda body relative to the start of the lambda signature
#LambdaBodyIndentation: Signature
# A regular expression matching macros that start a block.
MacroBlockBegin: ''
# A regular expression matching macros that end a block.
MacroBlockEnd:   ''
# Maximum number of consecutive empty lines to keep
MaxEmptyLinesToKeep: 1
# Don’t indent namespaces
NamespaceIndentation: None
# A vector of macros which are used to open namespace blocks
#NamespaceMacros: ''
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
# align pointers: int* ptr
PointerAlignment: Left
# align references like pointers
#ReferenceAlignment: Pointer
# Clang-format will attempt to reflow long comments
ReflowComments:  true
# Always have an ending namespace commment
#ShortNamespaceLines: 0
# Include sorting is alphabetical and case insensitive
SortIncludes: false   #CaseInsensitive
# using declarations will be  alphabetically sorted
SortUsingDeclarations: true
# Do not insert a space after a C-style cast
SpaceAfterCStyleCast: false
# Do not insert as pace after a logical not (!)
SpaceAfterLogicalNot: false
# Do not insert as pace after the template keyword
SpaceAfterTemplateKeyword: false
# Don't ensure spaces around pointer qualifiers, use PointerAlignment instead
SpaceAroundPointerQualifiers: Default
# Place spaces before assignment operators (=, +=, etc.)
SpaceBeforeAssignmentOperators: true
# Do not place a space befrore a case statement colon
SpaceBeforeCaseColon: false
# Do not place a space befrore a C++11 braced list
SpaceBeforeCpp11BracedList: false
# Do place a space between the constructor and the initializer colon
SpaceBeforeCtorInitializerColon: true
# Place a space between the class and the inheritance colon
SpaceBeforeInheritanceColon: true
# Never place a space between an item and following parens
SpaceBeforeParens: Never
# do not place a space before a range based for loop
SpaceBeforeRangeBasedForLoopColon: false
# do not place a space before square brackets []
SpaceBeforeSquareBrackets: false
# do not place a space in an empty block
SpaceInEmptyBlock: false
# Do not place a space in empty parens
SpaceInEmptyParentheses: false
# Spaces between end of the code and the start of a // line comment
SpacesBeforeTrailingComments: 1
# Remove spaces within <> : <int>
SpacesInAngles:  false #Never
# Do not add spaces in C-style cast parens
SpacesInCStyleCastParentheses: false
# Do not add spaces around if/for/while/switch conditions
SpacesInConditionalStatement: false
# Do not insert spaces inside container literals
SpacesInContainerLiterals: false
# Do not insert spaces after ( and before )
SpacesInParentheses: false
# Do not insert spaces after [ and before ]
SpacesInSquareBrackets: false
# Macros which are ignored in front of a statement, as if they were an attribute.
# StatementAttributeLikeMacros:
# A vector of macros that should be interpreted as complete statements.
# StatementMacros: ''
# The number of columns used for tab stops.
TabWidth:        4
# A vector of macros that should be interpreted as type declarations instead of as function calls.
#TypenameMacros: ''
# use \n for line breaks
UseCRLF: false
# Use tabs whenever we need to fill whitespace that spans at least from one tab stop to the next one.
UseTab:          Always
# A vector of macros which are whitespace-sensitive and should not be touched.
WhitespaceSensitiveMacros:
  - STRINGIZE
  - PP_STRINGIZE
  - BOOST_PP_STRINGIZE
  - NS_SWIFT_NAME
  - CF_SWIFT_NAME
...