.clang-format

Language: Cpp

# Aligns parameters contained within open brackets
# .e.g longFunction (argument1,
#                    argument2)
#AlignAfterOpenBracket: AlwaysBreak

# Aligns the assignment operators                     
#AlignConsecutiveAssignments: true

# Aligns the variable names
#AlignConsecutiveDeclarations: true

# Aligns operands that need to be split over multiple lines
#AlignOperands: true

# Align comments
#AlignTrailingComments: true

# if function declaration doesn't fit on a line, put all params
# of function dec. onto next line. Overrides BinPackParameters option
# void myFunc(
#       int a, int b, int c, int d, int e);
#AllowAllParametersOfDeclarationOnNextLine: false

# Allows braced statements to be on a single line
# e.g. if (eval) { return true; }
#AllowShortBlocksOnASingleLine: Never

# only merge functions defined inside a class, including empty ones
# Other options include "empty" where onyl empty functions are inline
# "InlineOnly" which excludes empty functions and "All" which merges 
# all functions fitting on a single line
#AllowShortFunctionsOnASingleLine: Inline

# single line conditionals can be put on a single line
# if (a) operation; 
# vs.
# if (a)
#     operation;
#AllowShortIfStatementsOnASingleLine: false

# self-explanatory. 
#AllowShortCaseLabelsOnASingleLine: false

# self-explanatory. for(;;) operation;
#AllowShortLoopsOnASingleLine: false

# break long strings into multiple lines and then align the strings
#AlwaysBreakBeforeMultilineStrings: false

# Forces the params and names following the template decl. to
# break into multiline
# e.g.
# template <typename T> 
# T foo (int a, int b)
#AlwaysBreakTemplateDeclarations: No

# if false, a function call's arguments get their own lines
#BinPackArguments: true

# if false, a function declaration's args get their own lines
#BinPackParameters: false

# forces the operator to be the end of line and the second monomial
# term to a new line
# e.g. val = a +
#            b /
#            c;
#BreakBeforeBinaryOperators: None

# forces each operand to a new line
#BreakBeforeTernaryOperators: true

#BreakBeforeBraces: Allman

# self-explanatory
ColumnLimit: 120

# stop clang from trying to format the special
# Cube-generated starting and ending comments
#CommentPragmas: '^( ###(\#+))'

# Either fits all the constructor call args onto one line
# or each param gets their own line if they don't fit
#ConstructorInitializerAllOnOneLineOrOnePerLine: true

# number of char to use for indentation of contructor initializer lists
# class::construct() : \noOfChars a(a), \noOfChars b(b) {};
#ConstructorInitializerIndentWidth: 2

# indent width length for line continuations
# int i =
# \noOfChars function(
# 2*\noOfChars arg);
#ContinuationIndentWidth: 4

# Format braced lists as best suited for C++11 braced lists
# Important Differences (if true)
# - no spaces inside the braced lists
# - no line break before closing brace
# - indentation with the continuation indentation, not with block indent
#Cpp11BracedListStyle: false

# "case" keywords are indented from the "switch"
#IndentCaseLabels: true

# self-explanatory
#IndentWidth: 4

# indent if function def or declaration is wrapped after the type
# e.g.
# stupidlyLongReturnType
#   stupidlyLongFunctionDeclaration();
#IndentWrappedFunctionNames: true

# empty line at start of new scope is kept
#KeepEmptyLinesAtTheStartOfBlocks: false

# Changed this. Made it C specific. Should also be left aligned.
# "Left"   : Leave the pointer character in a variable declaration to the left (e.g. int* a)
# "Right"  : Align pointer to right (e.g. int *a)
# "Middle" : Align pointer between type and var name (e.g. int * a)
PointerAlignment: Left

# if "None", no namespaces are indented
# if "Inner", only inner namespaces are indented
# if "All", every new scope is indented (intuitive)
#NamespaceIndentation: Inner

# splits long comments into multiline
#ReflowComments: true

# lists of the include headers in alphabetical order
#SortIncludes: CaseSensitive

# TODO: Enable me when clang-format has been updated to understand me
#SortUsingDeclarations: false

# inserts a space between casts and the variables they're targeting
#SpaceAfterCStyleCast: false

# TODO: Enable me when clang-format has been updated to understand me
#SpaceAfterTemplateKeyword: false

# self-explanatory
#SpaceBeforeAssignmentOperators: true

# "Never"             : don't put a space before opening parantheses
# "ControlStatements" : only put space before parantheses belonging to ctrl statements
# "Always"            : always put a space before opening params
#SpaceBeforeParens: ControlStatements

# self-explanatory
#SpaceInEmptyParentheses: false

# number of spaces before c-style comments "//"
#SpacesBeforeTrailingComments: 1

# spaces inserted after < and before > in template argument lists
#SpacesInAngles: false

# Spaces in parantheses for casting e.g. ( int )
#SpacesInCStyleCastParentheses: false

# Spaces inserted between array brackets
#SpacesInContainerLiterals: false

# self-explanatory
#SpacesInParentheses: false

# self-explanatory
#SpacesInSquareBrackets: false

# self-explanatory
TabWidth: 4

# self-explanatory
UseTab: ForIndentation