.clang-format

# -----------------------------------------------------------------------------
# Language
# -----------------------------------------------------------------------------

Language: Cpp
Standard: Latest
Cpp11BracedListStyle: true

# -----------------------------------------------------------------------------
# Common
# -----------------------------------------------------------------------------

# Numeric
TabWidth: 4
IndentWidth: 4
ColumnLimit: 80
PPIndentWidth: 1
MaxEmptyLinesToKeep: 1
AccessModifierOffset: -2
ContinuationIndentWidth: 4
SpacesBeforeTrailingComments: 1

# Enable/Disable/Option
UseTab: Never
LineEnding: DeriveLF
BinPackArguments: false
BinPackParameters: false
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakAfterDefinitionReturnType: All

# -----------------------------------------------------------------------------
# Not so common
# -----------------------------------------------------------------------------

SortIncludes: false
InsertBraces: false
ReflowComments:  false
RemoveSemicolon: false
RemoveBracesLLVM: false
PointerAlignment: Right
QualifierAlignment: Leave
InsertNewlineAtEOF: true
InsertTrailingCommas: None
BitFieldColonSpacing: Both
SeparateDefinitionBlocks: Leave
KeepEmptyLinesAtTheStartOfBlocks: false
ExperimentalAutoDetectBinPacking: false

# -----------------------------------------------------------------------------
# Align X
# -----------------------------------------------------------------------------

AlignOperands: Align
AlignEscapedNewlines: Left
AlignAfterOpenBracket: AlwaysBreak
AlignArrayOfStructures: None
AlignTrailingComments: false
AlignConsecutiveBitFields: false
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false

# -----------------------------------------------------------------------------
# Indent X
# -----------------------------------------------------------------------------

IndentCaseLabels: false
IndentCaseBlocks: false
IndentExternBlock: AfterExternBlock
IndentPPDirectives: AfterHash
IndentAccessModifiers: false
IndentWrappedFunctionNames: false

# -----------------------------------------------------------------------------
# Break X, Before X, After X
# -----------------------------------------------------------------------------

# X
BreakArrays: true
BreakStringLiterals: false
# Before X
BreakBeforeBraces: Linux
BreakBeforeBinaryOperators: All
BreakBeforeTernaryOperators: true
BreakBeforeConceptDeclarations: Always
# After X
BreakAfterReturnType: All
BreakAfterAttributes: Always

# -----------------------------------------------------------------------------
# Space Before X, In X, After X
# -----------------------------------------------------------------------------

# Before
SpaceBeforeParens: ControlStatements
SpaceBeforeCaseColon: false
SpaceBeforeSquareBrackets: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeRangeBasedForLoopColon: false
# In
SpacesInAngles:  Never
SpaceInEmptyBlock: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceInEmptyParentheses: false
SpacesInContainerLiterals: false
SpacesInConditionalStatement: false
SpacesInCStyleCastParentheses: false
# After
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false

# -----------------------------------------------------------------------------
# Allow X On A Single Line
# -----------------------------------------------------------------------------

AllowShortEnumsOnASingleLine: true
AllowShortLoopsOnASingleLine: false
AllowShortBlocksOnASingleLine: Never
AllowShortLambdasOnASingleLine: Empty
AllowShortFunctionsOnASingleLine: Empty
AllowShortCaseLabelsOnASingleLine: false
AllowShortIfStatementsOnASingleLine: Never

# -----------------------------------------------------------------------------
# Allow X On Next Line
# -----------------------------------------------------------------------------

AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true

# -----------------------------------------------------------------------------
# Macros
# -----------------------------------------------------------------------------

IfMacros:
  - 'if_test'
ForEachMacros:
 - 'for_each_builtin'
 - 'for_each_string_list_item'
 - 'for_each_ut'
 - 'for_each_wanted_builtin'
 - 'hashmap_for_each_entry'
 - 'hashmap_for_each_entry_from'
 - 'kh_foreach'
 - 'kh_foreach_value'
 - 'list_for_each'
 - 'list_for_each_dir'
 - 'list_for_each_prev'
 - 'list_for_each_prev_safe'
 - 'list_for_each_safe'
 - 'strintmap_for_each_entry'
 - 'strmap_for_each_entry'
 - 'strset_for_each_entry'

# -----------------------------------------------------------------------------
# Penalties
# -----------------------------------------------------------------------------

PenaltyBreakString: 10
PenaltyBreakComment: 10
PenaltyBreakAssignment: 10
PenaltyExcessCharacter: 100
PenaltyBreakFirstLessLess: 0
PenaltyReturnTypeOnItsOwnLine: 0
PenaltyBreakBeforeFirstCallParameter: 30

# -----------------------------------------------------------------------------
# May be useful
# -----------------------------------------------------------------------------

# BraceWrapping:
#   AfterCaseLabel:  false
#   AfterClass:      true
#   AfterControlStatement: Never
#   AfterEnum:       false
#   AfterExternBlock: false
#   AfterFunction:   true
#   AfterNamespace:  true
#   AfterObjCDeclaration: false
#   AfterStruct:     false
#   AfterUnion:      false
#   BeforeCatch:     false
#   BeforeElse:      false
#   BeforeLambdaBody: false
#   BeforeWhile:     false
#   IndentBraces:    false
#   SplitEmptyFunction: true
#   SplitEmptyRecord: true
#   SplitEmptyNamespace: true
# DerivePointerAlignment: false
# RequiresClausePosition: OwnLine
# EmptyLineAfterAccessModifier: Never
# EmptyLineBeforeAccessModifier: LogicalBlock
# RequiresExpressionIndentation: OuterScope

 # -----------------------------------------------------------------------------
 # Original clang-format of git/git.git 
 # -----------------------------------------------------------------------------

## This file is an example configuration for clang-format 5.0.
##
## Note that this style definition should only be understood as a hint
## for writing new code. The rules are still work-in-progress and does
## not yet exactly match the style we have in the existing code.
##
## Use tabs whenever we need to fill whitespace that spans at least from one tab
## stop to the next one.
##
## These settings are mirrored in .editorconfig.  Keep them in sync.
#UseTab: Never
#TabWidth: 4
#IndentWidth: 4
#ContinuationIndentWidth: 4
#ColumnLimit: 80

## C Language specifics
#Language: Cpp

## Align parameters on the open bracket
## someLongFunction(argument1,
##                  argument2);
#AlignAfterOpenBracket: Align

## Don't align consecutive assignments
## int aaaa = 12;
## int b = 14;
#AlignConsecutiveAssignments: false

## Don't align consecutive declarations
## int aaaa = 12;
## double b = 3.14;
#AlignConsecutiveDeclarations: false

## Align escaped newlines as far left as possible
## #define A   \
##   int aaaa; \
##   int b;    \
##   int cccccccc;
#AlignEscapedNewlines: Left

## Align operands of binary and ternary expressions
## int aaa = bbbbbbbbbbb +
##           cccccc;
#AlignOperands: true

## Don't align trailing comments
## int a; // Comment a
## int b = 2; // Comment b
#AlignTrailingComments: false

## By default don't allow putting parameters onto the next line
## myFunction(foo, bar, baz);
#AllowAllParametersOfDeclarationOnNextLine: false

## Don't allow short braced statements to be on a single line
## if (a)           not       if (a) return;
##   return;
#AllowShortBlocksOnASingleLine: false
#AllowShortCaseLabelsOnASingleLine: false
#AllowShortFunctionsOnASingleLine: false
#AllowShortIfStatementsOnASingleLine: false
#AllowShortLoopsOnASingleLine: false

## By default don't add a line break after the return type of top-level functions
## int foo();
#AlwaysBreakAfterReturnType: None

## Pack as many parameters or arguments onto the same line as possible
## int myFunction(int aaaaaaaaaaaa, int bbbbbbbb,
##                int cccc);
#BinPackArguments: true
#BinPackParameters: true

## Add no space around the bit field
## unsigned bf:2;
#BitFieldColonSpacing: None

## Attach braces to surrounding context except break before braces on function
## definitions.
## void foo()
## {
##    if (true) {
##    } else {
##    }
## };
#BreakBeforeBraces: Linux

## Break after operators
## int value = aaaaaaaaaaaaa +
##             bbbbbb -
##             ccccccccccc;
#BreakBeforeBinaryOperators: None
#BreakBeforeTernaryOperators: false

## Don't break string literals
#BreakStringLiterals: false

## Use the same indentation level as for the switch statement.
## Switch statement body is always indented one level more than case labels.
#IndentCaseLabels: false

## Indents directives before the hash. Each level uses a single space for
## indentation.
## #if FOO
## # include <foo>
## #endif
#IndentPPDirectives: AfterHash
#PPIndentWidth: 1

## Don't indent a function definition or declaration if it is wrapped after the
## type
#IndentWrappedFunctionNames: false

## Align pointer to the right
## int *a;
#PointerAlignment: Right

## Don't insert a space after a cast
## x = (int32)y;    not    x = (int32) y;
#SpaceAfterCStyleCast: false

## No space is inserted after the logical not operator
#SpaceAfterLogicalNot: false

## Insert spaces before and after assignment operators
## int a = 5;    not    int a=5;
## a += 42;             a+=42;
#SpaceBeforeAssignmentOperators: true

## Spaces will be removed before case colon.
## case 1: break;    not     case 1 : break;
#SpaceBeforeCaseColon: false

## Put a space before opening parentheses only after control statement keywords.
## void f() {
##   if (true) {
##     f();
##   }
## }
#SpaceBeforeParens: ControlStatements

## Don't insert spaces inside empty '()'
#SpaceInEmptyParentheses: false

## No space before first '[' in arrays
## int a[5][5];     not      int a [5][5];
#SpaceBeforeSquareBrackets: false

## No space will be inserted into {}
## while (true) {}    not    while (true) { }
#SpaceInEmptyBlock: false

## The number of spaces before trailing line comments (// - comments).
## This does not affect trailing block comments (/* - comments).
#SpacesBeforeTrailingComments: 1

## Don't insert spaces in casts
## x = (int32) y;    not    x = ( int32 ) y;
#SpacesInCStyleCastParentheses: false

## Don't insert spaces inside container literals
## var arr = [1, 2, 3];    not    var arr = [ 1, 2, 3 ];
#SpacesInContainerLiterals: false

## Don't insert spaces after '(' or before ')'
## f(arg);    not    f( arg );
#SpacesInParentheses: false

## Don't insert spaces after '[' or before ']'
## int a[5];    not    int a[ 5 ];
#SpacesInSquareBrackets: false

## Insert a space after '{' and before '}' in struct initializers
#Cpp11BracedListStyle: false

## A list of macros that should be interpreted as foreach loops instead of as
## function calls. Taken from:
##   git grep -h '^#define [^[:space:]]*for_\?each[^[:space:]]*(' |
##   sed "s/^#define /  - '/; s/(.*$/'/" | sort | uniq
#ForEachMacros:
#  - 'for_each_builtin'
#  - 'for_each_string_list_item'
#  - 'for_each_ut'
#  - 'for_each_wanted_builtin'
#  - 'hashmap_for_each_entry'
#  - 'hashmap_for_each_entry_from'
#  - 'kh_foreach'
#  - 'kh_foreach_value'
#  - 'list_for_each'
#  - 'list_for_each_dir'
#  - 'list_for_each_prev'
#  - 'list_for_each_prev_safe'
#  - 'list_for_each_safe'
#  - 'strintmap_for_each_entry'
#  - 'strmap_for_each_entry'
#  - 'strset_for_each_entry'

## A list of macros that should be interpreted as conditionals instead of as
## function calls.
#IfMacros:
#  - 'if_test'

## The maximum number of consecutive empty lines to keep.
#MaxEmptyLinesToKeep: 1

## No empty line at the start of a block.
#KeepEmptyLinesAtTheStartOfBlocks: false

## Penalties
## This decides what order things should be done if a line is too long
#PenaltyBreakAssignment: 10
#PenaltyBreakBeforeFirstCallParameter: 30
#PenaltyBreakComment: 10
#PenaltyBreakFirstLessLess: 0
#PenaltyBreakString: 10
#PenaltyExcessCharacter: 100
#PenaltyReturnTypeOnItsOwnLine: 60

## Don't sort #include's
#SortIncludes: false