Add Clang Format File

.clang-format

@@ -0,0 +1,389 @@
+---
+# Updated for clang-format 12.0.1, some commented values are there
+# for when we update to clang-format 13
+# https://embeddedartistry.com/blog/2017/10/23/creating-and-enforcing-a-code-formatting-standard-with-clang-format/
+Language:       Cpp
+Standard:       Latest #Cpp20
+BasedOnStyle:   Google
+
+# 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:     80
+
+# 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: true
+
+# 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 columns 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