Permalink
Browse files

Use clang-format to format priest module.

  • Loading branch information...
1 parent d464584 commit 2835459da1d35106d59b11abfec7640f9757f4c4 @scamille scamille committed Oct 18, 2015
Showing with 3,892 additions and 2,411 deletions.
  1. +260 −0 .clang-format
  2. +3,439 −2,235 engine/class_modules/sc_priest.cpp
  3. +193 −176 engine/sc_enums.hpp
View
@@ -0,0 +1,260 @@
+# SimulationCraft clang-format specification file.
+# documented using clang-format 3.8 documentation on 2015-10-18
+
+
+# The style used for all options not specifically set in the configuration.
+BasedOnStyle: Google
+
+# The extra indent or outdent of access modifiers, e.g. public:.
+AccessModifierOffset: -2
+
+# If true, horizontally aligns arguments after an open bracket. This applies to round brackets (parentheses), angle brackets and square brackets.
+AlignAfterOpenBracket: true
+
+# If true, aligns consecutive assignments. This will align the assignment operators of consecutive lines.
+AlignConsecutiveAssignments: true
+
+# If true, aligns consecutive declarations. This will align the declaration names of consecutive lines.
+AlignConsecutiveDeclarations: false
+
+# If true, aligns escaped newlines as far left as possible. Otherwise puts them into the right-most column.
+AlignEscapedNewlinesLeft: true
+
+# If true, horizontally align operands of binary and ternary expressions.
+AlignOperands: true
+
+# If true, aligns trailing comments.
+AlignTrailingComments: true
+
+# Allow putting all parameters of a function declaration onto the next line even if BinPackParameters is false.
+AllowAllParametersOfDeclarationOnNextLine: false
+
+# Allows contracting simple braced statements to a single line. E.g., this allows if (a) { return; } to be put on a single line.
+AllowShortBlocksOnASingleLine: false
+
+# If true, short case labels will be contracted to a single line.
+AllowShortCaseLabelsOnASingleLine: false
+
+# Dependent on the value, int f() { return 0; } can be put on a single line.
+# Possible values:
+# * SFS_None (in configuration: None) Never merge functions into a single line.
+# * SFS_Empty (in configuration: Empty) Only merge empty functions.
+# * SFS_Inline (in configuration: Inline) Only merge functions defined inside a class. Implies empty.
+# * SFS_All (in configuration: All) Merge all functions fitting on a single line.
+AllowShortFunctionsOnASingleLine: None
+
+# If true, if (a) return; can be put on a single line.
+AllowShortIfStatementsOnASingleLine: false
+
+# If true, while (true) continue; can be put on a single line.
+AllowShortLoopsOnASingleLine: false
+
+# The function definition return type breaking style to use.
+# Possible values:
+# * DRTBS_None (in configuration: None) Break after return type automatically. PenaltyReturnTypeOnItsOwnLine is taken into account.
+# * DRTBS_All (in configuration: All) Always break after the return type.
+# * DRTBS_TopLevel (in configuration: TopLevel) Always break after the return types of top level functions.
+AlwaysBreakAfterDefinitionReturnType: None
+
+# If true, always break before multiline string literals.
+# This flag is mean to make cases where there are multiple multiline strings in a file look more consistent. Thus, it will only take effect if wrapping the string at that point leads to it being indented ContinuationIndentWidth spaces from the start of the line.
+AlwaysBreakBeforeMultilineStrings: true
+
+# If true, always break after the template<...> of a template declaration.
+AlwaysBreakTemplateDeclarations: true
+
+# If false, a function calls arguments will either be all on the same line or will have one line each.
+BinPackArguments: true
+
+# If false, a function declarations or function definitions parameters will either all be on the same line or will have one line each.
+BinPackParameters: true
+
+# Control of individual brace wrapping cases.
+# If BreakBeforeBraces is set to custom, use this to specify how each individual brace case should be handled. Otherwise, this is ignored.
+BraceWrapping:
+ AfterClass: true
+ # Wrap control statements (if/for/while/switch/..).
+ AfterControlStatement: true
+ AfterEnum: true
+ AfterFunction: true
+ AfterNamespace: true
+ AfterObjCDeclaration: true
+ AfterStruct: true
+ AfterUnion: true
+ BeforeCatch: true
+ BeforeElse: true
+ # Indent the wrapped braces themselves.
+ IndentBraces: false
+
+# The way to wrap binary operators.
+# Possible values:
+# * BOS_None (in configuration: None) Break after operators.
+# * BOS_NonAssignment (in configuration: NonAssignment) Break before operators that arent assignments.
+# * BOS_All (in configuration: All) Break before operators.
+BreakBeforeBinaryOperators: None
+
+# The brace breaking style to use.
+BreakBeforeBraces: Custom
+
+# If true, ternary operators will be placed after line breaks.
+BreakBeforeTernaryOperators: true
+
+# Always break constructor initializers before commas and align the commas with the colon.
+BreakConstructorInitializersBeforeComma: false
+
+# The column limit.
+ColumnLimit: 80
+
+# A regular expression that describes comments with special meaning, which should not be split into lines or otherwise changed.
+CommentPragmas: '^ IWYU pragma:'
+
+# If the constructor initializers dont fit on a line, put each initializer on its own line.
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+
+# The number of characters to use for indentation of constructor initializer lists.
+ConstructorInitializerIndentWidth: 2
+
+# Indent width for line continuations.
+ContinuationIndentWidth: 4
+
+# If true, format braced lists as best suited for C++11 braced lists.
+Cpp11BracedListStyle: true
+
+# If true, analyze the formatted file for the most common alignment of & and *. PointerAlignment is then used only as fallback.
+DerivePointerAlignment: true
+
+# Disables formatting completely.
+DisableFormat: false
+
+# If true, clang-format detects whether function calls and definitions are formatted with one parameter per line.
+ExperimentalAutoDetectBinPacking: false
+
+# A vector of macros that should be interpreted as foreach loops instead of as function calls.
+ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
+
+# Regular expressions denoting the different #include categories used for ordering #includes.
+IncludeCategories:
+ - Regex: '^<.*\.h>'
+ Priority: 1
+ - Regex: '^<.*'
+ Priority: 2
+ - Regex: '.*'
+ Priority: 3
+
+# Indent case labels one level from the switch statement.
+# When false, use the same indentation level as for the switch statement. Switch statement body is always indented one level more than case labels.
+IndentCaseLabels: true
+
+# The number of columns to use for indentation.
+IndentWidth: 2
+
+# Indent if a function definition or declaration is wrapped after the type.
+IndentWrappedFunctionNames: false
+
+# If true, empty lines at the start of blocks are kept.
+KeepEmptyLinesAtTheStartOfBlocks: false
+
+# Language, this format style is targeted at.
+Language: Cpp
+
+# A regular expression matching macros that start a block.
+MacroBlockBegin: ''
+
+# A regular expression matching macros that end a block.
+MacroBlockEnd: ''
+
+# The maximum number of consecutive empty lines to keep.
+MaxEmptyLinesToKeep: 1
+
+# The indentation used for namespaces.
+# Possible values:
+# * NI_None (in configuration: None) Dont indent in namespaces.
+# * NI_Inner (in configuration: Inner) Indent only in inner namespaces (nested in other namespaces).
+# * NI_All (in configuration: All) Indent in all namespaces.
+NamespaceIndentation: None
+
+# The number of characters to use for indentation of ObjC blocks.
+ObjCBlockIndentWidth: 2
+
+# Add a space after @property in Objective-C, i.e. use \@property (readonly) instead of \@property(readonly).
+ObjCSpaceAfterProperty: false
+
+# Add a space in front of an Objective-C protocol list, i.e. use Foo <Protocol> instead of Foo<Protocol>.
+ObjCSpaceBeforeProtocolList: false
+
+# The penalty for breaking a function call after call(.
+PenaltyBreakBeforeFirstCallParameter: 1
+
+# The penalty for each line break introduced inside a comment.
+PenaltyBreakComment: 300
+
+# The penalty for breaking before the first <<.
+PenaltyBreakFirstLessLess: 120
+
+# The penalty for each line break introduced inside a string literal.
+PenaltyBreakString: 1000
+
+# The penalty for each character outside of the column limit.
+PenaltyExcessCharacter: 1000000
+
+# Penalty for putting the return type of a function onto its own line.
+PenaltyReturnTypeOnItsOwnLine: 200
+
+# Pointer and reference alignment style.
+# Possible values:
+# * PAS_Left (in configuration: Left) Align pointer to the left.
+# * PAS_Right (in configuration: Right) Align pointer to the right.
+# * PAS_Middle (in configuration: Middle) Align pointer in the middle.
+PointerAlignment: Left
+
+# If true, a space may be inserted after C style casts.
+SpaceAfterCStyleCast: false
+
+# If false, spaces will be removed before assignment operators.
+SpaceBeforeAssignmentOperators: true
+
+# Defines in which cases to put a space before opening parentheses.
+# Possible values:
+# * SBPO_Never (in configuration: Never) Never put a space before opening parentheses.
+# * SBPO_ControlStatements (in configuration: ControlStatements) Put a space before opening parentheses only after control statement keywords (for/if/while...).
+# * SBPO_Always (in configuration: Always) Always put a space before opening parentheses, except when it is prohibited by the syntax rules (in function-like macro definitions) or when determined by other style rules (after unary operators, opening parentheses, etc.)
+SpaceBeforeParens: ControlStatements
+
+# If true, spaces may be inserted into ().
+SpaceInEmptyParentheses: false
+
+# The number of spaces before trailing line comments (// - comments).
+# This does not affect trailing block comments (/**/ - comments) as those commonly have different usage patterns and a number of special cases.
+SpacesBeforeTrailingComments: 2
+
+# If true, spaces will be inserted after < and before > in template argument lists
+SpacesInAngles: false
+
+# If true, spaces are inserted inside container literals (e.g. ObjC and Javascript array and dict literals).
+SpacesInContainerLiterals: true
+
+# If true, spaces may be inserted into C style casts.
+SpacesInCStyleCastParentheses: false
+
+# If true, spaces will be inserted after ( and before ).
+SpacesInParentheses: true
+
+# If true, spaces will be inserted after [ and before ].
+SpacesInSquareBrackets: true
+
+# Format compatible with this standard, e.g. use A<A<int> > instead of A<A<int>> for LS_Cpp03.
+# Possible values:
+# * LS_Cpp03 (in configuration: Cpp03) Use C++03-compatible syntax.
+# * LS_Cpp11 (in configuration: Cpp11) Use features of C++11 (e.g. A<A<int>> instead of A<A<int> >).
+# * LS_Auto (in configuration: Auto) Automatic detection based on the input.
+Standard: Auto
+
+# The number of columns used for tab stops.
+TabWidth: 8
+
+# The way to use tab characters in the resulting file.
+# Possible values:
+# * UT_Never (in configuration: Never) Never use tab.
+# * UT_ForIndentation (in configuration: ForIndentation) Use tabs only for indentation.
+# * UT_Always (in configuration: Always) Use tabs whenever we need to fill whitespace that spans at least from one tab stop to the next one.
+UseTab: Never
Oops, something went wrong.

0 comments on commit 2835459

Please sign in to comment.