text:
/*jslint onevar: false, plusplus: false */
/*

 JS Beautifier
---------------

  Written by Einar Lielmanis, <einar@jsbeautifier.org>
      http://jsbeautifier.org/

  Originally converted to javascript by Vital, <vital76@gmail.com>

  You are free to use this in any way you want, in case you find this useful or working for you.

  Usage:
    js_beautify(js_source_text);
    js_beautify(js_source_text, options);

  The options are:
    indent_size (default 4)          — indentation size,
    indent_char (default space)      — character to indent with,
    preserve_newlines (default true) — whether existing line breaks should be preserved,
    indent_level (default 0)         — initial indentation level, you probably won't need this ever,

    space_after_anon_function (default false) — if true, then space is added between "function ()"
            (jslint is happy about this); if false, then the common "function()" output is used.
    braces_on_own_line (default false) - ANSI / Allman brace style, each opening/closing brace gets its own line.

    e.g

    js_beautify(js_source_text, {indent_size: 1, indent_char: '\t'});

*/

function js_beautify(js_source_text, options) {

    var input, output, token_text, last_type, last_text, last_last_text, last_word, flags, flag_store, indent_string;
    var whitespace, wordchar, punct, parser_pos, line_starters, digits;
    var prefix, token_type, do_block_just_closed;
    var wanted_newline, just_added_newline, n_newlines;

    // Some interpreters have unexpected results with foo = baz || bar;
    options = options ? options : {};
    var opt_braces_on_own_line = options.braces_on_own_line ? options.braces_on_own_line : false;
    var opt_indent_size = options.indent_size ? options.indent_size : 4;
    var opt_indent_char = options.indent_char ? options.indent_char : ' ';
    var opt_preserve_newlines = typeof options.preserve_newlines === 'undefined' ? true : options.preserve_newlines;
    var opt_indent_level = options.indent_level ? options.indent_level : 0; // starting indentation
    var opt_space_after_anon_function = options.space_after_anon_function === 'undefined' ? false : options.space_after_anon_function;
    var opt_keep_array_indentation = typeof options.keep_array_indentation === 'undefined' ? false : options.keep_array_indentation;

    just_added_newline = false;

    // cache the source's length.
    var input_length = js_source_text.length;

    function trim_output() {
        while (output.length && (output[output.length - 1] === ' ' || output[output.length - 1] === indent_string)) {
            output.pop();
        }
    }

    function is_array(mode) {
        return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]';
    }

    function print_newline(ignore_repeated) {

        flags.eat_next_space = false;
        if (opt_keep_array_indentation && is_array(flags.mode)) {
            return;
        }

        ignore_repeated = typeof ignore_repeated === 'undefined' ? true : ignore_repeated;

        flags.if_line = false;
        trim_output();

        if (!output.length) {
            return; // no newline on start of file
        }

        if (output[output.length - 1] !== "\n" || !ignore_repeated) {
            just_added_newline = true;
            output.push("\n");
        }
        for (var i = 0; i < flags.indentation_level; i += 1) {
            output.push(indent_string);
        }
        if (flags.var_line && flags.var_line_reindented) {
            if (opt_indent_char === ' ') {
                output.push('    '); // var_line always pushes 4 spaces, so that the variables would be one under another
            } else {
                output.push(indent_string); // skip space-stuffing, if indenting with a tab
            }
        }
    }

    function print_single_space() {
        if (flags.eat_next_space) {
            flags.eat_next_space = false;
            return;
        }
        var last_output = ' ';
        if (output.length) {
            last_output = output[output.length - 1];
        }
        if (last_output !== ' ' && last_output !== '\n' && last_output !== indent_string) { // prevent occassional duplicate space
            output.push(' ');
        }
    }

    function print_token() {
        just_added_newline = false;
        flags.eat_next_space = false;
        output.push(token_text);
    }

    function indent() {
        flags.indentation_level += 1;
    }

    function remove_indent() {
        if (output.length && output[output.length - 1] === indent_string) {
            output.pop();
        }
    }

    function set_mode(mode) {
        if (flags) {
            flag_store.push(flags);
        }
        flags = {
            previous_mode: flags ? flags.mode : 'BLOCK',
            mode: mode,
            var_line: false,
            var_line_tainted: false,
            var_line_reindented: false,
            in_html_comment: false,
            if_line: false,
            in_case: false,
            eat_next_space: false,
            indentation_baseline: -1,
            indentation_level: (flags ? flags.indentation_level + ((flags.var_line && flags.var_line_reindented) ? 1 : 0) : opt_indent_level)
        };
    }

    function is_array(mode) {
        return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]';
    }

    function is_expression(mode) {
        return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]' || mode === '(EXPRESSION)';
    }

    function restore_mode() {
        do_block_just_closed = flags.mode === 'DO_BLOCK';
        if (flag_store.length > 0) {
            flags = flag_store.pop();
        }
    }

    function in_array(what, arr) {
        for (var i = 0; i < arr.length; i += 1) {
            if (arr[i] === what) {
                return true;
            }
        }
        return false;
    }

    // Walk backwards from the colon to find a '?' (colon is part of a ternary op)
    // or a '{' (colon is part of a class literal).  Along the way, keep track of
    // the blocks and expressions we pass so we only trigger on those chars in our
    // own level, and keep track of the colons so we only trigger on the matching '?'.

    function is_ternary_op() {
        var level = 0,
            colon_count = 0;
        for (var i = output.length - 1; i >= 0; i--) {
            switch (output[i]) {
            case ':':
                if (level === 0) {
                    colon_count++;
                }
                break;
            case '?':
                if (level === 0) {
                    if (colon_count === 0) {
                        return true;
                    } else {
                        colon_count--;
                    }
                }
                break;
            case '{':
                if (level === 0) {
                    return false;
                }
                level--;
                break;
            case '(':
            case '[':
                level--;
                break;
            case ')':
            case ']':
            case '}':
                level++;
                break;
            }
        }
    }

    function get_next_token() {
        n_newlines = 0;

        if (parser_pos >= input_length) {
            return ['', 'TK_EOF'];
        }

        wanted_newline = false;

        var c = input.charAt(parser_pos);
        parser_pos += 1;

        var keep_whitespace = opt_keep_array_indentation && is_array(flags.mode);

        if (keep_whitespace) {

            //
            // slight mess to allow nice preservation of array indentation and reindent that correctly
            // first time when we get to the arrays:
            // var a = [
            // ....'something'
            // we make note of whitespace_count = 4 into flags.indentation_baseline
            // so we know that 4 whitespaces in original source match indent_level of reindented source
            //
            // and afterwards, when we get to
            //    'something,
            // .......'something else'
            // we know that this should be indented to indent_level + (7 - indentation_baseline) spaces
            //
            var whitespace_count = 0;

            while (in_array(c, whitespace)) {

                if (c === "\n") {
                    trim_output();
                    output.push("\n");
                    just_added_newline = true;
                    whitespace_count = 0;
                } else {
                    if (c === '\t') {
                        whitespace_count += 4;
                    } else {
                        whitespace_count += 1;
                    }
                }

                if (parser_pos >= input_length) {
                    return ['', 'TK_EOF'];
                }

                c = input.charAt(parser_pos);
                parser_pos += 1;

            }
            if (flags.indentation_baseline === -1) {
                flags.indentation_baseline = whitespace_count;
            }

            if (just_added_newline) {
                var i;
                for (i = 0; i < flags.indentation_level + 1; i += 1) {
                    output.push(indent_string);
                }
                if (flags.indentation_baseline !== -1) {
                    for (i = 0; i < whitespace_count - flags.indentation_baseline; i++) {
                        output.push(' ');
                    }
                }
            }

        } else {
            while (in_array(c, whitespace)) {

                if (c === "\n") {
                    n_newlines += 1;
                }

                if (parser_pos >= input_length) {
                    return ['', 'TK_EOF'];
                }

                c = input.charAt(parser_pos);
                parser_pos += 1;

            }

            if (opt_preserve_newlines) {
                if (n_newlines > 1) {
                    for (i = 0; i < n_newlines; i += 1) {
                        print_newline(i === 0);
                        just_added_newline = true;
                    }
                }
            }
            wanted_newline = n_newlines > 0;
        }

        if (in_array(c, wordchar)) {
            if (parser_pos < input_length) {
                while (in_array(input.charAt(parser_pos), wordchar)) {
                    c += input.charAt(parser_pos);
                    parser_pos += 1;
                    if (parser_pos === input_length) {
                        break;
                    }
                }
            }

            // small and surprisingly unugly hack for 1E-10 representation
            if (parser_pos !== input_length && c.match(/^[0-9]+[Ee]$/) && (input.charAt(parser_pos) === '-' || input.charAt(parser_pos) === '+')) {

                var sign = input.charAt(parser_pos);
                parser_pos += 1;

                var t = get_next_token(parser_pos);
                c += sign + t[0];
                return [c, 'TK_WORD'];
            }

            if (c === 'in') { // hack for 'in' operator
                return [c, 'TK_OPERATOR'];
            }
            if (wanted_newline && last_type !== 'TK_OPERATOR' && !flags.if_line && (opt_preserve_newlines || last_text !== 'var')) {
                print_newline();
            }
            return [c, 'TK_WORD'];
        }

        if (c === '(' || c === '[') {
            return [c, 'TK_START_EXPR'];
        }

        if (c === ')' || c === ']') {
            return [c, 'TK_END_EXPR'];
        }

        if (c === '{') {
            return [c, 'TK_START_BLOCK'];
        }

        if (c === '}') {
            return [c, 'TK_END_BLOCK'];
        }

        if (c === ';') {
            return [c, 'TK_SEMICOLON'];
        }

        if (c === '/') {
            var comment = '';
            // peek for comment /* ... */
            var inline_comment = true;
            if (input.charAt(parser_pos) === '*') {
                parser_pos += 1;
                if (parser_pos < input_length) {
                    while (! (input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/') && parser_pos < input_length) {
                        c = input.charAt(parser_pos);
                        comment += c;
                        if (c === '\x0d' || c === '\x0a') {
                            inline_comment = false;
                        }
                        parser_pos += 1;
                        if (parser_pos >= input_length) {
                            break;
                        }
                    }
                }
                parser_pos += 2;
                if (inline_comment) {
                    return ['/*' + comment + '*/', 'TK_INLINE_COMMENT'];
                } else {
                    return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT'];
                }
            }
            // peek for comment // ...
            if (input.charAt(parser_pos) === '/') {
                comment = c;
                while (input.charAt(parser_pos) !== "\x0d" && input.charAt(parser_pos) !== "\x0a") {
                    comment += input.charAt(parser_pos);
                    parser_pos += 1;
                    if (parser_pos >= input_length) {
                        break;
                    }
                }
                parser_pos += 1;
                if (wanted_newline) {
                    print_newline();
                }
                return [comment, 'TK_COMMENT'];
            }

        }

        if (c === "'" || // string
        c === '"' || // string
        (c === '/' && ((last_type === 'TK_WORD' && in_array(last_text, ['return', 'do'])) || (last_type === 'TK_START_EXPR' || last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK' || last_type === 'TK_OPERATOR' || last_type === 'TK_EQUALS' || last_type === 'TK_EOF' || last_type === 'TK_SEMICOLON')))) { // regexp
            var sep = c;
            var esc = false;
            var resulting_string = c;

            if (parser_pos < input_length) {
                if (sep === '/') {
                    //
                    // handle regexp separately...
                    //
                    var in_char_class = false;
                    while (esc || in_char_class || input.charAt(parser_pos) !== sep) {
                        resulting_string += input.charAt(parser_pos);
                        if (!esc) {
                            esc = input.charAt(parser_pos) === '\\';
                            if (input.charAt(parser_pos) === '[') {
                                in_char_class = true;
                            } else if (input.charAt(parser_pos) === ']') {
                                in_char_class = false;
                            }
                        } else {
                            esc = false;
                        }
                        parser_pos += 1;
                        if (parser_pos >= input_length) {
                            // incomplete string/rexp when end-of-file reached.
                            // bail out with what had been received so far.
                            return [resulting_string, 'TK_STRING'];
                        }
                    }

                } else {
                    //
                    // and handle string also separately
                    //
                    while (esc || input.charAt(parser_pos) !== sep) {
                        resulting_string += input.charAt(parser_pos);
                        if (!esc) {
                            esc = input.charAt(parser_pos) === '\\';
                        } else {
                            esc = false;
                        }
                        parser_pos += 1;
                        if (parser_pos >= input_length) {
                            // incomplete string/rexp when end-of-file reached.
                            // bail out with what had been received so far.
                            return [resulting_string, 'TK_STRING'];
                        }
                    }
                }

            }

            parser_pos += 1;

            resulting_string += sep;

            if (sep === '/') {
                // regexps may have modifiers /regexp/MOD , so fetch those, too
                while (parser_pos < input_length && in_array(input.charAt(parser_pos), wordchar)) {
                    resulting_string += input.charAt(parser_pos);
                    parser_pos += 1;
                }
            }
            return [resulting_string, 'TK_STRING'];
        }

        if (c === '#') {
            // Spidermonkey-specific sharp variables for circular references
            // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
            // http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
            var sharp = '#';
            if (parser_pos < input_length && in_array(input.charAt(parser_pos), digits)) {
                do {
                    c = input.charAt(parser_pos);
                    sharp += c;
                    parser_pos += 1;
                } while (parser_pos < input_length && c !== '#' && c !== '=');
                if (c === '#') {
                    //
                } else if (input.charAt(parser_pos) === '[' && input.charAt(parser_pos + 1) === ']') {
                    sharp += '[]';
                    parser_pos += 2;
                } else if (input.charAt(parser_pos) === '{' && input.charAt(parser_pos + 1) === '}') {
                    sharp += '{}';
                    parser_pos += 2;
                }
                return [sharp, 'TK_WORD'];
            }
        }

        if (c === '<' && input.substring(parser_pos - 1, parser_pos + 3) === '<!--') {
            parser_pos += 3;
            flags.in_html_comment = true;
            return ['<!--', 'TK_COMMENT'];
        }

        if (c === '-' && flags.in_html_comment && input.substring(parser_pos - 1, parser_pos + 2) === '-->') {
            flags.in_html_comment = false;
            parser_pos += 2;
            if (wanted_newline) {
                print_newline();
            }
            return ['-->', 'TK_COMMENT'];
        }

        if (in_array(c, punct)) {
            while (parser_pos < input_length && in_array(c + input.charAt(parser_pos), punct)) {
                c += input.charAt(parser_pos);
                parser_pos += 1;
                if (parser_pos >= input_length) {
                    break;
                }
            }

            if (c === '=') {
                return [c, 'TK_EQUALS'];
            } else {
                return [c, 'TK_OPERATOR'];
            }
        }

        return [c, 'TK_UNKNOWN'];
    }

    //----------------------------------
    indent_string = '';
    while (opt_indent_size > 0) {
        indent_string += opt_indent_char;
        opt_indent_size -= 1;
    }

    input = js_source_text;

    last_word = ''; // last 'TK_WORD' passed
    last_type = 'TK_START_EXPR'; // last token type
    last_text = ''; // last token text
    last_last_text = ''; // pre-last token text
    output = [];

    do_block_just_closed = false;

    whitespace = "\n\r\t ".split('');
    wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split('');
    digits = '0123456789'.split('');

    punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::'.split(' ');

    // words which should always start on new line.
    line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(',');

    // states showing if we are currently in expression (i.e. "if" case) - 'EXPRESSION', or in usual block (like, procedure), 'BLOCK'.
    // some formatting depends on that.
    flag_store = [];
    set_mode('BLOCK');

    parser_pos = 0;
    while (true) {
        var t = get_next_token(parser_pos);
        token_text = t[0];
        token_type = t[1];
        if (token_type === 'TK_EOF') {
            break;
        }

        switch (token_type) {

        case 'TK_START_EXPR':

            if (token_text === '[') {

                if (last_type === 'TK_WORD' || last_text === ')') {
                    // this is array index specifier, break immediately
                    // a[x], fn()[x]
                    if (in_array(last_text, line_starters)) {
                        print_single_space();
                    }
                    set_mode('(EXPRESSION)');
                    print_token();
                    break;
                }

                if (flags.mode === '[EXPRESSION]' || flags.mode === '[INDENTED-EXPRESSION]') {
                    if (last_last_text === ']' && last_text === ',') {
                        // ], [ goes to new line
                        if (flags.mode === '[EXPRESSION]') {
                            flags.mode = '[INDENTED-EXPRESSION]';
                            if (!opt_keep_array_indentation) {
                                indent();
                            }
                        }
                        set_mode('[EXPRESSION]');
                        if (!opt_keep_array_indentation) {
                            print_newline();
                        }
                    } else if (last_text === '[') {
                        if (flags.mode === '[EXPRESSION]') {
                            flags.mode = '[INDENTED-EXPRESSION]';
                            if (!opt_keep_array_indentation) {
                                indent();
                            }
                        }
                        set_mode('[EXPRESSION]');

                        if (!opt_keep_array_indentation) {
                            print_newline();
                        }
                    } else {
                        set_mode('[EXPRESSION]');
                    }
                } else {
                    set_mode('[EXPRESSION]');
                }

            } else {
                set_mode('(EXPRESSION)');
            }

            if (last_text === ';' || last_type === 'TK_START_BLOCK') {
                print_newline();
            } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || last_text === '.') {
                // do nothing on (( and )( and ][ and ]( and .(
            } else if (last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') {
                print_single_space();
            } else if (last_word === 'function') {
                // function() vs function ()
                if (opt_space_after_anon_function) {
                    print_single_space();
                }
            } else if (in_array(last_text, line_starters) || last_text === 'catch') {
                print_single_space();
            }
            print_token();

            break;

        case 'TK_END_EXPR':
            if (token_text === ']') {
                if (opt_keep_array_indentation) {
                    if (last_text === '}') {
                        // trim_output();
                        // print_newline(true);
                        remove_indent();
                        print_token();
                        restore_mode();
                        break;
                    }
                } else {
                    if (flags.mode === '[INDENTED-EXPRESSION]') {
                        if (last_text === ']') {
                            restore_mode();
                            print_newline();
                            print_token();
                            break;
                        }
                    }
                }
            }
            restore_mode();
            print_token();
            break;

        case 'TK_START_BLOCK':

            if (last_word === 'do') {
                set_mode('DO_BLOCK');
            } else {
                set_mode('BLOCK');
            }
            if (opt_braces_on_own_line) {
                if (last_type !== 'TK_OPERATOR') {
                    if (last_text == 'return') {
                        print_single_space();
                    } else {
                        print_newline(true);
                    }
                }
                print_token();
                indent();
            } else {
                if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
                    if (last_type === 'TK_START_BLOCK') {
                        print_newline();
                    } else {
                        print_single_space();
                    }
                } else {
                    // if TK_OPERATOR or TK_START_EXPR
                    if (is_array(flags.previous_mode) && last_text === ',') {
                        print_newline(); // [a, b, c, {
                    }
                }
                indent();
                print_token();
            }

            break;

        case 'TK_END_BLOCK':
            restore_mode();
            if (opt_braces_on_own_line) {
                print_newline();
                print_token();
            } else {
                if (last_type === 'TK_START_BLOCK') {
                    // nothing
                    if (just_added_newline) {
                        remove_indent();
                    } else {
                        // {}
                        trim_output();
                    }
                } else {
                    print_newline();
                }
                print_token();
            }
            break;

        case 'TK_WORD':

            // no, it's not you. even I have problems understanding how this works
            // and what does what.
            if (do_block_just_closed) {
                // do {} ## while ()
                print_single_space();
                print_token();
                print_single_space();
                do_block_just_closed = false;
                break;
            }

            if (token_text === 'function') {
                if ((just_added_newline || last_text === ';') && last_text !== '{') {
                    // make sure there is a nice clean space of at least one blank line
                    // before a new function definition
                    n_newlines = just_added_newline ? n_newlines : 0;

                    for (var i = 0; i < 2 - n_newlines; i++) {
                        print_newline(false);
                    }

                }
            }

            if (token_text === 'case' || token_text === 'default') {
                if (last_text === ':') {
                    // switch cases following one another
                    remove_indent();
                } else {
                    // case statement starts in the same line where switch
                    flags.indentation_level--;
                    print_newline();
                    flags.indentation_level++;
                }
                print_token();
                flags.in_case = true;
                break;
            }

            prefix = 'NONE';

            if (last_type === 'TK_END_BLOCK') {
                if (!in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
                    prefix = 'NEWLINE';
                } else {
                    if (opt_braces_on_own_line) {
                        prefix = 'NEWLINE';
                    } else {
                        prefix = 'SPACE';
                        print_single_space();
                    }
                }
            } else if (last_type === 'TK_SEMICOLON' && (flags.mode === 'BLOCK' || flags.mode === 'DO_BLOCK')) {
                prefix = 'NEWLINE';
            } else if (last_type === 'TK_SEMICOLON' && is_expression(flags.mode)) {
                prefix = 'SPACE';
            } else if (last_type === 'TK_STRING') {
                prefix = 'NEWLINE';
            } else if (last_type === 'TK_WORD') {
                prefix = 'SPACE';
            } else if (last_type === 'TK_START_BLOCK') {
                prefix = 'NEWLINE';
            } else if (last_type === 'TK_END_EXPR') {
                print_single_space();
                prefix = 'NEWLINE';
            }

            if (last_type !== 'TK_END_BLOCK' && in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
                print_newline();
            } else if (in_array(token_text, line_starters) || prefix === 'NEWLINE') {
                if (last_text === 'else') {
                    // no need to force newline on else break
                    print_single_space();
                } else if ((last_type === 'TK_START_EXPR' || last_text === '=' || last_text === ',') && token_text === 'function') {
                    // no need to force newline on 'function': (function
                    // DONOTHING
                } else if (last_text === 'return' || last_text === 'throw') {
                    // no newline between 'return nnn'
                    print_single_space();
                } else if (last_type !== 'TK_END_EXPR') {
                    if ((last_type !== 'TK_START_EXPR' || token_text !== 'var') && last_text !== ':') {
                        // no need to force newline on 'var': for (var x = 0...)
                        if (token_text === 'if' && last_word === 'else' && last_text !== '{') {
                            // no newline for } else if {
                            print_single_space();
                        } else {
                            print_newline();
                        }
                    }
                } else {
                    if (in_array(token_text, line_starters) && last_text !== ')') {
                        print_newline();
                    }
                }
            } else if (is_array(flags.mode) && last_text === ',' && last_last_text === '}') {
                print_newline(); // }, in lists get a newline treatment
            } else if (prefix === 'SPACE') {
                print_single_space();
            }
            print_token();
            last_word = token_text;

            if (token_text === 'var') {
                flags.var_line = true;
                flags.var_line_reindented = false;
                flags.var_line_tainted = false;
            }

            if (token_text === 'if' || token_text === 'else') {
                flags.if_line = true;
            }

            break;

        case 'TK_SEMICOLON':

            print_token();
            flags.var_line = false;
            flags.var_line_reindented = false;
            break;

        case 'TK_STRING':

            if (last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK' || last_type === 'TK_SEMICOLON') {
                print_newline();
            } else if (last_type === 'TK_WORD') {
                print_single_space();
            }
            print_token();
            break;

        case 'TK_EQUALS':
            if (flags.var_line) {
                // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
                flags.var_line_tainted = true;
            }
            print_single_space();
            print_token();
            print_single_space();
            break;

        case 'TK_OPERATOR':

            var space_before = true;
            var space_after = true;

            if (flags.var_line && token_text === ',' && (is_expression(flags.mode))) {
                // do not break on comma, for(var a = 1, b = 2)
                flags.var_line_tainted = false;
            }

            if (flags.var_line) {
                if (token_text === ',') {
                    if (flags.var_line_tainted) {
                        print_token();
                        flags.var_line_reindented = true;
                        flags.var_line_tainted = false;
                        print_newline();
                        break;
                    } else {
                        flags.var_line_tainted = false;
                    }
                // } else if (token_text === ':') {
                    // hmm, when does this happen? tests don't catch this
                    // flags.var_line = false;
                }
            }

            if (last_text === 'return' || last_text === 'throw') {
                // "return" had a special handling in TK_WORD. Now we need to return the favor
                print_single_space();
                print_token();
                break;
            }

            if (token_text === ':' && flags.in_case) {
                print_token(); // colon really asks for separate treatment
                print_newline();
                flags.in_case = false;
                break;
            }

            if (token_text === '::') {
                // no spaces around exotic namespacing syntax operator
                print_token();
                break;
            }

            if (token_text === ',') {
                if (flags.var_line) {
                    if (flags.var_line_tainted) {
                        print_token();
                        print_newline();
                        flags.var_line_tainted = false;
                    } else {
                        print_token();
                        print_single_space();
                    }
                } else if (last_type === 'TK_END_BLOCK' && flags.mode !== "(EXPRESSION)") {
                    print_token();
                    if (flags.mode === 'OBJECT' && last_text === '}') {
                        print_newline();
                    } else {
                        print_single_space();
                    }
                } else {
                    if (flags.mode === 'OBJECT') {
                        print_token();
                        print_newline();
                    } else {
                        // EXPR or DO_BLOCK
                        print_token();
                        print_single_space();
                    }
                }
                break;
            // } else if (in_array(token_text, ['--', '++', '!']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS']) || in_array(last_text, line_starters) || in_array(last_text, ['==', '!=', '+=', '-=', '*=', '/=', '+', '-'])))) {
            } else if (in_array(token_text, ['--', '++', '!']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || in_array(last_text, line_starters)))) {
                // unary operators (and binary +/- pretending to be unary) special cases

                space_before = false;
                space_after = false;

                if (last_text === ';' && is_expression(flags.mode)) {
                    // for (;; ++i)
                    //        ^^^
                    space_before = true;
                }
                if (last_type === 'TK_WORD' && in_array(last_text, line_starters)) {
                    space_before = true;
                }

                if (flags.mode === 'BLOCK' && (last_text === '{' || last_text === ';')) {
                    // { foo; --i }
                    // foo(); --bar;
                    print_newline();
                }
            } else if (token_text === '.') {
                // decimal digits or object.property
                space_before = false;

            } else if (token_text === ':') {
                if (!is_ternary_op()) {
                    flags.mode = 'OBJECT';
                    space_before = false;
                }
            }
            if (space_before) {
                print_single_space();
            }

            print_token();

            if (space_after) {
                print_single_space();
            }

            if (token_text === '!') {
                // flags.eat_next_space = true;
            }

            break;

        case 'TK_BLOCK_COMMENT':

            var lines = token_text.split(/\x0a|\x0d\x0a/);

            if (/^\/\*\*/.test(token_text)) {
                // javadoc: reformat and reindent
                print_newline();
                output.push(lines[0]);
                for (i = 1; i < lines.length; i++) {
                    print_newline();
                    output.push(' ');
                    output.push(lines[i].replace(/^\s\s*|\s\s*$/, ''));
                }

            } else {
                // simple block comment: leave intact
                if (lines.length > 1) {
                    // multiline comment block starts with a new line
                    print_newline();
                    trim_output();
                } else {
                    // single-line /* comment */ stays where it is
                    print_single_space();
                }
                for (i = 0; i < lines.length; i++) {
                    output.push(lines[i]);
                    output.push('\n');
                }

            }
            print_newline();
            break;

        case 'TK_INLINE_COMMENT':

            print_single_space();
            print_token();
            if (is_expression(flags.mode)) {
                print_single_space();
            } else {
                print_newline();
            }
            break;

        case 'TK_COMMENT':

            // print_newline();
            if (wanted_newline) {
                print_newline();
            } else {
                print_single_space();
            }
            print_token();
            print_newline();
            break;

        case 'TK_UNKNOWN':
            print_token();
            break;
        }

        last_last_text = last_text;
        last_type = token_type;
        last_text = token_text;
    }

    return output.join('').replace(/[\n ]+$/, '');

}

// Add support for CommonJS. Just put this file somewhere on your require.paths
// and you will be able to `var js_beautify = require("beautify").js_beautify`.
if (typeof exports !== "undefined")
    exports.js_beautify = js_beautify;


text:
package gov.hhs.fha.nhinc.patientdiscovery.entity.deferred.response;

import gov.hhs.fha.nhinc.common.nhinccommon.AssertionType;
import gov.hhs.fha.nhinc.common.nhinccommon.NhinTargetSystemType;
import gov.hhs.fha.nhinc.nhinclib.NhincConstants;
import gov.hhs.fha.nhinc.orchestration.AuditTransformer;
import gov.hhs.fha.nhinc.orchestration.NhinAggregator;
import gov.hhs.fha.nhinc.orchestration.OutboundDelegate;
import gov.hhs.fha.nhinc.orchestration.OutboundOrchestratable;
import gov.hhs.fha.nhinc.orchestration.PolicyTransformer;

import org.hl7.v3.MCCIIN000002UV01;
import org.hl7.v3.PRPAIN201306UV02;

/**
 * @author akong
 *
 */
public class OutboundPatientDiscoveryDeferredResponseOrchestratable implements OutboundOrchestratable {

    protected NhinTargetSystemType target = null;
    private AssertionType assertion = null;
    private OutboundDelegate nhinDelegate = null;
    private PRPAIN201306UV02 request = null;
    private MCCIIN000002UV01 response = null;

    public OutboundPatientDiscoveryDeferredResponseOrchestratable(OutboundDelegate delegate) {
        this.nhinDelegate = delegate;
    }

    public OutboundPatientDiscoveryDeferredResponseOrchestratable(OutboundDelegate delegate, PRPAIN201306UV02 request,
            NhinTargetSystemType target, AssertionType assertion) {
        this(delegate);
        this.assertion = assertion;
        this.request = request;
        this.target = target;
    }

    @Override
    public OutboundDelegate getDelegate() {
        return getNhinDelegate();
    }

    public OutboundDelegate getNhinDelegate() {
        return nhinDelegate;
    }

    @Override
    public NhinAggregator getAggregator() {
        throw new UnsupportedOperationException("Patient Discovery Deferred Req does not support aggregation.");
    }

    public AssertionType getAssertion() {
        return assertion;
    }

    public void setAssertion(AssertionType assertion) {
        this.assertion = assertion;
    }

    public PRPAIN201306UV02 getRequest() {
        return request;
    }

    public void setRequest(PRPAIN201306UV02 request) {
        this.request = request;
    }

    public MCCIIN000002UV01 getResponse() {
        return response;
    }

    public void setResponse(MCCIIN000002UV01 response) {
        this.response = response;
    }

    public NhinTargetSystemType getTarget() {
        return target;
    }

    public void setTarget(NhinTargetSystemType target) {
        this.target = target;
    }

    public String getServiceName() {
        return NhincConstants.PATIENT_DISCOVERY_DEFERRED_RESP_SERVICE_NAME;
    }

    public boolean isPassthru() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public AuditTransformer getAuditTransformer() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public PolicyTransformer getPolicyTransformer() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

}

redpajama_set_name: RedPajamaGithub


text:
O2.createClass('O876.Snail', {
	/**
	 * Renvoie la largeur d'un carré de snail selon le niveau
	 * @param nLevel niveau
	 * @return int nombre d'élément sur le coté
	 */
	getLevelSquareWidth: function(nLevel) {
		return nLevel * 2 + 1;
	},

	/**
	 * Renvoie le nombre d'élément qu'il y a dans un niveau
	 * @param nLevel niveau
	 * @return int nombre d'élément
	 */
	getLevelItemCount: function(nLevel) {
		var w = this.getLevelSquareWidth(nLevel);
		return 4 * w - 4;
	},

	/**
	 * Renvoie le niveau auquel appartient ce secteur
	 * le niveau 0 correspond au point 0, 0
	 */
	getLevel: function(x, y) {
		x = Math.abs(x);
		y = Math.abs(y);
		return Math.max(x, y);
	},

	/**
	 * Renvoie tous les secteur de niveau spécifié
	 */
	crawl: function(nLevelMin, nLevelMax) {
		if (nLevelMax === undefined) {
			nLevelMax = nLevelMin;
		}
		if (nLevelMin > nLevelMax) {
			throw new Error('levelMin must be lower or equal levelMax');
		}
		if (nLevelMin < 0) {
			return [];
		}
		var aSectors = [];
		var n, x, y;
		for (y = -nLevelMax; y <= nLevelMax; ++y) {
			for (x = -nLevelMax; x <= nLevelMax; ++x) {
				n = this.getLevel(x, y);
				if (n >= nLevelMin && n <= nLevelMax) {
					aSectors.push({x: x, y: y});
				}
			}
		}
		return aSectors;
	}

});


text:
module Booknize
  module Crawler
    class WwwAsahiCom < Base
      CONTENT = {h1: '.ArticleTitle h1', div: '.ArticleText > p', :'div.LastUpdated' => '.LastUpdated'}
    end
  end
end


text:
<?php

declare(strict_types = 1);

namespace PHPWebSockets;

use Psr\Log\LoggerInterface;

trait TLogAware {

    /**
     * The logger
     *
     * @var \Psr\Log\LoggerInterface|null
     */
    protected $_logger = NULL;

    /**
     * Sets the logger
     *
     * @param \Psr\Log\LoggerInterface $logger
     *
     * @return void
     */
    public function setLogger(LoggerInterface $logger) : void {
        $this->_logger = $logger;
    }

    /**
     * Returns the logger to use
     *
     * @return \Psr\Log\LoggerInterface
     */
    public function getLogger() : LoggerInterface {

        if ($this->_logger === NULL) {
            return \PHPWebSockets::GetLogger();
        }

        return $this->_logger;
    }

    /**
     * Logs a message to set logger
     *
     * @param string $level
     * @param string $message
     * @param array  $context
     *
     * @return void
     */
    protected function _log(string $level, string $message, array $context = []) : void {

        $this->getLogger()->log($level, $message, array_merge([
            'subject' => $this,
        ], $context));

    }
}


text:
from google.cloud import channel_v1

def sample_get_channel_partner_repricing_config():
    # Create a client
    client = channel_v1.CloudChannelServiceClient()

    # Initialize request argument(s)
    request = channel_v1.GetChannelPartnerRepricingConfigRequest(
        name="name_value",
    )

    # Make the request
    response = client.get_channel_partner_repricing_config(request=request)

    # Handle the response
    print(response)

# [END cloudchannel_v1_generated_CloudChannelService_GetChannelPartnerRepricingConfig_sync]


text:
package org.jsapar.compose.fixed;

import org.jsapar.compose.cell.CellFormat;
import org.jsapar.compose.fixed.pad.Pad;
import org.jsapar.model.Cell;
import org.jsapar.schema.FixedWidthSchemaCell;

import java.io.IOException;
import java.io.Writer;

/**
 * Composes fixed width output on cell level.
 */
class FixedWidthCellComposer {

    private final CellFormat           cellFormat;
    private final FixedWidthSchemaCell schemaCell;
    private final Pad                  pad;

    FixedWidthCellComposer(FixedWidthSchemaCell schemaCell) {
        this.cellFormat = CellFormat.ofSchemaCell(schemaCell);
        this.schemaCell = schemaCell;
        this.pad = Pad.ofAlignment(schemaCell.getAlignment(), schemaCell.getPadCharacter(), schemaCell.getLength());
    }

    /**
     * Writes a cell to the supplied writer using supplied fill character.
     *
     * @param writer     The writer to write to.
     * @param cell       The cell to write
     * @throws IOException If there is an error writing characters
     * @return The length of the cell written.
     */
    int compose(Writer writer, Cell cell) throws IOException {
        final String sValue = cellFormat.format(cell);
        compose(writer, sValue, schemaCell.getPadCharacter(), schemaCell.getLength(), schemaCell.getAlignment());
        return schemaCell.getLength();
    }

    /**
     * Writes a cell to the supplied writer using supplied fill character.
     *
     *
     * @param writer     The writer to write to.
     * @param sValue
     *            The value to write
     * @param fillCharacter
     *            The fill character to fill empty spaces.
     * @param length
     *            The number of characters to write.
     * @param alignment
     *            The alignment of the cell content if the content is smaller than the cell length.
     * @throws IOException If there is an error writing characters
     */
    private void compose(Writer writer, String sValue, char fillCharacter, int length, FixedWidthSchemaCell.Alignment alignment)
            throws IOException{
        if (sValue.length() == length) {
            writer.write(sValue);
        } else if (sValue.length() > length) {
            // If the cell value is larger than the cell length, we have to cut the value.
            pad.fit(writer, sValue);
        } else {
            pad.pad(writer, sValue);
        }
    }

    public String getName() {
        return schemaCell.getName();
    }

    public Cell makeEmptyCell() {
        return schemaCell.makeEmptyCell();
    }
}


text:
/**
 * SOAPStruct.java
 *
 * This file was auto-generated from WSDL
 * by the Apache Axis WSDL2Java emitter.
 */

package org.apache.geronimo.axis.builder.interop.types;

public class SOAPStruct  implements java.io.Serializable {
    private java.lang.String varString;
    private int varInt;
    private float varFloat;

    public SOAPStruct() {
    }

    public java.lang.String getVarString() {
        return varString;
    }

    public void setVarString(java.lang.String varString) {
        this.varString = varString;
    }

    public int getVarInt() {
        return varInt;
    }

    public void setVarInt(int varInt) {
        this.varInt = varInt;
    }

    public float getVarFloat() {
        return varFloat;
    }

    public void setVarFloat(float varFloat) {
        this.varFloat = varFloat;
    }

    private java.lang.Object __equalsCalc = null;
    public synchronized boolean equals(java.lang.Object obj) {
        if (!(obj instanceof SOAPStruct)) return false;
        SOAPStruct other = (SOAPStruct) obj;
        if (obj == null) return false;
        if (this == obj) return true;
        if (__equalsCalc != null) {
            return (__equalsCalc == obj);
        }
        __equalsCalc = obj;
        boolean _equals;
        _equals = true &&
            ((this.varString==null && other.getVarString()==null) ||
             (this.varString!=null &&
              this.varString.equals(other.getVarString()))) &&
            this.varInt == other.getVarInt() &&
            this.varFloat == other.getVarFloat();
        __equalsCalc = null;
        return _equals;
    }

    private boolean __hashCodeCalc = false;
    public synchronized int hashCode() {
        if (__hashCodeCalc) {
            return 0;
        }
        __hashCodeCalc = true;
        int _hashCode = 1;
        if (getVarString() != null) {
            _hashCode += getVarString().hashCode();
        }
        _hashCode += getVarInt();
        _hashCode += new Float(getVarFloat()).hashCode();
        __hashCodeCalc = false;
        return _hashCode;
    }

    // Type metadata
    private static org.apache.axis.description.TypeDesc typeDesc =
        new org.apache.axis.description.TypeDesc(SOAPStruct.class);

    static {
        typeDesc.setXmlType(new javax.xml.namespace.QName("http://tempuri.org/4s4c/1/3/wsdl/types/", "SOAPStruct"));
        org.apache.axis.description.ElementDesc elemField = new org.apache.axis.description.ElementDesc();
        elemField.setFieldName("varString");
        elemField.setXmlName(new javax.xml.namespace.QName("", "varString"));
        elemField.setXmlType(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "string"));
        typeDesc.addFieldDesc(elemField);
        elemField = new org.apache.axis.description.ElementDesc();
        elemField.setFieldName("varInt");
        elemField.setXmlName(new javax.xml.namespace.QName("", "varInt"));
        elemField.setXmlType(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "int"));
        typeDesc.addFieldDesc(elemField);
        elemField = new org.apache.axis.description.ElementDesc();
        elemField.setFieldName("varFloat");
        elemField.setXmlName(new javax.xml.namespace.QName("", "varFloat"));
        elemField.setXmlType(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema", "float"));
        typeDesc.addFieldDesc(elemField);
    }

    /**
     * Return type metadata object
     */
    public static org.apache.axis.description.TypeDesc getTypeDesc() {
        return typeDesc;
    }

    /**
     * Get Custom Serializer
     */
    public static org.apache.axis.encoding.Serializer getSerializer(
           java.lang.String mechType,
           java.lang.Class _javaType,
           javax.xml.namespace.QName _xmlType) {
        return
          new  org.apache.axis.encoding.ser.BeanSerializer(
            _javaType, _xmlType, typeDesc);
    }

    /**
     * Get Custom Deserializer
     */
    public static org.apache.axis.encoding.Deserializer getDeserializer(
           java.lang.String mechType,
           java.lang.Class _javaType,
           javax.xml.namespace.QName _xmlType) {
        return
          new  org.apache.axis.encoding.ser.BeanDeserializer(
            _javaType, _xmlType, typeDesc);
    }

}


text:
/*
 * GET home page.
 */

var conf = require('../config'), logger = require('tracer')[conf.log.strategy](conf.log.setting);

exports.index = function(req, res, next) {
	logger.debug('index');
	res.render('index', {
		title : 'Express'
	})
};


text:
This directory contains information regarding the current revision and should
be ignored.


text:
module Exlibris
  module Aleph
    module Table
      module Patron
        class CirculationPolicies < Table::Base
          def all
            @all ||= begin
              Hash[
                admin_libraries.map do |admin_library|
                  [admin_library, Reader::PatronCirculationPolicies.new(admin_library).all]
                end
              ]
            end
          end

          def find_by_identifier(identifier)
            unless identifier.is_a?(Aleph::Patron::CirculationPolicy::Identifier)
              raise ArgumentError.new("Expecting #{identifier} to be a CirculationPolicy::Identifier")
            end
            sub_library = identifier.sub_library
            circulation_policy = _find_by_identifier(identifier)
            # Try with a "generic" patron status
            if circulation_policy.nil?
              generic_status_identifier =
                Aleph::Patron::CirculationPolicy::Identifier.new(generic_status, sub_library)
              circulation_policy = _find_by_identifier(generic_status_identifier)
            end
            circulation_policy
          end

          private
          def generic_status
            @generic_status ||= Aleph::Patron::Status.new('##')
          end

          def _find_by_identifier(identifier)
            sub_library = identifier.sub_library
            admin_library = sub_library.admin_library
            all[admin_library].find do |circulation_policy|
              circulation_policy.identifier == identifier
            end
          end
        end
      end
    end
  end
end


text:
import { IReduxState, IStore } from '../../app/types';

export type IStateful = Function | IStore | IReduxState;


text:
describe('String helper', function () {
  //
  // Handsontable.helper.equalsIgnoreCase
  //
  describe('equalsIgnoreCase', function() {
    it("should correct equals strings", function () {
      expect(Handsontable.helper.equalsIgnoreCase()).toEqual(false);
      expect(Handsontable.helper.equalsIgnoreCase('', '')).toEqual(true);
      expect(Handsontable.helper.equalsIgnoreCase('True', 'TRUE', 'TrUe', true)).toEqual(true);
      expect(Handsontable.helper.equalsIgnoreCase('FALSE', 'false')).toEqual(true);

      expect(Handsontable.helper.equalsIgnoreCase('True', 'TRUE', false)).toEqual(false);
      expect(Handsontable.helper.equalsIgnoreCase('fals e', false)).toEqual(false);
    });
  });

  //
  // Handsontable.helper.startsWith
  //
  describe('startsWith', function() {
    it("should properly recognize whether a string begins with the characters", function() {
      expect(Handsontable.helper.startsWith('', '')).toBe(true);
      expect(Handsontable.helper.startsWith('Base string', '')).toBe(true);
      expect(Handsontable.helper.startsWith('Base string', 'B')).toBe(true);
      expect(Handsontable.helper.startsWith('Base string', 'Base')).toBe(true);
      expect(Handsontable.helper.startsWith('Base string', 'Base string')).toBe(true);

      expect(Handsontable.helper.startsWith('Base string', 'b')).toBe(false);
      expect(Handsontable.helper.startsWith('Base string', 'ase')).toBe(false);
      expect(Handsontable.helper.startsWith('Base string', 'g')).toBe(false);
      expect(Handsontable.helper.startsWith('Base string', '1')).toBe(false);
    });
  });

  //
  // Handsontable.helper.endsWith
  //
  describe('endsWith', function() {
    it("should properly recognize whether a string ends with the characters", function() {
      expect(Handsontable.helper.endsWith('', '')).toBe(true);
      expect(Handsontable.helper.endsWith('Base string', '')).toBe(true);
      expect(Handsontable.helper.endsWith('Base string', 'g')).toBe(true);
      expect(Handsontable.helper.endsWith('Base string', 'ing')).toBe(true);
      expect(Handsontable.helper.endsWith('Base string', 'Base string')).toBe(true);

      expect(Handsontable.helper.endsWith('Base string', 'G')).toBe(false);
      expect(Handsontable.helper.endsWith('Base string', 'strin')).toBe(false);
      expect(Handsontable.helper.endsWith('Base string', 'B')).toBe(false);
      expect(Handsontable.helper.endsWith('Base string', '1')).toBe(false);
    });
  });

  //
  // Handsontable.helper.substitute
  //
  describe('substitute', function() {
    it("should properly substitute string to specified values", function() {
      var substitute = Handsontable.helper.substitute;
      var vars = {
        zero: 0,
        empty: '',
        undef: void 0,
        string1: 'foo;',
        string2: 'foo\nbar',
      };

      expect(substitute('', vars)).toBe('');
      expect(substitute('[zero]', vars)).toBe('0');
      expect(substitute('[zero][zero]', vars)).toBe('00');
      expect(substitute('[empty][zero][string1]', vars)).toBe('0foo;');
      expect(substitute('BAZ [string2] test', vars)).toBe('BAZ foo\nbar test');
      expect(substitute('1[undef]', vars)).toBe('1');
    });
  });

  //
  // Handsontable.helper.padStart
  //
  describe('padStart', function() {
    it("should properly add leading chars at the begining of the string", function() {
      var padStart = Handsontable.helper.padStart;

      expect(padStart('x', 5, 'ab')).toBe('ababx');
      expect(padStart('x', 4, 'abcde')).toBe('abcx');
      expect(padStart('abcd', 2, 'z')).toBe('abcd');
      expect(padStart('12345', 10, 'abcdefg')).toBe('abcde12345');
      expect(padStart('a', 3)).toBe('  a');
      expect(padStart(2, 3, '00')).toBe('002');
    });
  });

  //
  // Handsontable.helper.stripTags
  //
  describe('stripTags', function() {
    it("should strip any HTML tags from the string", function() {
      var stripTags= Handsontable.helper.stripTags;

      expect(stripTags('')).toBe('');
      expect(stripTags('foo')).toBe('foo');
      expect(stripTags('')).toBe('alert()');
      expect(stripTags('Hello my world2')).toBe('Hello my world2');
      expect(stripTags('This is my link')).toBe('This is my link');
    });
  });
});


text:
package com.senseidb.cluster.routing;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import org.apache.log4j.Logger;

public class MD5HashProvider implements HashProvider {
  private final static Logger logger = Logger.getLogger(MD5HashProvider.class);
  private final ThreadLocal<MessageDigest> _md = new ThreadLocal<MessageDigest>() {
    protected MessageDigest initialValue() {
      try {
        return MessageDigest.getInstance("MD5");
      } catch (NoSuchAlgorithmException e) {
        logger.error(e);
      }
      return null;
    }
  };

  /**
   * Hash the key into an integer.
   *
   * @param key
   *          the key to be hashed
   * @return the hash code of the key
   */
  public long hash(String key) {
    byte[] kbytes = _md.get().digest(key.getBytes());
    long hc = ((long) (kbytes[3] & 0xFF) << 24) | ((long) (kbytes[2] & 0xFF) << 16)
        | ((long) (kbytes[1] & 0xFF) << 8) | (long) (kbytes[0] & 0xFF);
    _md.get().reset();
    return Math.abs(hc);
  }

}


text:
title: Al Franken, Minnesota Senator
name: Al Franken
avatar: /ui/img/avatars/Al_Franken.jpg
party: democrat
state: minnesota
type: senator
lasthall: 2009-08-28
phone: (202) 224-5641
never:
twitter: SenFranken
---


text:
/* ******************************************************************************
*																				*
*		Practica ABD - Series													*
*		Autores:	David Garcia Alvarez										*
*					Javier Toledano Regaño										*
*								3ºB												*
*********************************************************************************/

package series.GUI.VentanasInfo;
import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionListener;
import java.awt.event.FocusListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Calendar;
import java.util.EventListener;
import java.util.GregorianCalendar;
import java.util.Observable;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.WindowConstants;

import series.GUI.VistaInterfaz;
import series.modelo.Episodio;

/**
* This code was edited or generated using CloudGarden's Jigloo
* SWT/Swing GUI Builder, which is free for non-commercial
* use. If Jigloo is being used commercially (ie, by a corporation,
* company or business for any purpose whatever) then you
* should purchase a license for each developer using Jigloo.
* Please visit www.cloudgarden.com for details.
* Use of Jigloo implies acceptance of these licensing terms.
* A COMMERCIAL LICENSE HAS NOT BEEN PURCHASED FOR
* THIS MACHINE, SO JIGLOO OR THIS CODE CANNOT BE USED
* LEGALLY FOR ANY CORPORATE OR COMMERCIAL PURPOSE.
*/
@SuppressWarnings("serial")
public class VentanaInfoEpisodio extends javax.swing.JFrame implements VistaInterfaz {
	private JPanel jPanelFondo;
	private JLabel jLTitulo;
	private JButton jBNoVisto;
	private JButton jBAceptar;
	private JButton jBVisto;
	private JTextField jTFSerie;
	private JLabel jLSerie;
	private JTextField jTFAno;
	private JTextField jTFMes;
	private JTextField jTFDia;
	private JLabel jLFecha;
	private JTextArea jTASinopsis;
	private JLabel jLSinopsis;
	private JTextField jTFTemporada;
	private JLabel jLTemporada;
	private JTextField jTFCapitulo;
	private JLabel jLCapitulo;
	private JTextField jTFTitulo;
	private Episodio episodio;

	public VentanaInfoEpisodio(Episodio episodio, boolean isAdmin) {
		super("Informacion del episodio: " + episodio.getTitulo());
		this.episodio=episodio;
		initGUI(isAdmin);
		setLocationRelativeTo(null);
	}

	private void initGUI( boolean isAdmin) {
		GregorianCalendar fechaEpisodio = new GregorianCalendar();
		fechaEpisodio.setTime(episodio.getFecha());
			setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
			{
				jPanelFondo = new JPanel();
				getContentPane().add(jPanelFondo, BorderLayout.CENTER);
				jPanelFondo.setLayout(null);
				{
					jLTitulo = new JLabel();
					jPanelFondo.add(jLTitulo);
					jLTitulo.setText("Titulo");
					jLTitulo.setBounds(12, 19, 97, 19);
				}
				{
					jTFTitulo = new JTextField();
					jPanelFondo.add(jTFTitulo);
					jTFTitulo.setText(episodio.getTitulo());
					jTFTitulo.setBounds(109, 17, 249, 23);
					jTFTitulo.setEditable(isAdmin);
					jTFTitulo.setName("JTFTituloEpisodio");
				}
				{
					jLCapitulo = new JLabel();
					jPanelFondo.add(jLCapitulo);
					jLCapitulo.setText("Capitulo");
					jLCapitulo.setBounds(12, 55, 97, 16);
				}
				{
					jTFCapitulo = new JTextField();
					jPanelFondo.add(jTFCapitulo);
					jTFCapitulo.setBounds(109, 52, 249, 23);
					jTFCapitulo.setEditable(isAdmin);
					jTFCapitulo.setText(episodio.getEpisodioSerie().getCapitulo()+"");
					jTFCapitulo.setName("JTFCapituloEpisodio");
					jTFCapitulo.addKeyListener(new KeyAdapter()
			        {
				     	   public void keyTyped(KeyEvent e)
				     	   {
				     	      char caracter = e.getKeyChar();

				     	      // Verificar si la tecla pulsada no es un digito
				     	      if(((caracter < '0') ||
				     	         (caracter > '9')) &&
				     	         (caracter != '\b' /*corresponde a BACK_SPACE*/))
				     	      {
				     	         e.consume();  // ignorar el evento de teclado
				     	      }
				     	   }
				     	});
				}
				{
					jLTemporada = new JLabel();
					jPanelFondo.add(jLTemporada);
					jLTemporada.setText("Temporada");
					jLTemporada.setBounds(12, 87, 97, 16);
				}
				{
					jTFTemporada = new JTextField();
					jPanelFondo.add(jTFTemporada);
					jTFTemporada.setBounds(109, 84, 249, 23);
					jTFTemporada.setEditable(isAdmin);
					jTFTemporada.setText(episodio.getTemporada()+"");
					jTFTemporada.setName("JTFTemporadaEpisodio");
					jTFTemporada.addKeyListener(new KeyAdapter()
			        {
				     	   public void keyTyped(KeyEvent e)
				     	   {
				     	      char caracter = e.getKeyChar();

				     	      // Verificar si la tecla pulsada no es un digito
				     	      if(((caracter < '0') ||
				     	         (caracter > '9')) &&
				     	         (caracter != '\b' /*corresponde a BACK_SPACE*/))
				     	      {
				     	         e.consume();  // ignorar el evento de teclado
				     	      }
				     	   }
				     	});
				}
				{
					jLSinopsis = new JLabel();
					jPanelFondo.add(jLSinopsis);
					jLSinopsis.setText("Sinopsis");
					jLSinopsis.setBounds(12, 115, 97, 24);
				}
				{
					jTASinopsis = new JTextArea();
					jPanelFondo.add(jTASinopsis);
					jTASinopsis.setBounds(109, 117, 249, 54);
					jTASinopsis.setEditable(isAdmin);
					jTASinopsis.setText(episodio.getSinopsis());
					jTASinopsis.setName("JTASinopsisEpisodio");
				}
				{
					jLFecha = new JLabel();
					jPanelFondo.add(jLFecha);
					jLFecha.setText("Fecha");
					jLFecha.setBounds(12, 171, 97, 28);
				}
				{
					jTFDia = new JTextField();
					jPanelFondo.add(jTFDia);
					jTFDia.setBounds(109, 177, 38, 23);
					jTFDia.setEditable(isAdmin);
					jTFDia.setText(fechaEpisodio.get(Calendar.DATE)+"");
					jTFDia.setName("JTFDiaEpisodio");
					jTFDia.addKeyListener(new KeyAdapter()
			        {
				     	   public void keyTyped(KeyEvent e)
				     	   {
				     	      char caracter = e.getKeyChar();

				     	      // Verificar si la tecla pulsada no es un digito
				     	      if(((caracter < '0') ||
				     	         (caracter > '9')) &&
				     	         (caracter != '\b' /*corresponde a BACK_SPACE*/))
				     	      {
				     	         e.consume();  // ignorar el evento de teclado
				     	      }
				     	   }
				     	});
				}
				{
					jTFMes = new JTextField();
					jPanelFondo.add(jTFMes);
					jTFMes.setBounds(159, 177, 37, 23);
					jTFMes.setEditable(isAdmin);
					jTFMes.setText(fechaEpisodio.get(Calendar.MONTH)+"");
					jTFMes.setName("JTFMesEpisodio");
					jTFMes.addKeyListener(new KeyAdapter()
			        {
				     	   public void keyTyped(KeyEvent e)
				     	   {
				     	      char caracter = e.getKeyChar();

				     	      // Verificar si la tecla pulsada no es un digito
				     	      if(((caracter < '0') ||
				     	         (caracter > '9')) &&
				     	         (caracter != '\b' /*corresponde a BACK_SPACE*/))
				     	      {
				     	         e.consume();  // ignorar el evento de teclado
				     	      }
				     	   }
				     	});
				}
				{
					jTFAno = new JTextField();
					jPanelFondo.add(jTFAno);
					jTFAno.setBounds(208, 177, 50, 23);
					jTFAno.setEditable(isAdmin);
					jTFAno.setText(fechaEpisodio.get(Calendar.YEAR)+"");
					jTFAno.setName("JTFAnoEpisodio");
					jTFAno.addKeyListener(new KeyAdapter()
			        {
				     	   public void keyTyped(KeyEvent e)
				     	   {
				     	      char caracter = e.getKeyChar();

				     	      // Verificar si la tecla pulsada no es un digito
				     	      if(((caracter < '0') ||
				     	         (caracter > '9')) &&
				     	         (caracter != '\b' /*corresponde a BACK_SPACE*/))
				     	      {
				     	         e.consume();  // ignorar el evento de teclado
				     	      }
				     	   }
				     	});
				}
				{
					jLSerie = new JLabel();
					jPanelFondo.add(jLSerie);
					jLSerie.setText("Serie");
					jLSerie.setBounds(12, 211, 97, 29);
				}
				{
					jTFSerie = new JTextField();
					jPanelFondo.add(jTFSerie);
					jTFSerie.setBounds(109, 214, 149, 23);
					jTFSerie.setEditable(isAdmin);
					jTFSerie.setText(episodio.getEpisodioSerie().getIdSerie()+"");
					jTFSerie.setName("JTFIdSerieEpisodio");
					jTFSerie.addKeyListener(new KeyAdapter()
			        {
				     	   public void keyTyped(KeyEvent e)
				     	   {
				     	      char caracter = e.getKeyChar();

				     	      // Verificar si la tecla pulsada no es un digito
				     	      if(((caracter < '0') ||
				     	         (caracter > '9')) &&
				     	         (caracter != '\b' /*corresponde a BACK_SPACE*/))
				     	      {
				     	         e.consume();  // ignorar el evento de teclado
				     	      }
				     	   }
				     	});
				}
				{
					jBAceptar = new JButton();
					jPanelFondo.add(jBAceptar);
					jBAceptar.setText("Aceptar");
					jBAceptar.setBounds(270, 177, 103, 23);
					jBAceptar.setName("JButonAceptarInfoEpisodio");
				}
				{
					jBVisto = new JButton();
					jPanelFondo.add(jBVisto);
					jBVisto.setText("Visto");
					jBVisto.setBounds(270, 205, 103, 21);
					jBVisto.setName("JBMarcarComoVisto");
				}
				{
					jBNoVisto = new JButton();
					jPanelFondo.add(jBNoVisto);
					jBNoVisto.setText("No visto");
					jBNoVisto.setBounds(270, 231, 103, 23);
					jBNoVisto.setName("JBMarcarComoNoVisto");
				}
			}
			pack();
			setSize(400, 300);
	}

	@Override
	public void update(Observable arg0, Object arg1) {

	}

	@Override
	public void fijarControlador(EventListener controlador) {
		jTASinopsis.addFocusListener((FocusListener)controlador);
		jTFAno.addFocusListener((FocusListener)controlador);
		jTFCapitulo.addFocusListener((FocusListener)controlador);
		jTFDia.addFocusListener((FocusListener)controlador);
		jTFMes.addFocusListener((FocusListener)controlador);
		jTFSerie.addFocusListener((FocusListener)controlador);
		jTFTemporada.addFocusListener((FocusListener)controlador);
		jTFTitulo.addFocusListener((FocusListener)controlador);

		jBAceptar.addActionListener((ActionListener)controlador);
		jBVisto.addActionListener((ActionListener)controlador);
		jBNoVisto.addActionListener((ActionListener)controlador);

	}

	public void cerrarVentana()
	{
		dispose();
	}

	/**
	 * Metodo para que la ventana se empiece ha hacerse visible en un nuevo hilo.
	 */
	public void empieza()
	{
		EventQueue.invokeLater(new Runnable(){
	    	public void run() {
	    		setVisible(true);
	    	}
	    });
	}

	public Episodio getEpisodio() {
		return episodio;
	}

}


text:
You want to help? You rock! Now, take a moment to be sure your contributions make sense to everyone else.

## Reporting Issues

Found a problem? Want a new feature?

- See if your issue or idea has [already been reported].
- Provide a [reduced test case] or a [live example].

Remember, a bug is a _demonstrable problem_ caused by _our_ code.

## Submitting Pull Requests

Pull requests are the greatest contributions, so be sure they are focused in scope, and do avoid unrelated commits.

1. To begin, [fork this project], clone your fork, and add our upstream.
    ```bash
    # Clone your fork of the repo into the current directory
    git clone https://github.com/<your-username>/slims
    # Navigate to the newly cloned directory
    cd slims
    # Assign the original repo to a remote called "upstream"
    git remote add upstream https://github.com/scrum/slims
    # Install the tools necessary for development
    npm install
    # Run local server
    npm run dev
    ```

2. Create a branch for your feature or fix:
    ```bash
    # Move into a new branch for a feature
    git checkout -b feature/thing
    ```
    ```bash
    # Move into a new branch for a fix
    git checkout -b fix/something
    ```

3. Be sure your code follows our practices.
    ```bash
    # Test current code
    npm run test
    ```

4. Push your branch up to your fork:
    ```bash
    # Push a feature branch
    git push origin feature/thing
    ```
    ```bash
    # Push a fix branch
    git push origin fix/something
    ```

5. Now [open a pull request] with a clear title and description.

[already been reported]: issues
[fork this project]:     fork
[live example]:          http://codepen.io/pen
[open a pull request]:   https://help.github.com/articles/using-pull-requests/
[reduced test case]:     https://css-tricks.com/reduced-test-cases/


text:
import { EventUI } from './../models/event.model';

export type EventState = EventUI[];

export const initialState: EventState = [] as EventState;


text:
package com.example.achuan.teamsystem.ui.admin.ble.adapter;

import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import com.example.achuan.teamsystem.R;
import com.example.achuan.teamsystem.model.bean.MyBean;
import com.example.achuan.teamsystem.widget.SquareImageView;

import java.util.List;

import butterknife.BindView;
import butterknife.ButterKnife;

/**
 * Created by achuan on 16-10-5.
 * 功能:BLE设备连接进行通信后的列表适配器类
 */
public class DeviceLinkAdapter extends RecyclerView.Adapter<DeviceLinkAdapter.ViewHolder> {

    private LayoutInflater mInflater;//创建布局装载对象来获取相关控件(类似于findViewById())
    private Context mContext;//显示框面
    private List<MyBean> mList;
    //定义两个接口引用变量
    private OnClickListener mOnClickListener;
    private OnLongClickListener mOnLongClickListener;

    //define interface
    public interface OnClickListener {
        void onClick(View view, int postion);
    }

    public interface OnLongClickListener {
        void onLongClick(View view, int postion);
    }

    //定义 set方法
    public void setOnClickListener(OnClickListener onClickListener) {
        mOnClickListener = onClickListener;
    }

    public void setOnLongClickListener(OnLongClickListener onLongClickListener) {
        mOnLongClickListener = onLongClickListener;
    }

    /*构造方法*/
    public DeviceLinkAdapter(Context mContext, List<MyBean> mList) {
        this.mContext = mContext;
        this.mList = mList;
        //通过获取context来初始化mInflater对象
        mInflater = LayoutInflater.from(mContext);
    }

    //适配器中数据集中的个数
    public int getItemCount() {
        return mList.size();
    }

    /****
     * item第一次显示时,才创建其对应的viewholder进行控件存储,之后直接使用即可
     ****/
    //先创建ViewHolder
    public ViewHolder onCreateViewHolder(ViewGroup parent, int type) {
        //下面需要把单个item对应的布局文件加载进来,这里对应R.layout.item_my布局文件
        View view = mInflater.inflate(R.layout.item_no_card, parent, false);
        ViewHolder viewHolder = new ViewHolder(view);//创建一个item的viewHoler实例
        return viewHolder;
    }

    /****
     * 当前界面中出现了item的显示更新时执行该方法(即有item加入或者移除界面)
     * <p/>
     * 该方法的执行顺序  早于  onScrolled()方法
     ****/
    //绑定ViewHolder
    public void onBindViewHolder(final ViewHolder holder, final int postion) {
        //再通过viewHolder中缓冲的控件添加相关数据
        final MyBean myBean = mList.get(postion);//从数据源集合中获得对象
        /*
        * 这里结合下面自定义的viewHolder类,拿到控件的加载对象然后进行数据绑定
        * 这一步比较重要,需要小心设置
        * */
        holder.mSquareIv.setBackgroundResource(R.drawable.signin);
        holder.mTvTitle.setText(myBean.getTitle());
        holder.mTvContent.setText(myBean.getContent());
        /***为item设置点击监听事件***/
        holder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (mOnClickListener != null) {
                    //设置回调监听
                    mOnClickListener.onClick(view, postion);
                }
            }
        });
        holder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                if (mOnLongClickListener != null) {
                    //设置长时间点击回调监听
                    mOnLongClickListener.onLongClick(v, postion);
                }
                return false;//设置成false,这样就不会触发单击的监听事件
            }
        });
    }

    /*创建自定义的ViewHolder类*/
    public static class ViewHolder extends RecyclerView.ViewHolder {
        //使用butterknife来进行item中的控件加载,此处需要自己添加
        @BindView(R.id.square_iv)
        SquareImageView mSquareIv;
        @BindView(R.id.tv_title)
        TextView mTvTitle;
        @BindView(R.id.tv_content)
        TextView mTvContent;
        ViewHolder(View view) {
            super(view);
            ButterKnife.bind(this, view);
        }
    }
}


text:
package com.mapswithme.maps.analytics;

import android.app.Application;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

import com.mapswithme.maps.BuildConfig;
import com.mapswithme.util.log.Logger;
import com.mapswithme.util.log.LoggerFactory;
import ru.mail.libnotify.api.NotificationApi;
import ru.mail.libnotify.api.NotificationFactory;
import ru.mail.notify.core.api.BackgroundAwakeMode;
import ru.mail.notify.core.api.NetworkSyncMode;

import java.util.Collections;
import java.util.Map;

class LibnotifyEventLogger extends DefaultEventLogger
{
  LibnotifyEventLogger(@NonNull Application application)
  {
    super(application);
  }

  @Override
  public void initialize()
  {
    if (BuildConfig.DEBUG || BuildConfig.BUILD_TYPE.equals("beta"))
    {
      NotificationFactory.enableDebugMode();
      NotificationFactory.setLogReceiver(LoggerFactory.INSTANCE.createLibnotifyLogger());
      NotificationFactory.setUncaughtExceptionListener((thread, throwable) -> {
        Logger l = LoggerFactory.INSTANCE.getLogger(LoggerFactory.Type.THIRD_PARTY);
        l.e("LIBNOTIFY", "Thread: " + thread, throwable);
      });
    }
    NotificationFactory.setNetworkSyncMode(NetworkSyncMode.WIFI_ONLY);
    NotificationFactory.setBackgroundAwakeMode(BackgroundAwakeMode.DISABLED);
    NotificationFactory.initialize(getApplication());
    NotificationApi api = NotificationFactory.get(getApplication());
    api.allowDeviceIdTracking(false, false);
  }

  @Override
  public void sendTags(@NonNull String tag, @Nullable String[] params)
  {
    super.sendTags(tag, params);
    if (params == null)
      return;

    boolean isSingleParam = params.length == 1;
    Object value = isSingleParam ? params[0] : params;
    Map<String, Object> map = Collections.singletonMap(tag, value);
    NotificationApi api = NotificationFactory.get(getApplication());
    api.collectEventBatch(map);
  }
}


text:
libo3d3xx
=========

Library and utilities for working with IFM Efector O3D3xx Cameras.

![3dimg](doc/figures/3d.png)

libo3d3xx provides facilities for interfacing with O3D3xx cameras built and
sold by IFM Efector. The O3D3xx cameras are 3D cameras based on the PMD
Tech Photonic Mixer Device time-of-flight imager. This toolbox bridges the IFM
hardware to the open-source computer vision packages:
[OpenCV](http://opencv.org) and [PCL](http://pointclouds.org).

At its core, libo3d3xx provides a way to stream images from an O3D3xx camera in
real-time and access the 2D data as OpenCV images (applies to the Amplitude
(raw and normalized), Depth, and Confidence images) and the 3D data as both an
OpenCV image and a PCL point cloud (i.e., the `CARTESIAN_X`, `CARTESIAN_Y`, and
`CARTESIAN_Z` are fused to create a point cloud). We note that the PCL point
cloud constructed by this library has point type `pcl::PointXYZI` (referred to
as `o3d3xx::PointT`). For the intensity channel, we use the normalized
Amplitude image data registered to each point. We do this because, unlike in
earlier PMD-based IFM cameras, the Intensity image is not currently
available. We expect the Amplitude image can act as a proxy for the Intensity
image as it relates to PCL algorithms that may rely on that data.

The code has been developed on 64-bit Ubuntu Linux 14.04 LTS. This is currently
the only platform that the software has been tested on. It is expected that
some tweaks will need to be made to use the software on other platforms. You
can contact [Love Park Robotics](http://loveparkrobotics.com) for assistance in
porting or file an [issue request](https://github.com/lovepark/libo3d3xx/issues)

Software Compatibility Matrix
-----------------------------

    libo3d3xx version
    IFM Firmware Version
    Supported Cameras
    Notes

    0.1.7
    0.06.13
    O3D303
    Initial Release

    0.1.8
    0.06.39
    O3D303
    DEPRECATED, USE 0.1.9

    0.1.9
    0.06.39
    O3D303
    Initial support for 100k pixel images

    0.1.10
    0.06.39
    O3D303
    DEPRECATED, USE 0.1.11

    0.1.11
    0.06.39
    O3D303
    Adds the XYZ OpenCV image

    0.2.0
    1.1.288
    O3D303
    Cross-compilation support and exposing raw amplitude image

Features
--------

High-level features of this library include:

* The code is written in modern C++11.
* The library employs PCL and OpenCV native image formats.
* Easily scriptable command line utilities are provided for performing common
  tasks associated with configuring, backing up, restoring, and introspecting,
  the camera settings. This scriptability lends itself to managing fleets of
  cameras for large-scale installations.
* A simple viewer application is provided for concurrently inspecting the point
  cloud, depth, amplitude, and confidence image.
* A business-friendly (Apache 2.0) License is employed.
* The code is being actively developed and maintained at
  [Love Park Robotics](http://loveparkrobotics.com). Pull requests are welcome
  from those who wish to contribute code!

[ROS](http://ros.org) bindings are available [here](https://github.com/lovepark/o3d3xx-ros)

Prerequisites
-------------

* [Boost](http://www.boost.org) (>= 1.54)
* [Gtest](https://code.google.com/p/googletest/) (unit testing)
* [Glog](https://code.google.com/p/google-glog/) (logging infrastructure)
* [libxmlrpc](http://xmlrpc-c.sourceforge.net/)
* [OpenCV](http://opencv.org) (>= 2.4)
* [PCL](http://pointclouds.org) (>= 1.7.1)
* [CMake](http://www.cmake.org) (>= 2.8.11)

Additionally, your compiler must support C++11. We are using g++ 4.8.2 on
Ubuntu Linux 14.04 LTS.

Installation
------------

(Assumes Linux)

To build and install `libo3d3xx` you can issue the following commands
from the top-level directory of this source distribution:

	$ mkdir build
	$ cd build
	$ cmake ..
	$ make
	$ make check
	$ sudo make install

NOTE: Running `make check` will run unit tests. It assumes that the hardware is
available and running with factory default settings. If your camera is using an
IP address different from the factory default of 192.168.0.69, you can set the
`O3D3XX_IP` environment variable to point to the proper IP. Please note, the unit
tests will wipe out your current camera settings and applications. You should
back up your camera prior to running the unit tests.

There is also a `make package` target that will build the binary debian
package. You can then install this with the usual Debian/Ubuntu `dpkg`
tool. From the beginning the process would look like:

	$ mkdir build
	$ cd build
	$ cmake ..
	$ make
	$ make check
    $ make package
    $ sudo dpkg -i libo3d3xx_0.2.0_amd64.deb

**NOTE:** The version string in the deb file may be different based upon the
  version of libo3d3xx that you are building.

Installing the debian file is the preferred method of installation, albeit
assumes you are on a system such as Debian or Ubuntu. It is preferred because
it has runtime dependency checking built in as well as a clean way to uninstall
the software (i.e., `sudo dpkg --purge libo3d3xx`).

After installation, you may find it useful to add the following to your
`~/.bash_profile`:

	if [ -f /opt/libo3d3xx/etc/setup.bash ]; then
		source /opt/libo3d3xx/etc/setup.bash
	fi

This will modify your `LD_LIBRARY_PATH` and `PATH` to ensure the library is
available to your environment.

More detail on the build process can be found at:

* [Custom builds](doc/custom_builds.md)
* [Cross compiling](doc/cross_compiling.md)

Running
-------

* [Using the library](doc/using.md)
* [Command-line utilities](doc/utils.md)
* [Unlocking the 100k Pixel Imager](doc/100k.md)

TODO
----

Please see the [Github Issues](https://github.com/lovepark/libo3d3xx/issues).

LICENSE
-------

Please see the file called LICENSE.

AUTHORS
-------

Tom Panzarella <tom@loveparkrobotics.com>


text:
task :reset => [:init, :clean_all, :reset_packages] do

  execute "reset"

end


text:
<?xml version="1.0" encoding="utf-8"?>

<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    tools:context="fr.tvbarthel.apps.simpleweatherforcast.MainActivity">
    <item
        android:id="@+id/menu_item_thanks"
        android:title="@string/menu_item_thanks"
        android:orderInCategory="10"
        app:showAsAction="never" />
</menu>


text:
using System;
using System.Collections.Generic;
using System.Linq;
using AgentMulder.ReSharper.Domain.Elements.Modules;
using AgentMulder.ReSharper.Domain.Patterns;
using AgentMulder.ReSharper.Domain.Registrations;
using JetBrains.ProjectModel;
using JetBrains.ReSharper.Feature.Services.CSharp.StructuralSearch;
using JetBrains.ReSharper.Feature.Services.CSharp.StructuralSearch.Placeholders;
using JetBrains.ReSharper.Feature.Services.StructuralSearch;
using JetBrains.ReSharper.Psi;
using JetBrains.ReSharper.Psi.CSharp.Tree;
using JetBrains.ReSharper.Psi.Tree;
using JetBrains.Util;

namespace AgentMulder.Containers.Autofac.Patterns.Mvc
{
    public abstract class RegisterControllersBase : RegistrationPatternBase
    {
        private readonly string mvcTypeFqn;
        private readonly IEnumerable<IBasedOnPattern> basedOnPatterns;

        protected RegisterControllersBase(string expression, string mvcTypeFqn, IEnumerable<IBasedOnPattern> basedOnPatterns)
            : base(CreatePattern(expression))
        {
            this.mvcTypeFqn = mvcTypeFqn;
            this.basedOnPatterns = basedOnPatterns;
        }

        private static IStructuralSearchPattern CreatePattern(string expression)
        {
            return new CSharpStructuralSearchPattern(string.Format("$builder$.{0}($assemblies$)", expression),
                new ExpressionPlaceholder("builder", "Autofac.ContainerBuilder", true),
                new ArgumentPlaceholder("assemblies"));
        }

        public override IEnumerable<IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement)
        {
            IExpressionStatement parentExpression = GetParentExpressionStatement(registrationRootElement);
            if (parentExpression == null)
            {
                yield break;
            }

            IStructuralMatchResult match = Match(registrationRootElement);
            if (match.Matched)
            {
                var arguments = match.GetMatchedElementList("assemblies").Cast<ICSharpArgument>();

                IEnumerable<IModule> modules = arguments.SelectNotNull(argument => ModuleExtractor.GetTargetModule<ICSharpExpression>(argument.Value));

                IEnumerable<FilteredRegistrationBase> basedOnRegistrations = basedOnPatterns.SelectMany(
                    basedOnPattern => basedOnPattern.GetBasedOnRegistrations(parentExpression.Expression)).ToList();

                foreach (IModule module in modules)
                {
                    // todo blech, fix this
                    yield return new CompositeRegistration(registrationRootElement, basedOnRegistrations.Concat(
                        new ComponentRegistrationBase[]
                        {
                            new MvcControllerRegistration(registrationRootElement, mvcTypeFqn),
                            new ModuleBasedOnRegistration(registrationRootElement, module)
                        }));
                }
            }
        }

        private class MvcControllerRegistration : FilteredRegistrationBase
        {
            public MvcControllerRegistration(ITreeNode registrationRootElement, string mvcControllerClrTypeName)
                : base(registrationRootElement)
            {
                AddFilter(typeElement =>
                {
                    // todo this returns null!

                    ITypeElement mvcControllerType = TypeFactory.CreateTypeByCLRName(mvcControllerClrTypeName, typeElement.Module).GetTypeElement();

                    return typeElement.IsDescendantOf(mvcControllerType) &&
                           typeElement.GetClrName().ShortName.EndsWith("Controller"); // per Autofac's RegisterApiControllers/RegisterWebApiControllers extension
                });
            }
        }

        private IExpressionStatement GetParentExpressionStatement(ITreeNode node)
        {
            for (var n = node; n != null; n = n.Parent)
            {
                var expressionStatement = n as IExpressionStatement;
                if (expressionStatement != null)
                    return expressionStatement;
            }

            return null;
        }
    }
}


text:
SET NEWLINE=^& echo.

FIND /C /I "myordbok.local" %WINDIR%\system32\drivers\etc\hosts
IF %ERRORLEVEL% NEQ 0 ECHO %NEWLINE%^127.0.0.1                   myordbok.local>>%WINDIR%\system32\drivers\etc\hosts


text:
<?php
/**
 * generate url from raw db data
 *
 * Here we get the raw structure that has been hydrated for $ref link cases
 * by doctrine and replace it with a route generated by the symfony router.
 * We do this in it's own listener due to the fact that there is no way that
 * we can inject anything useable into the default odm hydrator and it looks
 * rather futile to hack it so we can use our own custom hydration code.
 */

namespace Graviton\DocumentBundle\Listener;

use Graviton\DocumentBundle\Service\ExtReferenceConverterInterface;
use Graviton\Rql\Event\VisitNodeEvent;
use Graviton\Rql\Node\ElemMatchNode;
use Graviton\RqlParser\Node\Query\AbstractArrayOperatorNode;
use Graviton\RqlParser\Node\Query\AbstractScalarOperatorNode;

/**
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  https://opensource.org/licenses/MIT MIT License
 * @link     http://swisscom.ch
 */
class ExtReferenceSearchListener
{
    /**
     * @var ExtReferenceConverterInterface
     */
    private $converter;

    /**
     * @var array
     */
    private $fields;

    /**
     * construct
     *
     * @param ExtReferenceConverterInterface $converter Extref converter
     * @param array                          $fields    map of fields to process
     */
    public function __construct(ExtReferenceConverterInterface $converter, array $fields)
    {
        $this->converter = $converter;
        $this->fields = $fields;
    }

    /**
     * @param VisitNodeEvent $event node event to visit
     *
     * @return VisitNodeEvent
     */
    public function onVisitNode(VisitNodeEvent $event)
    {
        $node = $event->getNode();
        $documentClassName = $event->getClassName();
        if ($node instanceof AbstractScalarOperatorNode &&
            $this->isExtrefField($documentClassName, $node->getField(), $event->getContext())) {
            $event->setNode($this->processScalarNode($node));
        } elseif ($node instanceof AbstractArrayOperatorNode &&
            $this->isExtrefField($documentClassName, $node->getField(), $event->getContext())) {
            $event->setNode($this->processArrayNode($node));
        }

        return $event;
    }

    /**
     * Process scalar condition
     *
     * @param AbstractScalarOperatorNode $node Query node
     * @return AbstractScalarOperatorNode
     */
    private function processScalarNode(AbstractScalarOperatorNode $node)
    {
        $copy = clone $node;
        $copy->setValue($this->getDbRefValue($node->getValue()));
        return $copy;
    }

    /**
     * Process array condition
     *
     * @param AbstractArrayOperatorNode $node Query node
     * @return AbstractArrayOperatorNode
     */
    private function processArrayNode(AbstractArrayOperatorNode $node)
    {
        $copy = clone $node;
        $copy->setValues(array_map([$this, 'getDbRefValue'], $node->getValues()));
        return $copy;
    }

    /**
     * Get DbRef from extref URL
     *
     * @param string $url Extref URL representation
     *
     * @return \Graviton\DocumentBundle\Entity\ExtReference extref
     */
    private function getDbRefValue($url)
    {
        if (empty($url)) {
            return null;
        }

        try {
            return $this->converter->getExtReference($url)->jsonSerialize();
        } catch (\InvalidArgumentException $e) {
            //make up some invalid refs to ensure we find nothing if an invalid url was given
            return [];
        }
    }

    /**
     * Get document field name by query name
     *
     * @param string    $documentClassName document class name
     * @param string    $searchName        Exposed field name from RQL query
     * @param \SplStack $nodeContext       Current node context
     * @return bool
     */
    private function isExtrefField(string $documentClassName, string $searchName, \SplStack $nodeContext)
    {
        if (!isset($this->fields[$documentClassName])) {
            throw new \LogicException(sprintf('Missing "%s" from extref fields map.', $documentClassName));
        }

        $fieldName = $searchName;
        foreach ($nodeContext as $parentNode) {
            if ($parentNode instanceof ElemMatchNode) {
                $fieldName = $parentNode->getField().'..'.$fieldName;
            }
        }

        return in_array(
            strtr($fieldName, ['..' => '.0.']),
            $this->fields[$documentClassName],
            true
        );
    }
}


text:
package com.manorrock.json.convert;

import com.manorrock.convert.Converter;
import com.manorrock.json.JsonObject;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.Test;

/**
 * The JUnit tests for the JsonObjectPojoConverter.
 *
 * @author Manfred Riem (mriem@manorrock.com)
 */
public class JsonObjectPojoConverterTest {

    /**
     * Test convert method.
     */
    @Test
    public void testConvert() {
        JsonToPojoConverterContext context = new JsonToPojoConverterContext();
        JsonObject jsonObject = new JsonObject();
        Converter converter = context.getDefaultConverter();
        context.setAttribute("className", TestPojo.class.getName());
        Object result = converter.convert(context, jsonObject);
        assertNotNull(result);
        assertTrue(result instanceof TestPojo);
    }

    /**
     * Test convert method.
     */
    @Test
    public void testConvert2() {
        JsonToPojoConverterContext context = new JsonToPojoConverterContext();
        JsonObject jsonObject = new JsonObject();
        Converter converter = context.getDefaultConverter();
        context.setAttribute("className", TestPojoList.class.getName());
        Object result = converter.convert(context, jsonObject);
        assertNotNull(result);
        assertTrue(result instanceof TestPojoList);
    }
}


text:
#if !defined(FUSION_FILTER_IF_07172005_0818)
#define FUSION_FILTER_IF_07172005_0818

#include <boost/fusion/support/config.hpp>
#include <boost/fusion/view/filter_view/filter_view.hpp>

namespace boost { namespace fusion
{
    namespace result_of
    {
        template <typename Sequence, typename Pred>
        struct filter_if
        {
            typedef filter_view<Sequence, Pred> type;
        };
    }

    template <typename Pred, typename Sequence>
    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
    inline typename result_of::filter_if<Sequence const, Pred>::type
    filter_if(Sequence const& seq)
    {
        return filter_view<Sequence const, Pred>(seq);
    }
}}

#endif


text:
test:
	./node_modules/.bin/mocha --compilers coffee:coffee-script

test-all:
	./node_modules/.bin/mocha --compilers coffee:coffee-script --recursive

.PHONY: test-all test