.clang-format

AccessModifierOffset: 0

# Align at =
# auto var1      = value1;
# auto variable1 = value2;
AlignConsecutiveAssignments: true

# Align declarations
# ClassFoo    foo;
# ClassFooBar foobar;
AlignConsecutiveDeclarations: true

# int aaa = bbbbbbbbbbbbbbb +
#           ccccccccccccccc;
AlignOperands: true

# true:                                   false:
# int a;     // My comment a      vs.     int a; // My comment a
# int b = 2; // comment  b                int b = 2; // comment about b
AlignTrailingComments: true

# false:
# void myFunction(int a,
#                 int d,
#                 int e);
AllowAllParametersOfDeclarationOnNextLine: false
# false:
# void f() {
#  f(aaaaaaaaaaaaaaaaaaaa,
#    aaaaaaaaaaaaaaaaaaaa,
#    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
# }

AllowShortLambdasOnASingleLine: true
BreakBeforeBraces: Custom


BinPackArguments: false
BinPackParameters: false

# if true this allows if (a) { return; } to be put on a single line.
AllowShortBlocksOnASingleLine: true

# true:                                   false:
# switch (a) {                    vs.     switch (a) {
# case 1: x = 1; break;                   case 1:
# case 2: return;                           x = 1;
# }                                         break;
AllowShortCaseLabelsOnASingleLine: true

# class Foo {
#     void f() { foo(); }
# };
AllowShortFunctionsOnASingleLine: InlineOnly

# If true, if (a) return; can be put on a single line.
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true

# LooooooooooongType loooooooooooooooooooooongVariable
#    = someLooooooooooooooooongFunction();
# bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
#                    > ccccccccccccccccccccccccccccccccccccccccc;
BreakBeforeBinaryOperators: All

# try 
# {
#  foo();
# }
BraceWrapping:
    AfterCaseLabel: true
    AfterClass: true
    AfterControlStatement: Always
    AfterEnum: true
    AfterFunction: true
    AfterNamespace: true
    AfterStruct: true
    AfterUnion: true
    AfterExternBlock: true
    BeforeCatch: false
    BeforeElse: true
    BeforeLambdaBody: false
    BeforeWhile: false
    IndentBraces: false
    SplitEmptyFunction: false
    SplitEmptyRecord: false
    SplitEmptyNamespace: false

# true:
# veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
#    ? firstValue
#    : SecondValueVeryVeryVeryVeryLong;
BreakBeforeTernaryOperators: true

# Constructor() :
#    initializer1(),
#    initializer2()
BreakConstructorInitializers: AfterColon

# Type& name <- instead of -> Type &name
PointerAlignment: Left 

# Using 120 for now. Pending survey results
ColumnLimit: 140

IndentWidth: 4
Language: Cpp
MaxEmptyLinesToKeep: 1

# #define A   \
#   int aaaa; \
#   int b;    \
#   int dddddddddd;
AlignEscapedNewlines: Left

# true:
# SomeClass::Constructor()
#    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
#  return 0;
# }
# SomeClass::Constructor()
#    : aaaaaaaa(aaaaaaaa), 
#      aaaaaaaa(aaaaaaaa), 
#      aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa) {
#  return 0;
# }
ConstructorInitializerAllOnOneLineOrOnePerLine: true

# int i =         //  VeryVeryVeryVeryVeryLongComment
#     longFunction( // Again a long comment
#         arg);
ContinuationIndentWidth: 4

# true: vector<int> x{1, 2, 3, 4};     vs.    false: vector<int> x{ 1, 2, 3, 4 };
Cpp11BracedListStyle: true

# Force pointers to the type for C++.
# int* a;
DerivePointerBinding: false

# Automatically add namespace comment at the end of namespace
# namespace a {
# foo();
# } // namespace a;
FixNamespaceComments: true

# Sort each #include block separately
# #include "b.h"               into      #include "b.h"
# 
# #include <lib/main.h>                  #include "a.h"
##include "a.h"                         #include <lib/main.h>
IncludeBlocks: Preserve

# false:                                 true:
# switch (fool) {                vs.     switch (fool) {
# case 1:                                  case 1:
IndentCaseLabels: false

# true:                                  false:
# int a = 5;                     vs.     int a=5;
# a += 42                                a+=42;
SpaceBeforeAssignmentOperators: true

#void f() {
#  if (true) {   // foo1
#    f();        // bar
#  }             // foo
#}
SpacesBeforeTrailingComments: 4

# true:                                  false:
# static_cast< int >(arg);       vs.     static_cast<int>(arg);
# std::function< void(int) > fct;        std::function<void(int)> fct;
SpacesInAngles: false

# true:                                  false:
# x = ( int32 )y                 vs.     x = (int32)y
SpacesInCStyleCastParentheses: false

# true:                                  false:
# var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
# if({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
SpacesInContainerLiterals: false

# Need description and justification

#PenaltyBreakBeforeFirstCallParameter: 100
#PenaltyBreakComment: 100
#PenaltyBreakFirstLessLess: 0
#PenaltyBreakString: 100
#PenaltyExcessCharacter: 1
#PenaltyReturnTypeOnItsOwnLine: 20
#AlwaysBreakBeforeMultilineStrings: true
#AlwaysBreakTemplateDeclarations: true

Standard: Cpp11
TabWidth: 4
UseTab: Never