text:
import React, { Component } from 'react';
import { connect } from 'react-redux';
// import { Field, reduxForm } from 'redux-form';

import styles from './styles.css';

class ConfirmModal extends Component {

  getTextAndConfirm() {
    const text = this.confirmInput.value;
    this.props.onConfirm(text);
  }

  handleChange(event) {
    this.props.onUpdate('name', event.target.value);
  }

  render() {
    const { message, onCancel, data } = this.props;

    if (!data.isShowing) {
      return null;
    }

    // const CreateVmForm = require('./CreateVmForm').default

    return (

              {message}
              <input className={styles.confirmModalInput} type="text" value={data.name} onChange={(event) => this.handleChange(event)} ref={(_ref) => { this.confirmInput = _ref; }} />
              <button className={styles.btn} onClick={() => this.getTextAndConfirm()}>OK</button>
              <button className={styles.btn} onClick={() => onCancel()}>Cancel</button>

    );
  }

}

ConfirmModal.propTypes = {
  message: React.PropTypes.string.isRequired,
  onConfirm: React.PropTypes.string.isRequired,
  onCancel: React.PropTypes.string.isRequired,
  onUpdate: React.PropTypes.string.isRequired,
  data: React.PropTypes.string.isRequired,
};

// const mapStateToComponent = (state) => {
//   return {
//     // isShowing: state.modals.isShowing
//   }
// }

const mapStateToComponent = () => {};

export default connect(mapStateToComponent)(ConfirmModal);


text:
package gtreap

import (
	"github.com/noypi/kv"
	"github.com/steveyen/gtreap"
)

type Reader struct {
	t *gtreap.Treap
}

func (w *Reader) Get(k []byte) (v []byte, err error) {
	var rv []byte
	itm := w.t.Get(&Item{k: k})
	if itm != nil {
		rv = make([]byte, len(itm.(*Item).v))
		copy(rv, itm.(*Item).v)
		return rv, nil
	}
	return nil, nil
}

func (r *Reader) MultiGet(keys [][]byte) ([][]byte, error) {
	return kv.MultiGet(r, keys)
}

func (w *Reader) PrefixIterator(k []byte) kv.KVIterator {
	rv := Iterator{
		t:      w.t,
		prefix: k,
	}
	rv.restart(&Item{k: k})
	return &rv
}

func (w *Reader) PrefixIterator0(k []byte) kv.KVIterator {
	panic("not implemented")
	return nil
}

func (w *Reader) ReversePrefixIterator(k []byte) kv.KVIterator {
	panic("not implemented")
	return nil
}

func (w *Reader) RangeIterator(start, end []byte) kv.KVIterator {
	rv := Iterator{
		t:     w.t,
		start: start,
		end:   end,
	}
	rv.restart(&Item{k: start})
	return &rv
}

func (w *Reader) ReverseRangeIterator(start, end []byte) kv.KVIterator {
	panic("unimplemented")
	return nil
}

func (w *Reader) RangeIterator0(start, end []byte) kv.KVIterator {
	panic("unimplemented")
	return nil
}

func (w *Reader) Close() error {
	return nil
}

redpajama_set_name: RedPajamaGithub


text:
/** Defines classes to load and execute TensorFlowLite models. */
package org.tensorflow.lite;


text:
var step = '
Purpose:
'
            +'
Validate if the better fitting size icon is used to the icon of web app<
'
            +'
Expected Result:
'
            +'
'
            +'
"ManifestUsingBetterFittingSizeIcon/res/icon.png" is used as the icon of "manifestusingbetterfittingsizeicon" app
'
            +'
';


text:
import { assert } from 'chai';

import { AbstractRule } from '../../src/rules/abstract-rule';
import { MacAddress } from '../../src/rules/mac-address';

describe('MacAddress', () => {

    let macAddress: MacAddress;

    beforeEach(() => {
        macAddress = new MacAddress();
    });

    it('is rule', () => {
        assert.instanceOf(macAddress, AbstractRule);
    });

    it('values is valid', () => {
        assert.isTrue(macAddress.validate('00:11:22:33:44:55'));
        assert.isTrue(macAddress.validate('66-77-88-99-aa-bb'));
        assert.isTrue(macAddress.validate('AF:0F:bd:12:44:ba'));
        assert.isTrue(macAddress.validate('90-bc-d3-1a-dd-cc'));
    });

    it('values is not valid', () => {
        assert.isFalse(macAddress.validate(''));
        assert.isFalse(macAddress.validate('00-1122:33:44:55'));
        assert.isFalse(macAddress.validate('66-77--99-jj-bb'));
        assert.isFalse(macAddress.validate('HH:0F-bd:12:44:ba'));
        assert.isFalse(macAddress.validate('90-bc-nk:1a-dd-cc'));
        assert.isFalse(macAddress.validate(null));
        assert.isFalse(macAddress.validate(undefined));
        assert.isFalse(macAddress.validate(true));
        assert.isFalse(macAddress.validate(false));
    });

});


text:
bro-start

Blazing fast webpack setup for static websites

### :unamused:  Why another frontend setup?

Webpack is a nice, easily customizable module bundler.

It pairs nice with modern javascript frameworks like Vue or React but it's a hassle when it comes to compile some good old html files. :older_man:
_Bro-start_ combines for you the coolest webpack features with a simple static site generator with yaml and handlebars.

### :santa:  I want my bro-start setup!

```sh
svn export https://github.com/brocessing/bro-start/trunk bro-start
cd bro-start
yarn install
# Yarn is FAST ! But npm install will do the job as well.
```

You can also [download the latest release](https://github.com/brocessing/bro-start/releases/latest)

### :handbag:  Features

- Static rendering from yaml files and handlebars templates
- Easy routing : by default hierarchy of your yaml files are the routes of your sites
- Multifiles rendering / Multirouting from a single yaml file
- Easily configurable with multiple config files for each parts of the starter kit
- Lifecycle hooks to execute code at certain steps
- _autoPartials_ option to register all your partials automatically before any rendering
- PostCSS + Stylus + Autoprefixer
- ES6 transpilation with babel + ES2015 presets
- Webpack Dev Server and Hot Reloading
- BrowserSync and its features (localtunnel, xip.io, ...)
- Hash, publicPath from webpack is available as data in your layouts
- `deploy` npm script to push the dist folder contents on a gh-pages branch

### :hammer:  License
MIT.


text:
<?php

namespace chegamos\entity\factory;

use chegamos\entity\Category;
use chegamos\entity\Subcategory;
use chegamos\exception\ChegamosException;

class CategoryFactory
{
    public static function generate($categoryJsonObject)
    {
        if (is_object($categoryJsonObject)) {
            $category = new Category();
            $category->setId($categoryJsonObject->id);
            $category->setName($categoryJsonObject->name);
            $category->setSubcategory(
                SubcategoryFactory::generate($categoryJsonObject->subcategory)
            );

            return $category;
        } else {
            throw new ChegamosException("Parâmetro passado não é um objeto.");
        }
    }
}


text:
/*! @license Firebase v4.3.1
Build: rev-b4fe95f
Terms: https://firebase.google.com/terms/ */

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
/**
* Copyright 2017 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var PROTOCOL_VERSION = exports.PROTOCOL_VERSION = '5';
var VERSION_PARAM = exports.VERSION_PARAM = 'v';
var TRANSPORT_SESSION_PARAM = exports.TRANSPORT_SESSION_PARAM = 's';
var REFERER_PARAM = exports.REFERER_PARAM = 'r';
var FORGE_REF = exports.FORGE_REF = 'f';
var FORGE_DOMAIN = exports.FORGE_DOMAIN = 'firebaseio.com';
var LAST_SESSION_PARAM = exports.LAST_SESSION_PARAM = 'ls';
var WEBSOCKET = exports.WEBSOCKET = 'websocket';
var LONG_POLLING = exports.LONG_POLLING = 'long_polling';
//# sourceMappingURL=Constants.js.map


text:
'use strict';

/**
 * @ngdoc service
 * @name $animateCss
 * @kind object
 *
 * @description
 * This is the core version of `$animateCss`. By default, only when the `ngAnimate` is included,
 * then the `$animateCss` service will actually perform animations.
 *
 * Click here {@link ngAnimate.$animateCss to read the documentation for $animateCss}.
 */
var $CoreAnimateCssProvider = function() {
  this.$get = ['$$rAF', '$q', '$$AnimateRunner', function($$rAF, $q, $$AnimateRunner) {

    return function(element, initialOptions) {
      // we always make a copy of the options since
      // there should never be any side effects on
      // the input data when running `$animateCss`.
      var options = copy(initialOptions);

      // there is no point in applying the styles since
      // there is no animation that goes on at all in
      // this version of $animateCss.
      if (options.cleanupStyles) {
        options.from = options.to = null;
      }

      if (options.from) {
        element.css(options.from);
        options.from = null;
      }

      /* jshint newcap: false */
      var closed, runner = new $$AnimateRunner();
      return {
        start: run,
        end: run
      };

      function run() {
        $$rAF(function() {
          applyAnimationContents();
          if (!closed) {
            runner.complete();
          }
          closed = true;
        });
        return runner;
      }

      function applyAnimationContents() {
        if (options.addClass) {
          element.addClass(options.addClass);
          options.addClass = null;
        }
        if (options.removeClass) {
          element.removeClass(options.removeClass);
          options.removeClass = null;
        }
        if (options.to) {
          element.css(options.to);
          options.to = null;
        }
      }
    };
  }];
};


text:
<ion-content padding class="contatos-tab">

  <ion-list>
    <ion-item>Contato 1</ion-item>
    <ion-item>Contato 2</ion-item>
    <ion-item>Contato 3</ion-item>
  </ion-list>

</ion-content>


text:
namespace dragonBones.phaser.plugin {
    export class DragonBonesScenePlugin extends Phaser.Plugins.ScenePlugin {
        protected _dbInst: dragonBones.DragonBones;
        protected _factory: Factory;

        constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager) {
            super(scene, pluginManager);

            const game = this.game;

            // bone data store
            game.cache.addCustom("dragonbone");

            if (this.game.config.renderType === Phaser.WEBGL) {
                const renderer = this.game.renderer as Phaser.Renderer.WebGL.WebGLRenderer;
                if (!renderer.hasPipeline('PhaserTextureTintPipeline'))
                    renderer.addPipeline('PhaserTextureTintPipeline', new pipeline.TextureTintPipeline({ game, renderer }));
            }

            // Add dragonBones only
            pluginManager.registerGameObject("dragonBones", CreateDragonBonesRegisterHandler);
            // Add armature, this will add dragonBones when not exist
            pluginManager.registerGameObject("armature", CreateArmatureRegisterHandler);
            pluginManager.registerFileType("dragonbone", DragonBoneFileRegisterHandler, scene);
        }

        createArmature(armature: string, dragonBones?: string, skinName?: string, atlasTextureName?: string, textureScale = 1.0): display.ArmatureDisplay {
            const display = this.factory.buildArmatureDisplay(armature, dragonBones, skinName, atlasTextureName, textureScale);
            this.systems.displayList.add(display);
            // use db.clock instead, if here we just use this.systems.updateList.add(display), that will cause the db event is dispatched with 1 or more frames delay
            this._dbInst.clock.add(display.armature);

            return display;
        }

        createDragonBones(dragonBonesName: string, textureScale = 1.0): DragonBonesData {
            return this.factory.buildDragonBonesData(dragonBonesName, textureScale);
        }

        get factory(): Factory {  // lazy instancing
            if (!this._factory) {
                this._dbInst = new dragonBones.DragonBones(new util.EventDispatcher());
                this._factory = new Factory(this._dbInst, this.scene);
            }

            return this._factory;
        }

        /*
        * Slot has a default display, usually it is a transparent image, here you could create a display whatever you want as the default one which -
        * has both skewX / skewY attributes and use "PhaserTextureTintPipeline" to render itself, or simply just use SlotImage or SlotSprite.
        */
        createSlotDisplayPlaceholder(): display.SlotImage | display.SlotSprite {
            return new display.SlotImage(this.scene, 0, 0);
        }

        boot(): void {
            this.systems.events.once('destroy', this.destroy, this);
            this.start();
        }

        start(): void {
            const ee = this.systems.events;

            ee.on('update', this.update, this);
            ee.once('shutdown', this.shutdown, this);
        }

        private update(time: number, delta: number): void {
            this._dbInst && this._dbInst.advanceTime(delta * 0.001);
        }

        shutdown(): void {
            const ee = this.systems.events;

            ee.off('update', this.update, this);
            ee.off('shutdown', this.shutdown, this);
        }

        destroy(): void {
            this.shutdown();

            this._factory =
            this._dbInst = null;

            this.pluginManager =
            this.game =
            this.scene =
            this.systems = null;
        }

        createMeshDisplayPlaceholder(): Phaser.GameObjects.Mesh {
            return new display.SlotMesh(this.scene, 0, 0, [], [], [], [], null, null);
        }
    }

    const CreateDragonBonesRegisterHandler = function(dragonBonesName: string, textureScale = 1.0): DragonBonesData {
        return this.scene.dragonbone.createDragonBones(dragonBonesName, textureScale);
    };

    const CreateArmatureRegisterHandler = function(armature: string, dragonBones?: string, skinName?: string, atlasTextureName?: string): display.ArmatureDisplay {
        return this.scene.dragonbone.createArmature(armature, dragonBones, skinName, atlasTextureName);
    };

    const DragonBoneFileRegisterHandler = function(dragonbonesName: string | object,
            textureURL?: string,
            atlasURL?: string,
            boneURL?: string,
            textureXhrSettings?: XHRSettingsObject,
            atlasXhrSettings?: XHRSettingsObject,
            boneXhrSettings?: XHRSettingsObject) {
        const multifile = new DragonBonesFile(this, dragonbonesName, textureURL, atlasURL, boneURL, textureXhrSettings, atlasXhrSettings, boneXhrSettings);
        this.addFile(multifile.files);

        return this;
    };
}


text:
from __future__ import absolute_import

from sentry.models import Project, ProjectTeam, ScheduledDeletion, Team
from sentry.tasks.deletion import run_deletion
from sentry.testutils import TestCase

class DeleteTeamTest(TestCase):
    def test_simple(self):
        team = self.create_team(
            name='test',
        )
        project1 = self.create_project(team=team, name='test1')
        project2 = self.create_project(team=team, name='test2')
        assert project1.teams.first() == team
        assert project2.teams.first() == team

        deletion = ScheduledDeletion.schedule(team, days=0)
        deletion.update(in_progress=True)

        with self.tasks():
            run_deletion(deletion.id)

        assert not Team.objects.filter(id=team.id).exists()
        assert not Project.objects.filter(id=project1.id).exists()
        assert not Project.objects.filter(id=project2.id).exists()
        assert not ProjectTeam.objects.filter(team_id=team.id).exists()


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.psalgs.array.matrix;

/**
 *
 * @author djoshi
 *
 * http://www.geeksforgeeks.org/number-cells-queen-can-move-obstacles-chessborad/
 *
 * http://portalkrishna.blogspot.com/2017/01/queens-attack-ii-solving-problem.html
 *
 * Number of cells a queen can move with obstacles on the chess board
 *
 * Queen Attack II problem ( Method 2 of first link on top )
 *
 * Time Complexity O( k ) where k is no. of obstacles
 */
public class QueenAttack {

    private static int numberOfPosition(int n, int k, int x, int y, int obstPosx[], int obstPosy[]) {
        // d11, d12, d21, d22 are for diagnoal distances.
        // r1, r2 are for vertical distance.
        // c1, c2 are for horizontal distance.
        int d11, d12, d21, d22, r1, r2, c1, c2;

        // Initialize the distance to end of the board ( diagonals)
        d11 = Math.min(x - 1, y - 1); // top left half diagonal
        d12 = Math.min(n - x, n - y); // bottom right half diagonal
        d21 = Math.min(n - x, y - 1); // bottom left half diagonal
        d22 = Math.min(x - 1, n - y); // top right half diagonal

        // Initialize distances from center ( vertical and horizontal )
        r1 = y - 1;  // mid left half horizontal (row)
        r2 = n - y;  // mid right half horizontal (row)
        c1 = x - 1;  // mid top half vertical (column)
        c2 = n - x;  // mid bottom half vertical (column)

        // For each obstacle find the minimum distance.
        // If obstacle is present in any direction, distance has to be updated.
        for (int i = 0; i < k; i++) {

            // check if there is any obstacles on top left half diagonal (d11)
            if (x > obstPosx[i] && y > obstPosy[i] && x - obstPosx[i] == y - obstPosy[i]) {
                d11 = Math.min(d11, x - obstPosx[i] - y);
            }

            // check if there is any obstacles on bottom right half diagonal (d12)
            if (obstPosx[i] > x && obstPosy[i] > y && obstPosx[i] - x == obstPosy[i] - y) {
                d12 = Math.min(d12, obstPosx[i] - x - 1);
            }

            // check if there is any obstacles on bottom left half diagonal (d21)
            if (obstPosx[i] > x && y > obstPosy[i] && obstPosx[i] - x == y - obstPosy[i]) {
                d21 = Math.min(d21, obstPosx[i] - x - 1);
            }

            // check if there is any obstacles on top right half diagonal (d22)
            if (x > obstPosx[i] && obstPosy[i] > y && x - obstPosx[i] == obstPosy[i] - y) {
                d22 = Math.min(d22, x - obstPosx[i] - 1);
            }

            // check if obstacle is straight left from middle horizontally
            if (x == obstPosx[i] && obstPosy[i] < y) {
                r1 = Math.min(r1, y - obstPosy[i] - 1);
            }

            // check if obstacle is straight right from middle horizontally
            if (x == obstPosx[i] && obstPosy[i] > y) {
                r2 = Math.min(r2, obstPosy[i] - y - 1);
            }

            // check if obstacle is straight top from middle vertically
            if (y == obstPosy[i] && obstPosx[i] < x) {
                c1 = Math.min(c1, x - obstPosx[i] - 1);
            }

            // check if obstacle is straight bottom from middle vertically
            if (y == obstPosy[i] && obstPosx[i] > x) {
                c2 = Math.min(c2, obstPosx[i] - x - 1);
            }
        }

        return d11 + d12 + d21 + d22 + r1 + r2 + c1 + c2;
    }

    public static void main(String args[]) {
        int n = 8; // Chessboard size
        int k = 1; // Number of obstacles
        int Qposx = 4; // Queen X Position
        int Qposy = 4; // Queen y position
        int obstPosx[] = {3}; // x position of obstacles
        int obstPosy[] = {4}; // y position of obstacles

        int no =  numberOfPosition(n, k, Qposx, Qposy, obstPosx, obstPosy);
        System.out.println(no);

    }
}


text:
![UvaRegexValidation](https://raw.github.com/inventtoo/UvaRegexValidation/master/design/UvaRegexValidation_mini.png "Logo Uva Regex Validation") *Uva Regex Validation* is a class of static functions to validate strings through regular expressions.

## Regular Expression Rules (RegEx Rules)
| [RegEx][1] | Description                                                  |
| :---------: | ------------------------------------------------------------- |
|/ /        |start delimiter - end delimiter
|^          |star with
|$          |end with
|()         |group, output reference as (?1)(?2)...
|(?<name>)  |name group, output reference as (?P>name) or (?&name) [PHP Manual][2]
|?:         |(?: .... ) don't capture group as output  [StackOverflow Post][3]
||     |or
|\          |escaped
|+          |one or more repetitions (at least 1 repetition)
|*          |zero or more repetitions (optional with multiple repetitions)
|?          |one or zero repetitions (optional 1 repetition)
|{x}        |x repetitions
|{x,y}      |from x to y repetitions
|{x,}       |from x to any repetitions
|a-z        |a to z letters
|A-Z        |A to Z letters
|0-9        |0 to 9 numbers
|.          |any single character (point)
|\\.        |point (escaped point)
|\/         |slash / (escaped slash)
|[xyz]      |matches a single character contained within the brackets, i.e.: x OR y OR z
|[^xyz]     |any character not contained, i.e.: a NOR b NOR c ...
|\d         |equivalence of: [0-9] any number
|\D         |equivalence of: [^0-9] not any number
|\w         |equivalence of: [A-Za-z0-9_] any letter,number,underscore, dot or hyphen
|\W         |equivalence of: [^A-Za-z0-9_] non-word characters
|\a         |equivalence of: [A-Za-z] alphabetic characters
|\l         |equivalence of: [a-z] lower-case letters
|\u         |equivalence of: [A-Z] upper-case letters

[1]: http://en.wikipedia.org/wiki/Regular_expression "Wikipedia"
[2]: http://www.php.net/manual/en/regexp.reference.recursive.php "PHP Manual"
[3]: http://stackoverflow.com/questions/3512471/non-capturing-group "StackOverFlow"
[4]: http://net.tutsplus.com/tutorials/other/8-regular-expressions-you-should-know/ "Tutsplus.com"

##List of functions

###PHP Functions
* **is_array** [\[Manual\]][5]
* **is_string** [\[Manual\]][6]
* **is_object** [\[Manual\]][7]
* **is_bool** - ex: true, false [\[Manual\]][8]
* **is_float (is_double, is_real)**- ex: 23.5, 1e7 [\[Manual\]][9]
* **is_int (is_integer, is_long)** - ex: 23, 86 [\[Manual\]][10]
* **is_null** - ex: null, NULL [\[Manual\]][11]
* **is_numeric** - ex:  "42", 1337, 0x539, 02471, 0b10100111001, 1337e0, 9.1 [\[Manual\]][12]
* **is_scalar** - ex: integer||float||string||boolean [\[Manual\]][13]
[5]: http://mx1.php.net/manual/en/function.is-array.php
[6]: http://mx1.php.net/manual/en/function.is-string.php
[7]: http://mx1.php.net/manual/en/function.is-object.php
[8]: http://mx1.php.net/manual/en/function.is-bool.php
[9]: http://mx1.php.net/manual/en/function.is-float.php
[10]: http://mx1.php.net/manual/en/function.is-int.php
[11]: http://mx1.php.net/manual/en/function.is-null.php
[12]: http://mx1.php.net/manual/en/function.is-numeric.php
[13]: http://mx1.php.net/manual/en/function.is-scalar.php

###Class Functions
* **is_alphabetic** - validate if a string is alphabetic
* **is_alphanumeric** - validate if a string is alphanumeric
* **is_number_string** - validate if a string is numeric
* **is_email** - validate if a string is an e-mail
* **is_hexadecimal_color** - validate if a string is hexadecimal color value
* **is_url** - validate if a string is an URL
* **is_url_image** - validate if a string is an image URL
* **is_url_friendly** - validate if a string is a friendly URL without domain
* **is_ip** - validate if a string is an IP value
* **is_strlen_min(s,l)** - validate the minimum length of a string (string,lenght)
* **is_strlen_max(s,l)** - validate the maximal length of a string (string,lenght)
* **is_strlen_between(s,m,M)** - validate if the string has between min and max characters (string,min,max)
* **is_username(s,m,M)** - validate if a string is a valid username (letters [Upper/Lower-case], point [.], underscore [_]) (string,min,max)
* **is_password(s,m,M)** - validate if a string is a valid password (string,min,max)
* **is_password_secure(s,m,M)** - validate if a string is a valid secure password with special characters (string,min,max)
* **is_personal_name** -validate if a string is a full personal name
* **is_html_tag** - validate if a string is a html tag
* **is_datetime** - validate if a string is a datetime string (yyyy-mm-dd hh:mm:ss)
* **is_time** - validate if a string is a time string (hh:mm:ss)
* **is_date** - validate if a string is a date string ISO-Standard(yyyy-mm-dd)
* **is_date_ddmmyyyy** - validate if a string is a date string (dd-mm-yyyy)
* **is_date_mmddyyyy** - validate if a string is a date string (mm-dd-yyyy)
* **is_date_yyyymmdd** - validate if a string is a date string (yyyy-mm-dd)

##Examples

```php
<?php

var_dump(uva::is_url('http://inventtoo.com'));
//Output: int(1)

var_dump(uva::is_alphabetic('123456'));
//Output: int(0)

var_dump(uva::is_url('test'));
//Output: int(0)
```

##License
This project have a MIT License, so you can modify it, redistribute it, print it, burn it, or whatever you want.


text:
#ifndef __INC_ENTROPY_H
#define __INC_ENTROPY_H

#include "treecoder.h"
#include "blockd.h"

/* Coefficient token alphabet */

#define ZERO_TOKEN              0       /* 0         Extra Bits 0+0 */
#define ONE_TOKEN               1       /* 1         Extra Bits 0+1 */
#define TWO_TOKEN               2       /* 2         Extra Bits 0+1 */
#define THREE_TOKEN             3       /* 3         Extra Bits 0+1 */
#define FOUR_TOKEN              4       /* 4         Extra Bits 0+1 */
#define DCT_VAL_CATEGORY1       5       /* 5-6       Extra Bits 1+1 */
#define DCT_VAL_CATEGORY2       6       /* 7-10      Extra Bits 2+1 */
#define DCT_VAL_CATEGORY3       7       /* 11-26     Extra Bits 4+1 */
#define DCT_VAL_CATEGORY4       8       /* 11-26     Extra Bits 5+1 */
#define DCT_VAL_CATEGORY5       9       /* 27-58     Extra Bits 5+1 */
#define DCT_VAL_CATEGORY6       10      /* 59+       Extra Bits 11+1 */
#define DCT_EOB_TOKEN           11      /* EOB       Extra Bits 0+0 */

#define vp8_coef_tokens 12
#define MAX_ENTROPY_TOKENS vp8_coef_tokens
#define ENTROPY_NODES 11

extern const vp8_tree_index vp8_coef_tree[];

extern struct vp8_token_struct vp8_coef_encodings[vp8_coef_tokens];

typedef struct
{
    vp8_tree_p tree;
    const vp8_prob *prob;
    vp8bc_index_t *prob_bc;
    int Len;
    int base_val;
} vp8_extra_bit_struct;

extern vp8_extra_bit_struct vp8_extra_bits[12];    /* indexed by token value */

#define PROB_UPDATE_BASELINE_COST   7

#define MAX_PROB                255
#define DCT_MAX_VALUE           2048

/* Coefficients are predicted via a 3-dimensional probability table. */

/* Outside dimension.  0 = Y no DC, 1 = Y2, 2 = UV, 3 = Y with DC */

#define BLOCK_TYPES 4

/* Middle dimension is a coarsening of the coefficient's
   position within the 4x4 DCT. */

#define COEF_BANDS 8
extern DECLARE_ALIGNED(16, const unsigned char, vp8_coef_bands[16]);

/* Inside dimension is 3-valued measure of nearby complexity, that is,
   the extent to which nearby coefficients are nonzero.  For the first
   coefficient (DC, unless block type is 0), we look at the (already encoded)
   blocks above and to the left of the current block.  The context index is
   then the number (0,1,or 2) of these blocks having nonzero coefficients.
   After decoding a coefficient, the measure is roughly the size of the
   most recently decoded coefficient (0 for 0, 1 for 1, 2 for >1).
   Note that the intuitive meaning of this measure changes as coefficients
   are decoded, e.g., prior to the first token, a zero means that my neighbors
   are empty while, after the first token, because of the use of end-of-block,
   a zero means we just decoded a zero and hence guarantees that a non-zero
   coefficient will appear later in this block.  However, this shift
   in meaning is perfectly OK because our context depends also on the
   coefficient band (and since zigzag positions 0, 1, and 2 are in
   distinct bands). */

/*# define DC_TOKEN_CONTEXTS        3*/ /* 00, 0!0, !0!0 */
#   define PREV_COEF_CONTEXTS       3

extern DECLARE_ALIGNED(16, const unsigned char, vp8_prev_token_class[vp8_coef_tokens]);

extern const vp8_prob vp8_coef_update_probs [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1];

struct VP8Common;
void vp8_default_coef_probs(struct VP8Common *);

extern DECLARE_ALIGNED(16, const int, vp8_default_zig_zag1d[16]);
extern short vp8_default_zig_zag_mask[16];
extern const int vp8_mb_feature_data_bits[MB_LVL_MAX];

void vp8_coef_tree_initialize(void);
#endif


text:
//---------------------------------------------------------------------
// <copyright file="WriterTestConfiguration.cs" company="Microsoft">
//      Copyright (C) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
// </copyright>
//---------------------------------------------------------------------

namespace Microsoft.Test.Taupo.OData.Writer.Tests.Common
{
    #region Namespaces
    using System;
    using System.Diagnostics;
    using Microsoft.OData.Core;
    using Microsoft.Test.Taupo.OData.Atom;
    using Microsoft.Test.Taupo.OData.Common;
    using Microsoft.Test.Taupo.OData.Contracts;
    #endregion Namespaces

    /// <summary>
    /// Class which wraps all the configurations for a writer test
    /// </summary>
    public sealed class WriterTestConfiguration : TestConfiguration
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="format">The format used for the test.</param>
        /// <param name="messageWriterSettings">The message writer settings used for the test.</param>
        /// <param name="IsRequest">True if the test is writing a request. Otherwise false if it's writing a response.</param>
        /// <param name="synchronous">True if the test should be ran using synchronous API. Otherwise false if it should be ran using asynchronous APIs.</param>
        public WriterTestConfiguration(ODataFormat format, ODataMessageWriterSettings messageWriterSettings, bool IsRequest, bool synchronous)
            : base(format, messageWriterSettings.Version.Value, IsRequest, TestODataBehaviorKind.Default)
        {
            Debug.Assert(messageWriterSettings != null, "messageWriterSettings != null");
            this.Synchronous = synchronous;
            this.MessageWriterSettings = messageWriterSettings;
        }

        /// <summary>
        /// True if the test should be ran using synchronous API. Otherwise false if it should be ran using asynchronous APIs.
        /// </summary>
        public bool Synchronous { get; private set; }

        /// <summary>
        /// The message writer settings used for the test.
        /// </summary>
        public ODataMessageWriterSettings MessageWriterSettings { get; private set; }

        /// <summary>
        /// Returns text represenation of the configuration.
        /// </summary>
        /// <returns>Humanly readable text representation of the configuration. Used for debugging.</returns>
        public override string ToString()
        {
            return string.Format(
                "Format: {0}, Version: {1}, WriterSettings.Indent: {2}, WriterSettings.DisableMessageStreamDisposal: {3}, IsRequest: {4}, Synchronous: {5}",
                this.Format,
                this.Version.ToString(),
                this.MessageWriterSettings.Indent.ToString(),
                this.MessageWriterSettings.DisableMessageStreamDisposal.ToString(),
                this.IsRequest,
                this.Synchronous);
        }

        /// <summary>
        /// Clones the test configuration.
        /// </summary>
        /// <returns>The copied test configuration.</returns>
        public WriterTestConfiguration Clone()
        {
            return new WriterTestConfiguration(this.Format, this.MessageWriterSettings.Clone(), this.IsRequest, this.Synchronous);
        }

        /// <summary>
        /// Applies the specified behavior with default settings.
        /// For detailed settings the caller should use Clone and direct application of behavior to the settings.
        /// </summary>
        /// <param name="behaviorKind">The behavior kind to apply.</param>
        /// <returns>A copy of this configuration with the new behavior applied.</returns>
        public WriterTestConfiguration CloneAndApplyBehavior(TestODataBehaviorKind behaviorKind)
        {
            WriterTestConfiguration testConfiguration = this.Clone();
            switch (behaviorKind)
            {
                case TestODataBehaviorKind.Default:
                    break;
                case TestODataBehaviorKind.WcfDataServicesClient:
                    testConfiguration.MessageWriterSettings.EnableWcfDataServicesClientBehavior();
                    break;
                case TestODataBehaviorKind.WcfDataServicesServer:
                    testConfiguration.MessageWriterSettings.EnableODataServerBehavior(false);
                    break;
            }

            return testConfiguration;
        }
    }
}


text:
// ////////////////////////////////////////////////////////////////////////////
// $Id$
//
// Author: Volkmar Seifert
// Description:
// An abstract base-class for easing automated dialog creation.
//
// ////////////////////////////////////////////////////////////////////////////
// License:
// // // // // // // // // // // // // // // // // // // //
// Copyright 2011 Volkmar Seifert <vs@dimensionv.de>.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY VOLKMAR SEIFERT AND CONTRIBUTORS ``AS IS''
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//
// The views and conclusions contained in the software and documentation are
// those of the authors and should not be interpreted as representing official
// policies, either expressed or implied, of Volkmar Seifert <vs@dimensionv.de>.
// ////////////////////////////////////////////////////////////////////////////
//
// $Log: BaseDialogFragment.java,v $
// Revision 1.2  2013/12/05 21:26:58  mjoellnir
// Bugfixes and improvements
//
// Revision 1.1 2013/10/12 07:29:17 mjoellnir
// Initial commit of the project into the repository
//
//
// ////////////////////////////////////////////////////////////////////////////
package de.dimensionv.android.androdialogs;

import android.app.Activity;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;

import de.dimensionv.android.androdialogs.common.DialogFragmentInterface;
import de.dimensionv.android.androdialogs.common.FragmentDialogController;
import de.dimensionv.android.androdialogs.handlers.ActionHandler;
import de.dimensionv.android.androdialogs.handlers.CancelActionHandler;
import de.dimensionv.android.androdialogs.interceptors.ViewInterceptor;

/**
 *

 * An abstract base-class for easing automated dialog creation.
 *

 *

 * This class will make use of the ConfirmationActionHandler. Should the
 * Activity calling this dialog not implement this interface, a
 * ClassCastException will be thrown with an appropriate error-message.
 *

 *
 * @author Volkmar Seifert
 * @version 1.0
 * @since API 1.0.0
 */
@SuppressWarnings("UnusedDeclaration")
public abstract class BaseDialogFragment<T extends ActionHandler> extends DialogFragment implements DialogFragmentInterface {

  protected FragmentDialogController<T> controller = null;

  /**
   *
Default constructor, actually forwarding to BaseDialogFragment(boolean registerHandler)
   * with registerHandler being set to true.

   */
  public BaseDialogFragment(Class<T> type) {
    this(type, true);
  }

  /**
   *
This constructor initializes the BaseDialogFragment. All descendents must call
   * through to either this or the default constructor.

   *
   *
The registerHandler parameter is used to allow or forbid registering the
   * parent Activity as an ActionHandler.

   *
In case it is forbidden, the method setActionHandler() can (and should) be used
   * to set an ActionHandler manually that can actually be any class, not just the
   * parent Activity.

   *
   * @param registerHandler Flag whether to register an ActionHandler or not.
   */
  public BaseDialogFragment(Class<T> type, boolean registerHandler) {
    controller = new FragmentDialogController<T>(type, registerHandler, this);
  }

  /**
   * Shows an AlertDialog, set the buttons and populate the Dialog with
   * content.
   *
   * @param savedInstanceState
   *          The last saved instance state of the Fragment, or null if this is
   *          a freshly created Fragment.
   * @return Return a new Dialog instance to be displayed by the Fragment.
   */
  @Override
  public Dialog onCreateDialog(Bundle savedInstanceState) {
    return controller.onCreateDialog(savedInstanceState);
  }

  /**
   * Called when a fragment is first attached to its activity. onCreate(Bundle)
   * will be called after this.
   *
   * @param activity
   *          the Activity this dialog is attached to.
   */
  @SuppressWarnings("unchecked")
  @Override
  public void onAttach(Activity activity) {
    super.onAttach(activity);
    controller.onAttach(activity);
  }

  @Override
  public void onCancel(DialogInterface dialog) {
    super.onCancel(dialog);
    ActionHandler actionHandler = controller.getActionHandler();
    if((actionHandler != null) && (actionHandler instanceof CancelActionHandler)) {
      ((CancelActionHandler) actionHandler).onCancel(this);
    }
  }

  /**
   * Abstract method to populate the given builder-object with appropriate
   * content.
   *
   * @param builder
   *          The Builder-object that should be populated and represents the
   *          actual dialog
   * @param arguments The arguments of the DialogFragment, as retrievable via getArguments().
   */
  @Override
  public abstract void populateDialog(Builder builder, Bundle arguments);

  /**
   * @param handler
   *          the handler to set
   */
  public void setActionHandler(T handler) {
    controller.setActionHandler(handler);
  }

  /**
   * Returns the registerHandler flag, which is used to determine whether an ActionHandler
   * should be registered or not.
   *
   * @return the registerHandler
   */
  public boolean isRegisterHandler() {
    return controller.canRegisterHandler();
  }

  /**
   * Sets the flag whether to allow registering of an ActionHandler.
   *
   * @param registerHandler Flag whether to register a handler or not.
   *
   * @see ActionHandler
   */
  public void setRegisterHandler(boolean registerHandler) {
    controller.setRegisterHandler(registerHandler);
  }

  /**
   *
Sets the ViewInterceptor for this BaseDialogFragment.

   *
   * @param interceptor The ViewInterceptor for this BaseDialogFragment.
   *
   * @see ViewInterceptor
   */
  public void setViewInterceptor(ViewInterceptor interceptor) {
    controller.setViewInterceptor(interceptor);
  }

  /**
   *
Returns the ViewInterceptor of this BaseDialogFragment.

   *
   * @return The ViewInterceptor of this BaseDialogFragment.
   */
  protected ViewInterceptor getViewInterceptor() {
    return controller.getViewInterceptor();
  }

  /**
   *
Calls the ViewInterceptor of this BaseDialogFragment.

   *
   * @param view The View containing this dialog's UI elements
   * @return The view that's been handed over to this method.
   */
  protected View callInterceptor(View view) {
    return controller.callInterceptor(view);
  }

  /**
   * Returns the tag under which this dialog can be registered with the fragment manager.
   *
   * @return The default tag under which the dialog can be registered with the FragmentManager.
   */
  public String getDialogTag() {
    return controller.getDialogTag();
  }
}


text:
var App;
(function (App) {
    var Shapes;
    (function (Shapes) {
        var Rectangle = (function () {
            function Rectangle(height, width) {
                this.height = height;
                this.width = width;
            }
            Rectangle.prototype.getArea = function () {
                return this.height * this.width;
            };
            return Rectangle;
        })();
        Shapes.Rectangle = Rectangle;
        Shapes.rect = new Rectangle(10, 4);
    })(Shapes = App.Shapes || (App.Shapes = {}));
})(App || (App = {}));
// can't include module2.ts at runtime (i.e. module2.js) in Node
// so we have it here.
var App;
(function (App) {
    var Shapes;
    (function (Shapes) {
        var Circle = (function () {
            function Circle(radius) {
                this.radius = radius;
            }
            return Circle;
        })();
        Shapes.Circle = Circle;
    })(Shapes = App.Shapes || (App.Shapes = {}));
})(App || (App = {}));
var myProgram;
(function (myProgram) {
    function run() {
        var myRectangle = App.Shapes.rect;
        console.info(myRectangle.height, myRectangle.getArea());
        var yourRectangle = new App.Shapes.Rectangle(9, 6);
        console.info(yourRectangle.height);
        var aCircle = new App.Shapes.Circle(5);
        console.info(aCircle.radius);
    }
    run();
})(myProgram || (myProgram = {}));
var Program2;
(function (Program2) {
    var shapes = App.Shapes;
    function run() {
        var myRectangle = shapes.rect;
        console.info(myRectangle.height, myRectangle.getArea());
        var yourRectangle = new shapes.Rectangle(9, 6);
        console.info(yourRectangle.height);
    }
    run();
})(Program2 || (Program2 = {}));
//# sourceMappingURL=module.js.map


text:
class AddAttachmentIdToMedium < ActiveRecord::Migration
  def self.up
    add_column :media, :attachment_id, :integer, :null => true
    Medium.update_all ('attachment_id = image_id', ['type = ?', 'Picture'])
    Medium.update_all ('attachment_id = movie_id', ['type = ?', 'Video'])
    Medium.update_all ('attachment_id = typescript_id', ['type = ?', 'Document'])
    change_column :media, :attachment_id, :integer, :null => false
    remove_index :media, [:image_id, :movie_id, :typescript_id]
    remove_column :media, :image_id
    remove_column :media, :movie_id
    remove_column :media, :typescript_id
    add_index :media, [:type, :attachment_id], :unique => true
  end

  def self.down
    add_column :media, :image_id, :integer, :null => true
    add_column :media, :movie_id, :integer, :null => true
    add_column :media, :typescript_id, :integer, :null => true
    Medium.update_all ('image_id = attachment_id', ['type = ?', 'Picture'])
    Medium.update_all ('movie_id = attachment_id', ['type = ?', 'Video'])
    Medium.update_all ('typescript_id = attachment_id', ['type = ?', 'Document'])
    add_index :media, [:image_id, :movie_id, :typescript_id]
    remove_index :media, [:type, :attachment_id]
    remove_column :media, :attachment_id
  end
end


text:
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>de.holisticon.jdk9showcase</groupId>
    <artifactId>jdk9-jigsaw-http2</artifactId>
    <version>1.0</version>

    <properties>
        <java.version>9</java.version>
        <java.9.executable>
            /Library/Java/JavaVirtualMachines/jdk-9_153.jdk/Contents/Home/bin/java
        </java.9.executable>
        <additionalRuntimeArgLine>
            --add-modules=java.xml.bind,jdk.incubator.httpclient,java.base
        </additionalRuntimeArgLine>
        <!-- @formatter:off -->
        <java.logging.format><![CDATA[
            -Djava.util.logging.SimpleFormatter.format=%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS || %5$s %6$s%n]]>
        </java.logging.format>
        <!-- @formatter:on -->
        <!--
       <java.logging.format>-Djava.util.logging.SimpleFormatter.format=%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n</java.logging.format>
         -->
    </properties>
    <profiles>
        <profile>
            <id>ResponseAsyncExample</id>
            <activation>
                <!-- Java 9 doesn't identify itself as "1.9" but "9" -->
                <jdk>9</jdk>
            </activation>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <version>1.5.0</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>exec</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <executable>${java.9.executable}</executable>
                            <arguments>
                                <argument>-Xmx2048m</argument>
                                <argument>${java.logging.format}</argument>
                                <argument>-classpath</argument>
                                <classpath/>
                                <argument>${additionalRuntimeArgLine}</argument>
                                <argument>
                                    de.holisticon.jdk9showcase.http2client.ResponseAsyncExample
                                </argument>
                            </arguments>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>

        <profile>
            <id>ResponseAsyncCompare</id>
            <activation>
                <!-- Java 9 doesn't identify itself as "1.9" but "9" -->
                <jdk>9</jdk>
            </activation>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <version>1.5.0</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>exec</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <executable>${java.9.executable}</executable>
                            <arguments>
                                <argument>-Xmx4096m</argument>
                                <argument>${java.logging.format}</argument>
                                <argument>-classpath</argument>
                                <classpath/>
                                <argument>${additionalRuntimeArgLine}</argument>
                                <argument>
                                    de.holisticon.jdk9showcase.http2client.ResponseAsyncCompare
                                </argument>
                                <argument>${httpVersion}</argument>
                                <argument>${numberOfRequests}</argument>
                            </arguments>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>ResponseAsyncMultiExample</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <version>1.5.0</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>exec</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <executable>${java.9.executable}</executable>
                            <arguments>
                                <argument>${java.logging.format}</argument>
                                <argument>-classpath</argument>
                                <classpath/>
                                <argument>${additionalRuntimeArgLine}</argument>
                                <argument>
                                    de.holisticon.jdk9showcase.http2client.ResponseAsyncMultiExample
                                </argument>
                            </arguments>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>CancelClientExample</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.mojo</groupId>
                        <artifactId>exec-maven-plugin</artifactId>
                        <version>1.5.0</version>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>exec</goal>
                                </goals>
                            </execution>
                        </executions>
                        <configuration>
                            <executable>${java.9.executable}</executable>
                            <arguments>
                                <argument>${java.logging.format}</argument>
                                <argument>-classpath</argument>
                                <classpath/>
                                <argument>${additionalRuntimeArgLine}</argument>
                                <argument>
                                    de.holisticon.jdk9showcase.http2client.CancelClientExample
                                </argument>
                            </arguments>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-toolchains-plugin</artifactId>
                <version>1.1</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>toolchain</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <toolchains>
                        <jdk>
                            <version>1.9</version>
                        </jdk>
                    </toolchains>
                </configuration>
            </plugin>
            <!-- -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <verbose>true</verbose>
                    <fork>true</fork>
                    <source>9</source>
                    <target>9</target>
                    <jdkToolchain>
                        <version>9</version>
                    </jdkToolchain>
                    <release>9</release>
                    <compilerArgs>
                        <arg>-verbose</arg>

                    </compilerArgs>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <filesets>
                        <fileset>
                            <directory>${basedir}/downloads/ResponseAsync
                            </directory>
                            <includes>
                                <include>**/*.*</include>
                            </includes>
                            <excludes>
                                <eclude>
                                    info.md
                                </eclude>
                            </excludes>
                            <followSymlinks>false</followSymlinks>
                        </fileset>
                        <fileset>
                            <directory>${basedir}/downloads/ResponseAsyncMulti
                            </directory>
                            <includes>
                                <include>**/*.*</include>
                            </includes>
                            <excludes>
                                <eclude>
                                    info.md
                                </eclude>
                            </excludes>
                            <followSymlinks>false</followSymlinks>
                        </fileset>
                    </filesets>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
    </dependencies>
    <pluginRepositories>
        <pluginRepository>
            <id>apache.snapshots</id>
            <url>http://repository.apache.org/snapshots/</url>
        </pluginRepository>
    </pluginRepositories>
</project>


text:
namespace CH.Testing.T2.Interface
{
    internal interface IArgMapping
    {
    }
}


text:
<?php

namespace Cake\Database;

/**
 * Exception for the database package.
 */
class Exception extends \Cake\Core\Exception\Exception
{

}


text:
namespace remoting {

namespace {

FileChooser::Result& StaticResult() {
  static base::NoDestructor<FileChooser::Result> result(
      protocol::MakeFileTransferError(
          FROM_HERE, protocol::FileTransfer_Error_Type_CANCELED));
  return *result;
}

}  // namespace

std::unique_ptr<FileChooser> FileChooser::Create(
    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
    ResultCallback callback) {
  return std::make_unique<FakeFileChooser>(std::move(callback));
}

FakeFileChooser::FakeFileChooser(FileChooser::ResultCallback callback)
    : callback_(std::move(callback)) {}

FakeFileChooser::~FakeFileChooser() = default;

void FakeFileChooser::Show() {
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE, base::BindOnce(std::move(callback_), StaticResult()));
}

void FakeFileChooser::SetResult(FileChooser::Result result) {
  StaticResult() = std::move(result);
}

}  // namespace remoting


text:
module BohFoundation.UserAccount.Manage.Models {
    'use strict';
    export class ChangePasswordModel {
        constructor(public oldPassword: string, public newPassword: string) { }
    }
}


text:
package pl.kmi.adventofcode.day1;

public class Santa {

    private long currentFloor;

    public Santa(long currentFloor) {
        this.currentFloor = currentFloor;
    }

    public void go(char direction) {
        if (direction == '(') {
            currentFloor++;
        } else if (direction == ')') {
            currentFloor--;
        } else {
            throw new LostSantaException(
                    String.format("Cannot parse direction. Invalid direction description: '%s'", direction)
            );
        }
    }

    public long getCurrentFloor() {
        return currentFloor;
    }
}


text:
@interface ResponseDownload : NSObject
@end


text:
package MathML;

 class RealNumber extends ASTNumber {
    Double real = 0d;
    long intVal=0;
    final  int UNKNOWN=1;
    final int INTEGER=2;
    final int DOUBLE=1;
    int type=UNKNOWN;

	 RealNumber(Double value) {
		super(ASTNumberType.NUMBER);
		this.real=value;
		type=DOUBLE;
		setName(getString());
	}
	 RealNumber(int n) {
		super(ASTNumberType.NUMBER);
		this.intVal=n;
		type=INTEGER;
		setName(getString());
	}

	 RealNumber(long n) {
			super(ASTNumberType.NUMBER);
			this.intVal=n;
			type=INTEGER;
			setName(getString());
		}

	public long getIntValue() {
		return intVal;
	}
	@Override
	public String getString() {
		if (type==INTEGER) {
			return Long.toString(intVal);
		}
		else if (type==DOUBLE) {
			if(isInfinity())
			return "infinity";
			else if (real==Double.NEGATIVE_INFINITY)
			return "-infinity";
			else if (isNaN())
				return "notanumber";
			else if(isE()){
				return "exponentiale";
			}else if (isPI()){
				return "pi";
			}
			else return Double.toString(real);
		}
		return Double.toString(Double.NaN);
	}
	@Override
	public double getValue() {
		return type==INTEGER?intVal:real;
	}

	public  boolean isInteger(){
		return type==INTEGER?true:false;
	}

}


text:
var should = require('should'),
  example = require('./../index.js'),
  mwcCore = require('mwc_kernel'),
  config = require('./config.json').development;

/*
// it is not the test for socket.io plugin
describe('mwc plugin example', function() {
  var MWC;

  before(function() {
    MWC = new mwcCore(config);
    MWC.usePlugin(example);
    MWC.listen();
  });

  describe('#extendApp', function() {

    it('should set Var1 with the value \'42\'', function() {
      MWC.app.get('Var1').should.equal('42');
    });

  });

});
*/