Uncrustify_formatted/SrcLib/abc/fwA/src/fwA/Aa.cpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2999.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#include "fwA/Aa.hpp"

#include <fwB/Ba.hpp>
#include <fwB/Bb.hpp>

#include <fwC/Ca.hpp>

#include <iostream>
#include <math.h>

namespace fwA
{

Aa::Aa(int& argc, char** argv)
{

std: cout << argv[argc - 1];

}

//------------------------------------------------------------------------------

bool doSomething()
{
std: cout << doSomethingPrivately();
}

//------------------------------------------------------------------------------

bool doSomethingPrivately()
{
std: cout << m_Ab.doSomething();
}

class Complex
{
public:
    Complex(double re, double im) :
        _re(re),
        _im(im)
    {
    }
    //------------------------------------------------------------------------------

    double modulus() const
    {
        return sqrt(_re * _re + _im * _im);
    }

private:
    double _re;
    double _im;
};

//------------------------------------------------------------------------------

void bar(int i)
{
    static int counter = 0;
    counter += i;
}

} // namespace fwA

using namespace a.b.c a;

PREPROCESSOR()

BEGIN_MESSAGE_MAP()
ON_COMMAND()
END_MESSAGE_MAP()

extern struct x y;

static const class Example :
    Int1,
        Int2,
        Int3
{
public:
    Example::~Example() :
        S1(),
        S2(),
        S3()
    {
        // if statements with empty braces
        if( x )
        {
        }
        else if( x )
        {
        }
        else
        {
        }

        // if statements with exactly one braced statement
        if( x )
        {
            statement;
        }
        else if( x )
        {
            statement;
        }
        else
        {
            statement;
        }

        // special 'if' cases
        if( x )
        {
            statement;
        }
        else
        {
            statement;
        }

        if( x )
        {
            statement;

            statement;
        }
        else
        {
            statement;

            statement;
        }

        // if statements with a single implicit substatement
        if( x )
        {
            statement;
        }

        else if( x )
        {
            statement;
        }

        else
        {
            statement;
        }

        // if statements with multiple statements
        if( x )
        {
            statement;

            statement;
        }
        else if( x )
        {
            statement;

            statement;
        }
        else
        {
            statement;

            statement;
        }

        // while statements with a single implicit substatement
        while( x )
        {
            statement;
        }

        // while statements with a single implicit 'if' substatement
        while( x )
        {
            if( x )
            {
                statement;
            }
        }

        // while with multiple statements
        while( x )
        {
            statement;

            statement;
        }

        // labeled statement
label:
        statement;

        // for statements with a single braced statement
        for ( x; x; x )
        {
            statement;
        }

        // do statements with a single braced substatement
        do
        {
            statement;
        }
        while ( false );

        // do statement with an empty block
        do
        {
        }
        while ( x );

        // local blocks
        {
            statement;
        }

        /* Switch blocks:
         *
         * You can have case substatements be aligned by giving an example like:
         *
         * case 1: statement;
         *
         *         statement;
         *
         *         statement;
         *
         *         etc...
         */
        switch( c )
        {
            case 1:
            case 2:
            case 3:
                statement;

                statement;

                statement;

            case 4:
                break; // case with exactly one substatement

            default:
                break;
        }
    }

    //------------------------------------------------------------------------------

    void method( const myClass<item>& x, int [][][] c, ... )
    {
        // try-catch-finally with empty bodies
        try
        {
        }
        catch(Throwable e)
        {
        }
        finally { }

        // try-catch-finally with exactly one statement
        try
        {
            statement;
        }
        catch( Throwable t )
        {
            statement;
        }
        finally {
            statement;
        }

        // try-catch-finally with multiple statements
        try
        {
            statement;

            statement;
        }
        catch( Throwable e )
        {
            statement;

            statement;
        }
        finally {
            statement;

            statement;

            statement;
        }
    }
};

// enum statement
static typedef enum x
{
    x,
    y,
    z,
};

// simple typedef
typedef interface static short int x;

namespace x
{
// template header
template <class T>
x y z v() const;

// pure virtual function, using c-style formal parameters with double parens
void v(()) = 0;

// function with one single line statement and c-style formal parameters
void v(( int i ))
{
    statement;
}

// function with no statements
myClass<myType>::method() {
}
}

template <T> class x
{
public:

    // operator declarations
    int operator +();

    int operator []();

    // template method
    static void A<x>::method() [][][]
    {
        asm
        {
            -Assembler statements -

            The outside braces are formatted but the asm code is passed through
            unchanged.
        }

        asm Single line assembler statements are also just passed through
    }

    extern void oldStyleFunction()
    int a;
    int b;
    int c; {
        // various simple statements
        long int a, b, c;

        long double [] i;

        goto x;

        delete [] x;

        delete [][][] x;

        return x;

        continue label;

        throw e;

        // c-style function calls with double parens
        b((a, b, c));

        a(());

        // expressions
        new Object()->field.method();

        s = "string"
            "split across lines";

        method(a, B::C, 'd');

        z = j[0][0][0] || k * 3 >> ++i + "0" > i++ & (i) == !j;

        int* v;

        int& v;

        x = x * *x;

        (int*)x;

        int (* functionPointer)( x, y, z );

        h[0] += a ? b : ((int)c).d;

        new Handler();
    }
} a, b, c; // struct instances

class Class2
{
/* Array creation with multiple non-array elements.
 *
 * If you give this example with the elements on the same line, then
 * Polystyle will automatically vertically align them into a grid when it
 * fits your code to the page. An alternate style is to have each
 * element on its own line, like this:
 * {
 * x,
 * y
 * z
 * }
 */
boolean* bools1 =
{
    x, y, z
};

// array creation with a single element
boolean bools2 = { x };

// array creation with no elements
boolean bools3 = { };

// multidimensional array creation
const int*** array =
{
    { 1, 2, 3 },
    { 1, 2, 3 },
    { 1, 2, 3 },
};
};

#if x

#define x

#elif a

#define x

#else

#define x

#define x

#define x

#endif

// see if multi line macros are safely handled:
#define multilinemacro do { x = x+5; } while (0); \
    printf("a multilinemacro"); \
    printf("a multilinemacro2");