text:
Wolkenbruch.Puzzle = function (scene, camera, renderer) {

    var that = this;

    this.scene = scene;
    this.camera = camera;
    this.renderer = renderer;

    this.activeElements = [];

    InputModule.dragConsumer = this;

    var hexahedronTarget = {
        x: 0.05,
        y: 0.05,
        distanceX: function (x) {
            return x;
        },
        distanceY: function (y) {
            return y;
        }
    };
    var polygonalPrismTarget = {
        x: 1.0,
        y: 0.05,
        distanceX: function (x) {
            return x - 1.0;
        },
        distanceY: function (y) {
            return y;
        }
    };
    var octahedronTarget = {
        x: 0.05,
        y: 2.0,
        distanceX: function (x) {
            return x;
        },
        distanceY: function (y) {
            return y - 1.0;
        }
    };
    var sphericalPolyhedronTarget = {
        x: 1.0,
        y: 1.0,
        distanceX: function (x) {
            return x - 1.0;
        },
        distanceY: function (y) {
            return y - 1.0;
        }
    };

    this.elementTargets = [hexahedronTarget, polygonalPrismTarget, octahedronTarget, sphericalPolyhedronTarget];

    var spaceX = 5.0;
    var spaceY = 5.0;

    this.spaceX = spaceX;
    this.spaceY = spaceY;

    var numElementsX = 5;
    var numElementsY = 5;
    var elementScaleX = spaceX / numElementsX;
    var elementScaleY = spaceY / numElementsY;
    this.elements = [];
    for (var y = 0; y < numElementsY; y++) {
        for (var x = 0; x < numElementsX; x++) {

            var sizeX = 0.5 * elementScaleX;
            var sizeY = 0.5 * elementScaleY;

            var posx = (x - numElementsX / 2) * elementScaleX + sizeX;
            var posy = (y - numElementsY / 2) * elementScaleY + sizeY + 2.0;
            var posz = 0.0;

            var sq = new Wolkenbruch.SuperQuadric(scene);
            sq.mesh.position.x = posx;
            sq.mesh.position.y = posy;
            sq.mesh.position.z = posz;
            sq.mesh.scale.x = elementScaleX;
            sq.mesh.scale.y = elementScaleY;
            sq.mesh.scale.z = elementScaleX;

            var pos = new THREE.Vector3(posx, posy, posz);
            var min = new THREE.Vector3(-sizeX, -sizeY, -sizeX).add(pos);
            var max = new THREE.Vector3(sizeX, sizeY, sizeX).add(pos);
            var aabb = new THREE.Box3(min, max);

            var length = this.elements.push(
            {
                pos: pos,
                morphx: 0.5,
                morphy: 0.5,
                morphTargetX: Math.round(Math.random()),
                morphTargetY: Math.round(Math.random()),
                morphvx: 0.0,
                morphvy: 0.0,
                sq: sq,
                aabb: aabb,
                neighbors: []
            });
            this.updateElement(length - 1);
        }
    }

    var dirs = [
        new THREE.Vector3(0, 0, 1),
        new THREE.Vector3(0, 0, -1),
        new THREE.Vector3(0, 1, 0),
        new THREE.Vector3(0, -1, 0),
        new THREE.Vector3(1, 0, 0),
        new THREE.Vector3(-1, 0, 0),
    ];

    // collect list of direct neighbors (von Neumann neighborhood) for each element
    for (var e = 0; e < this.elements.length; e++) {
        for (var d = 0; d < 6; d++) {
            var minDist = Infinity;
            var neighborIndex = -1;
            var ray = new THREE.Ray(this.elements[e].pos, dirs[d]);
            for (var eo = 0; eo < this.elements.length; eo++) {
                if (e == eo) continue;
                var el = this.elements[eo];

                var result = ray.intersectBox(el.aabb);

                if (result) {
                    var dist = ray.origin.distanceToSquared(result);
                    if (dist < minDist) {
                        minDist = dist;
                        neighborIndex = eo;
                    }
                }
            }
            if (neighborIndex >= 0) {
                this.elements[e].neighbors.push(neighborIndex);
            }
        }
    }
};

Wolkenbruch.Puzzle.prototype = {
    update: function () {

        var dt = Wolkenbruch.smoothDelta;
        var snappingSpeed = 10.0;

        for (var e = 0; e < this.elements.length; e++) {

            var el = this.elements[e];
            var isActive = (this.activeElements.indexOf(e) >= 0);

            var dx = el.morphTargetX - el.morphx + el.morphvx;
            var dy = el.morphTargetY - el.morphy + el.morphvy;
            //var dx = el.morphTargetX - el.morphx;
            //var dy = el.morphTargetY - el.morphy;

            var snappingSpeed = 20.0;

            if (isActive) {
                snappingSpeed *= 10;
            } else {

                // snap all inactive elements to their destination shape
                if (el.morphvx !== 0.0 && el.morphvy !== 0.0) {

                    var vTan = Math.abs(el.morphvx / el.morphvy);

                    if (vTan < 0.5) {
                        dx = 0.0;
                    }
                    if (vTan > 2.0) {
                        dy = 0.0;
                    }
                }

                if (dx == 0.0) {
                    dx = el.morphx - 0.5;
                }
                if (dy == 0.0) {
                    dy = el.morphy - 0.5;
                }

                el.morphTargetX = (dx > 0.0) ? 1.0 : 0.0;
                el.morphTargetY = (dy > 0.0) ? 1.0 : 0.0;
            }

            var constantSnappingSpeed = Math.min(1.0,dt * snappingSpeed);

            dx = el.morphTargetX - el.morphx;
            dy = el.morphTargetY - el.morphy;
            if(Math.abs(dx) > 0.001 || Math.abs(dy) > 0.001) {
                el.morphx = Math.min(1.0, Math.max(0.0, el.morphx + dx * constantSnappingSpeed));
                el.morphy = Math.min(1.0, Math.max(0.0, el.morphy + dy * constantSnappingSpeed));
                this.updateElement(e);
            }
        }
    },
    updateElement: function (elementIndex) {
        var element = this.elements[elementIndex];
        var n = 0.0;
        var e = 0.0;
        for (var t = 0; t < this.elementTargets.length; t++) {
            var target = this.elementTargets[t];
            var dx = Math.max(0.0, 1.0 - Math.abs(target.distanceX(element.morphx)));
            var dy = Math.max(0.0, 1.0 - Math.abs(target.distanceY(element.morphy)));
            var d = dx * dy;    // results in linear interpolation

            n += target.x * d;
            e += target.y * d;
        }

        var neRadNS = element.sq.mat.uniforms.neRadNS.value;
        neRadNS.x = n;
        neRadNS.y = e;
    },
    consumeDragging: function (x, y, dx, dy) {

        if (this.activeElements.length == 0) {
            var mouse = new THREE.Vector2();

            mouse.x = 2 * (x / this.renderer.domElement.clientWidth) - 1;
            mouse.y = 1 - 2 * (y / this.renderer.domElement.clientHeight);

            var raycaster = new THREE.Raycaster();
            raycaster.setFromCamera(mouse, this.camera);

            var touchedElementIndex = -1;
            var minDist = Infinity;
            for (var e = 0; e < this.elements.length; e++) {
                var el = this.elements[e];

                var result = raycaster.ray.intersectBox(el.aabb);

                if (result) {
                    var dist = raycaster.ray.origin.distanceToSquared(result);
                    if (dist < minDist) {
                        minDist = dist;
                        touchedElementIndex = e;
                    }
                }
            }

            AudioModule.play("swipe");

            if (touchedElementIndex < 0) {
                this.activeElements = [];
            } else {
                this.activeElements.push(touchedElementIndex);
                // get a list of all neighbors with same morph values to move them along
                this.computeAllEqualNeighbors(touchedElementIndex, this.activeElements);
            }
        }

        if (this.activeElements.length > 0) {
            var maxSpeed = 3.0;
            dSqr = dx * dx + dy * dy;
            if (dSqr > maxSpeed * maxSpeed) {
                var dScale = maxSpeed / Math.sqrt(dSqr);
                dx *= dScale;
                dy *= dScale;
            }

            for (var e = 0; e < this.activeElements.length; e++) {
                var activeElementIndex = this.activeElements[e];
                var el = this.elements[activeElementIndex];
                var oldMorphTargetX = el.morphTargetX;
                var oldMorphTargetY = el.morphTargetY;
                el.morphTargetX = Math.min(1.0, Math.max(0.0, el.morphTargetX + dx * 0.02));
                el.morphTargetY = Math.min(1.0, Math.max(0.0, el.morphTargetY + dy * 0.02));
                el.morphvx = el.morphTargetX - oldMorphTargetX;
                el.morphvy = el.morphTargetY - oldMorphTargetY;
            }
        }
    },
    consumeDraggingEnd: function () {
        this.activeElements = [];
    },
    computeAllEqualNeighbors: function (elementIndex, elements) {
        var el = this.elements[elementIndex];

        for (var n = 0; n < el.neighbors.length; n++) {
            var ni = el.neighbors[n];
            if (elements.indexOf(ni) < 0 &&
                this.elements[ni].morphTargetX == el.morphTargetX &&
                this.elements[ni].morphTargetY == el.morphTargetY) {
                elements.push(ni);

                this.computeAllEqualNeighbors(ni, elements);
            }
        }
    },
    destroy: function () {
        for (var e = 0; e < this.elements.length; e++) {
            this.elements[e].sq.destroy();
        }
    }
};


text:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using Semver;
using Umbraco.Core.Configuration;
using Umbraco.Core.Persistence.Migrations;

namespace Umbraco.Core.Events
{
    public class MigrationEventArgs : CancellableObjectEventArgs<IList<IMigration>>, IEquatable<MigrationEventArgs>
    {
        /// <summary>
        /// Constructor accepting multiple migrations that are used in the migration runner
        /// </summary>
        /// <param name="eventObject"></param>
        /// <param name="targetVersion"></param>
        /// <param name="productName"></param>
        /// <param name="canCancel"></param>
        /// <param name="configuredVersion"></param>
        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, string productName, bool canCancel)
            : this(eventObject, null, configuredVersion, targetVersion, productName, canCancel)
        { }

        /// <summary>
        /// Constructor accepting multiple migrations that are used in the migration runner
        /// </summary>
        /// <param name="eventObject"></param>
        /// <param name="targetVersion"></param>
        /// <param name="canCancel"></param>
        /// <param name="configuredVersion"></param>
        [Obsolete("Use constructor accepting a product name instead.")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
            : this(eventObject, null, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName, canCancel)
        { }

        [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion, bool canCancel)
			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), Constants.System.UmbracoMigrationName, canCancel)
         { }

        /// <summary>
        /// Constructor accepting multiple migrations that are used in the migration runner
        /// </summary>
        /// <param name="eventObject"></param>
        /// <param name="migrationContext"></param>
        /// <param name="targetVersion"></param>
        /// <param name="productName"></param>
        /// <param name="canCancel"></param>
        /// <param name="configuredVersion"></param>
        internal MigrationEventArgs(IList<IMigration> eventObject, MigrationContext migrationContext, SemVersion configuredVersion, SemVersion targetVersion, string productName, bool canCancel)
            : base(eventObject, canCancel)
        {
            MigrationContext = migrationContext;
            ConfiguredSemVersion = configuredVersion;
            TargetSemVersion = targetVersion;
            ProductName = productName;
        }

        /// <summary>
        /// Constructor accepting multiple migrations that are used in the migration runner
        /// </summary>
        /// <param name="eventObject"></param>
        /// <param name="migrationContext"></param>
        /// <param name="targetVersion"></param>
        /// <param name="canCancel"></param>
        /// <param name="configuredVersion"></param>
        [Obsolete("Use constructor accepting a product name instead.")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        internal MigrationEventArgs(IList<IMigration> eventObject, MigrationContext migrationContext, SemVersion configuredVersion, SemVersion targetVersion, bool canCancel)
            : base(eventObject, canCancel)
        {
            MigrationContext = migrationContext;
            ConfiguredSemVersion = configuredVersion;
            TargetSemVersion = targetVersion;
            ProductName = Constants.System.UmbracoMigrationName;
        }

        /// <summary>
        /// Constructor accepting multiple migrations that are used in the migration runner
        /// </summary>
        /// <param name="eventObject"></param>
        /// <param name="configuredVersion"></param>
        /// <param name="targetVersion"></param>
        /// <param name="productName"></param>
        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion, string productName)
            : this(eventObject, null, configuredVersion, targetVersion, productName, false)
        { }

        /// <summary>
        /// Constructor accepting multiple migrations that are used in the migration runner
        /// </summary>
        /// <param name="eventObject"></param>
        /// <param name="configuredVersion"></param>
        /// <param name="targetVersion"></param>
        [Obsolete("Use constructor accepting a product name instead.")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public MigrationEventArgs(IList<IMigration> eventObject, SemVersion configuredVersion, SemVersion targetVersion)
            : this(eventObject, null, configuredVersion, targetVersion, Constants.System.UmbracoMigrationName, false)
        { }

        [Obsolete("Use constructor accepting SemVersion instances and a product name instead.")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public MigrationEventArgs(IList<IMigration> eventObject, Version configuredVersion, Version targetVersion)
			: this(eventObject, null, new SemVersion(configuredVersion), new SemVersion(targetVersion), Constants.System.UmbracoMigrationName, false)
		{ }

		/// <summary>
		/// Returns all migrations that were used in the migration runner
		/// </summary>
        public IList<IMigration> Migrations
		{
			get { return EventObject; }
		}

        [Obsolete("Use ConfiguredSemVersion instead")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public Version ConfiguredVersion
        {
            get { return ConfiguredSemVersion.GetVersion(); }
        }

        [Obsolete("Use TargetUmbracoVersion instead")]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public Version TargetVersion
        {
            get { return TargetSemVersion.GetVersion(); }
        }

        /// <summary>
        /// Gets the origin version of the migration, i.e. the one that is currently installed.
        /// </summary>
        public SemVersion ConfiguredSemVersion { get; private set; }

        /// <summary>
        /// Gets the target version of the migration.
        /// </summary>
        public SemVersion TargetSemVersion { get; private set; }

        public string ProductName { get; private set; }

        internal MigrationContext MigrationContext { get; private set; }

        public bool Equals(MigrationEventArgs other)
        {
            if (ReferenceEquals(null, other)) return false;
            if (ReferenceEquals(this, other)) return true;
            return base.Equals(other) && ConfiguredSemVersion.Equals(other.ConfiguredSemVersion) && MigrationContext.Equals(other.MigrationContext) && string.Equals(ProductName, other.ProductName) && TargetSemVersion.Equals(other.TargetSemVersion);
        }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj)) return false;
            if (ReferenceEquals(this, obj)) return true;
            if (obj.GetType() != this.GetType()) return false;
            return Equals((MigrationEventArgs) obj);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hashCode = base.GetHashCode();
                hashCode = (hashCode * 397) ^ ConfiguredSemVersion.GetHashCode();
                hashCode = (hashCode * 397) ^ MigrationContext.GetHashCode();
                hashCode = (hashCode * 397) ^ ProductName.GetHashCode();
                hashCode = (hashCode * 397) ^ TargetSemVersion.GetHashCode();
                return hashCode;
            }
        }

        public static bool operator ==(MigrationEventArgs left, MigrationEventArgs right)
        {
            return Equals(left, right);
        }

        public static bool operator !=(MigrationEventArgs left, MigrationEventArgs right)
        {
            return !Equals(left, right);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
/**
 *
 */
package com.juxtapose.example.ch06.jpa;

import java.util.ArrayList;
import java.util.List;

import org.springframework.batch.item.ItemWriter;

/**
 *
 * @author bruce.liu(mailto:jxta.liu@gmail.com)
 * 2013-9-1上午09:04:55
 */
public class DummyCreditItemWriter implements ItemWriter<CreditBill> {

	public List<CreditBill> creditBills = new ArrayList<CreditBill>();

	public void write(List<? extends CreditBill> items) throws Exception {
		creditBills.addAll(items);
	}

	public List<CreditBill> getCredits() {
		return creditBills;
	}
}


text:
using System;
using NBM.Plugin;
using WinForms = System.Windows.Forms;

// 8/5/03

namespace NBM
{
	/// <summary>
	/// Context menu for the protocols
	/// </summary>
	public class ProtocolMenu : WinForms.ContextMenu, IProtocolListener
	{
		private MainForm mainForm;
		private Protocol protocol;

		private StatusMenu statusMenu;
		private WinForms.MenuItem addFriendItem, debugReportItem, optionsItem, connectItem, disconnectItem;

		/// <summary>
		/// Constructs a ProtocolMenu
		/// </summary>
		/// <param name="mainForm"></param>
		/// <param name="protocol"></param>
		public ProtocolMenu(MainForm mainForm, Protocol protocol)
		{
			this.mainForm = mainForm;
			this.protocol = protocol;
			this.protocol.AddListener(this);

			// add connect and disconnect menu items
			this.statusMenu = new StatusMenu("Status", new EventHandler(OnStatusClick));

			foreach (StatusMenuItem item in this.statusMenu.MenuItems)
			{
				item.RadioCheck = true;
				item.Checked = item.Status == this.protocol.Settings.Status;
			}

			this.MenuItems.Add(statusMenu);
			this.MenuItems.Add("-");

			this.connectItem = new WinForms.MenuItem("Connect", new EventHandler(connectMenuItem_Click));
			this.MenuItems.Add(this.connectItem);

			this.disconnectItem = new WinForms.MenuItem("Disconnect", new EventHandler(disconnectMenuItem_Click));
			this.disconnectItem.Enabled = false;
			this.MenuItems.Add(this.disconnectItem);
			this.MenuItems.Add("-");

			this.optionsItem = new WinForms.MenuItem("Options", new EventHandler(optionsMenuItem_Click));
			this.MenuItems.Add(this.optionsItem);
			this.MenuItems.Add("-");

			this.addFriendItem = new WinForms.MenuItem("Add friend", new EventHandler(addfriendMenuItem_Click));
			this.addFriendItem.Enabled = false;
			this.MenuItems.Add(this.addFriendItem);

			this.MenuItems.Add("-");

			this.debugReportItem = new WinForms.MenuItem("Debug Report", new EventHandler(debugReportMenuItem_Click));
			this.MenuItems.Add(this.debugReportItem);

			this.Disposed += new EventHandler(OnDispose);

//			this.MenuItems.Add("Self Destruct", new EventHandler(selfdestruct_click));
		}

		private void OnStatusClick(object sender, EventArgs e)
		{
			this.protocol.ChangeStatus(((StatusMenuItem)sender).Status, new OperationCompleteEvent());
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void OnDispose(object sender, EventArgs e)
		{
			if (this.protocol != null)
				this.protocol.RemoveListener(this);
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void connectMenuItem_Click(object sender, System.EventArgs e)
		{
			protocol.Connect(new OperationCompleteEvent());
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void disconnectMenuItem_Click(object sender, System.EventArgs e)
		{
			protocol.Disconnect(new OperationCompleteEvent());
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void addfriendMenuItem_Click(object sender, System.EventArgs e)
		{
			if (this.protocol.Connected)
			{
				// show add friend dialog
				AddFriendForm form = new AddFriendForm(this.protocol);
				if (form.ShowDialog() == WinForms.DialogResult.OK)
				{
					this.protocol.AddFriendToList(form.Username, form.Message, new OperationCompleteEvent());
				}
			}
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void debugReportMenuItem_Click(object sender, System.EventArgs e)
		{
			this.protocol.Reporter.Show();
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void optionsMenuItem_Click(object sender, System.EventArgs e)
		{
			OptionsForm form = new OptionsForm(this.mainForm, this.protocol);
			form.Show();
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		private void selfdestruct_click(object sender, EventArgs e)
		{
			this.protocol.SelfDestruct();
		}

		#region ProtocolListener methods

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		public void OnFriendAdd(Friend friend)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		public void OnFriendRemove(Friend friend)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		/// <param name="status"></param>
		public void OnFriendChangeStatus(Friend friend, OnlineStatus status)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		/// <param name="newName"></param>
		public void OnFriendChangeDisplayName(Friend friend, string newName)
		{
		}

		/// <summary>
		///
		/// </summary>
		public void OnBeginConnect()
		{
		}

		/// <summary>
		///
		/// </summary>
		public void OnConnect()
		{
			this.addFriendItem.Enabled = true;
			this.connectItem.Enabled = false;
			this.disconnectItem.Enabled = true;
		}

		/// <summary>
		/// Called when the connection is canceled
		/// </summary>
		public void OnConnectCanceled()
		{
			this.addFriendItem.Enabled = false;
			this.disconnectItem.Enabled = false;
			this.connectItem.Enabled = true;
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="forced"></param>
		public void OnDisconnect(bool forced)
		{
			this.addFriendItem.Enabled = false;
			this.disconnectItem.Enabled = false;
			this.connectItem.Enabled = true;
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="status"></param>
		public void OnChangeStatus(OnlineStatus status)
		{
			foreach (StatusMenuItem item in this.statusMenu.MenuItems)
			{
				item.Checked = item.Status == status;
			}
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		/// <param name="opCompleteEvent"></param>
		/// <param name="tag"></param>
		public void OnInvitedToConversation(Friend friend, OperationCompleteEvent opCompleteEvent, object tag)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="username"></param>
		public void OnAddFriendToList(string username)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		public void OnRemoveFriendFromList(Friend friend)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		public void OnBlockFriend(Friend friend)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		public void OnUnblockFriend(Friend friend)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="text"></param>
		public void OnWriteDebug(string text)
		{
		}

		/// <summary>
		///
		/// </summary>
		/// <param name="friend"></param>
		/// <param name="reason"></param>
		/// <param name="enableAddCheckbox"></param>
		public void OnPromptForStrangerHasAddedMe(Friend friend, string reason, bool enableAddCheckbox)
		{
		}

		#endregion
	}
}


text:
#import <Foundation/Foundation.h>

@class SFOAuthCoordinator;
@class SFSDKTestCredentialsData;

/**
 This class provides utilities useful to all unit tests based on the Salesforce SDK
 */
@interface TestSetupUtils : NSObject

/**
 Loads a set of auth credentials from the 'test_credentials.json' file located in the bundle
 of the app, and configures SFUserAccountManager and the current account with the data from
 that file.
 @return The configuration data used to configure SFUserAccountManager (useful e.g. for hybrid
 apps which need the data to bootstrap SFHybridViewController).
 */
+ (SFSDKTestCredentialsData *)populateAuthCredentialsFromConfigFile;

/**
 Performs a synchronous refresh of the OAuth credentials, which will stage the remaining auth
 data (access token, User ID, Org ID, etc.) in SFUserAccountManager.
 `populateAuthCredentialsFromConfigFile` is required to run once before this method will attempt
 to refresh authentication.
 */
+ (void)synchronousAuthRefresh;

@end


text:
package org.wikipedia.editing;

import android.os.Parcel;
import android.os.Parcelable;
import org.json.JSONObject;

public class AbuseFilterEditResult extends EditingResult {
    public static final int TYPE_WARNING = 1;
    public static final int TYPE_ERROR = 2;

    private final String code;
    private final String info;
    private final String warning;

    public AbuseFilterEditResult(JSONObject result) {
        super("Failure");
        this.code = result.optString("code");
        this.info = result.optString("info");
        this.warning = result.optString("warning");
    }

    protected AbuseFilterEditResult(Parcel in) {
        super(in);
        code = in.readString();
        info = in.readString();
        warning = in.readString();
    }

    public String getCode() {
        return code;
    }

    public String getInfo() {
        return info;
    }

    public String getWarning() {
        return warning;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        super.writeToParcel(dest, flags);
        dest.writeString(code);
        dest.writeString(info);
        dest.writeString(warning);
    }

    public int getType() {
        if (code.startsWith("abusefilter-warning")) {
            return TYPE_WARNING;
        } else if (code.startsWith("abusefilter-disallowed")) {
            return TYPE_ERROR;
        } else if (info.startsWith("Hit AbuseFilter")) {
            // This case is here because, unfortunately, an admin can create an abuse filter which
            // emits an arbitrary error code over the API.
            // TODO: More properly handle the case where the AbuseFilter throws an arbitrary error.
            // Oh, and, you know, also fix the AbuseFilter API to not throw arbitrary error codes.
            return TYPE_ERROR;
        } else {
            // We have no understanding of what kind of abuse filter response we got. It's safest
            // to simply treat these as an error.
            return TYPE_ERROR;
        }
    }

    public static final Parcelable.Creator<AbuseFilterEditResult> CREATOR
            = new Parcelable.Creator<AbuseFilterEditResult>() {
        @Override
        public AbuseFilterEditResult createFromParcel(Parcel in) {
            return new AbuseFilterEditResult(in);
        }

        @Override
        public AbuseFilterEditResult[] newArray(int size) {
            return new AbuseFilterEditResult[size];
        }
    };
}


text:
<?php

defined('_JEXEC') or die();

jimport( 'joomla.application.component.model' );

class jdownloadsModellayouts extends JModelLegacy
{

	/**
	 * Constructor
	 *
	 */
	function __construct()
	{
		parent::__construct();

        $option = 'com_jdownloads';
        $app = JFactory::getApplication();
	}

}


text:
package com.trsvax.datepicker.app.pages;

import java.util.Date;

import org.apache.tapestry5.annotations.Property;

public class Index {

	@Property
	private Date date;

}


text:
/*
	This is a haggle main function. It's purpose is to let the testsuite run
	a haggle kernel without the need to start a separate program that is haggle.
*/

#include "hagglemain.h"

#include <libcpphaggle/Thread.h>
#include "DataManager.h"
#include "NodeManager.h"
#include "ProtocolManager.h"
#include "ProtocolUDP.h"
#include "ConnectivityManager.h"
#include "ForwardingManager.h"
#include "SecurityManager.h"
#include "ApplicationManager.h"
#include "ResourceManager.h"

#include "SQLDataStore.h"
#include <libcpphaggle/Exception.h>

using namespace haggle;

#if defined(OS_WINDOWS)
#define TEST_SQL_DATABASE	"test.db"
#else
#define TEST_SQL_DATABASE	"/tmp/test.db"
#endif

class hidden_hagglemainRunnable;

static hidden_hagglemainRunnable	*current_haggle = NULL;
HaggleKernel *kernel = NULL;
static bool shutdown_started = false;

static Condition *signalling_condition;

class hidden_hagglemainRunnable : public Runnable {
	long flags;
public:
	hidden_hagglemainRunnable(long _flags) : flags(_flags) {}
	~hidden_hagglemainRunnable() {}

	bool run()
	{
		ApplicationManager *am = NULL;
		DataManager *dm = NULL;
		NodeManager *nm = NULL;
		ProtocolManager *pm = NULL;
		ForwardingManager *fm = NULL;
		SecurityManager *sm = NULL;
		ConnectivityManager *cm = NULL;
		ResourceManager *rm = NULL;

		/* Seed the random number generator */
		srand(Timeval::now().getMicroSeconds());

		try{
			kernel = new HaggleKernel(new SQLDataStore(true, TEST_SQL_DATABASE));
		}catch (Exception&){
			kernel = NULL;
		}

		if(!kernel)
		{
			return false;
		}

		// Build a Haggle configuration
		try{
			ProtocolSocket *p = NULL;

			if(flags & hagglemain_have_application_manager)
			{
				am = new ApplicationManager(kernel);
			}

			if(flags & hagglemain_have_data_manager)
			{
				dm = new DataManager(kernel);
			}

			if(flags & hagglemain_have_node_manager)
			{
				nm = new NodeManager(kernel);
			}

			if(flags & hagglemain_have_protocol_manager)
			{
				pm = new ProtocolManager(kernel);
			}

			if(flags & hagglemain_have_forwarding_manager)
			{
				fm = new ForwardingManager(kernel);
			}

			if(flags & hagglemain_have_security_manager)
			{
				sm = new SecurityManager(kernel);
			}

			if(flags & hagglemain_have_protocol_manager)
			{
				p = new ProtocolUDP("127.0.0.1", HAGGLE_SERVICE_DEFAULT_PORT, pm);
				p->setFlag(PROT_FLAG_APPLICATION);
				p->registerWithManager();
			}

			if(flags & hagglemain_have_resource_manager)
			{
				rm = new ResourceManager(kernel);
			}

			/* Add ConnectivityManager last since it will start to
			 * discover interfaces and generate events. At that
			 * point the other managers should already be
			 * running. */
			if(flags & hagglemain_have_connectivity_manager)
			{
				cm = new ConnectivityManager(kernel);
			}
		}catch (Exception&){
			goto fail_exception;
		}

		try {
			HAGGLE_DBG("Starting kernel...\n");
			if (signalling_condition != NULL)
				signalling_condition->signal();
			kernel->run();
			HAGGLE_DBG("Haggle finished\n");
		} catch (Exception&)
		{

		}

fail_exception:
		if(cm)
			delete cm;
		if(sm)
			delete sm;
		if(fm)
			delete fm;
		if(pm)
			delete pm;
		if(nm)
			delete nm;
		if(dm)
			delete dm;
		if(am)
			delete am;
		if(kernel)
			delete kernel;
		kernel = NULL;

		return false;
	}

	void cleanup()
	{
		current_haggle = NULL;
		delete this;
	}
};

bool hagglemain_start(long flags, Condition *cond)
{
	if(current_haggle != NULL)
		return false;

	signalling_condition = cond;

	try{
		current_haggle = new hidden_hagglemainRunnable(flags);
	}catch(Exception &){
		goto fail_current_haggle;
	}
	try{
		if(current_haggle->start() != 0)
			goto fail_thread;
	}catch(Exception &){
		goto fail_thread;
	}
	shutdown_started = false;
	return true;
fail_thread:
	delete current_haggle;
	current_haggle = NULL;
fail_current_haggle:
	return false;
}

bool hagglemain_is_running(void)
{
	return (current_haggle != NULL);
}

bool hagglemain_stop(void)
{
	if(shutdown_started)
		return false;

	if(current_haggle == NULL)
		return false;

	if(kernel == NULL)
		return false;

	kernel->shutdown();
	shutdown_started = true;
	return true;
}

bool hagglemain_stop_and_wait(void)
{
	if(hagglemain_stop())
	{
		current_haggle->join();
		return true;
	}
	return false;
}


text:
package com.blazebit.persistence.examples.spring.data.webmvc.view;

import com.blazebit.persistence.examples.spring.data.webmvc.model.Person;
import com.blazebit.persistence.view.EntityView;

/**
 * @author Christian Beikov
 * @since 1.2.0
 */
@EntityView(Person.class)
public interface PersonSimpleView extends PersonIdView {

    String getName();

}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_margin="50px"
    android:layout_height="match_parent"
    android:weightSum="1"
    android:nestedScrollingEnabled="true">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:layout_gravity="center_horizontal"
        android:text="IMC"
        android:id="@+id/Calc_Imc" />

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="50px"
        android:layout_height="wrap_content">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textAppearance="?android:attr/textAppearanceMedium"
            android:text="Peso (em Kg):"
            android:id="@+id/Text_peso" />

        <EditText
            android:layout_width="156dp"
            android:layout_height="wrap_content"
            android:id="@+id/altura_imc"
            android:text="1.70" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textAppearance="?android:attr/textAppearanceMedium"
            android:text="Altura:"
            android:id="@+id/Altura_imc" />

        <EditText
            android:layout_width="146dp"
            android:layout_height="wrap_content"
            android:id="@+id/peso_imc"
            android:text="60.0" />

        <Button
            android:layout_width="141dp"
            android:layout_height="wrap_content"
            android:text="Calcular"
            android:id="@+id/calcula_imc" />
    </LinearLayout>

</LinearLayout>


text:
import express = require('express');
import flash = require('connect-flash');

var app = express();

app.use(flash());
app.use(flash({
    unsafe: false
}));

app.use(function(req: Express.Request, res: Express.Response, next: Function) {
    req.flash('Message');
    req.flash('info', 'Message');
    req.flash();
});


text:
echo "###################################################"
echo "symlinking dotfiles into parent directory..."
for dir in  `find  * -maxdepth 0 -type d \( -iname ".*" \)`
do
    stow $dir
done
echo "done!"

if [ ! -d ~/.vim/bundle/Vundle.vim/ ]; then
    echo "###################################################"
    echo "Installing Vundle"
    git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim
fi


text:
class MessageLoop;

namespace net {
class IOBuffer;
class Socket;
}  // namespace net

namespace remoting {
namespace protocol {

// MessageReader reads data from the socket asynchronously and calls
// callback for each message it receives. It stops calling the
// callback as soon as the socket is closed, so the socket should
// always be closed before the callback handler is destroyed.
//
// In order to throttle the stream, MessageReader doesn't try to read
// new data from the socket until all previously received messages are
// processed by the receiver (|done_task| is called for each message).
// It is still possible that the MessageReceivedCallback is called
// twice (so that there is more than one outstanding message),
// e.g. when we the sender sends multiple messages in one TCP packet.
class MessageReader : public base::RefCountedThreadSafe<MessageReader> {
 public:
  typedef base::Callback<void(scoped_ptr<CompoundBuffer>, const base::Closure&)>
      MessageReceivedCallback;

  MessageReader();
  virtual ~MessageReader();

  // Initialize the MessageReader with a socket. If a message is received
  // |callback| is called.
  void Init(net::Socket* socket, const MessageReceivedCallback& callback);

 private:
  void DoRead();
  void OnRead(int result);
  void HandleReadResult(int result);
  void OnDataReceived(net::IOBuffer* data, int data_size);
  void OnMessageDone(scoped_refptr<base::MessageLoopProxy> message_loop);
  void ProcessDoneEvent();

  net::Socket* socket_;

  // Set to true, when we have a socket read pending, and expecting
  // OnRead() to be called when new data is received.
  bool read_pending_;

  // Number of messages that we received, but haven't finished
  // processing yet, i.e. |done_task| hasn't been called for these
  // messages.
  int pending_messages_;

  bool closed_;
  scoped_refptr<net::IOBuffer> read_buffer_;

  MessageDecoder message_decoder_;

  // Callback is called when a message is received.
  MessageReceivedCallback message_received_callback_;
};

// Version of MessageReader for protocol buffer messages, that parses
// each incoming message.
template <class T>
class ProtobufMessageReader {
 public:
  typedef typename base::Callback<void(scoped_ptr<T>, const base::Closure&)>
      MessageReceivedCallback;

  ProtobufMessageReader() { };
  ~ProtobufMessageReader() { };

  void Init(net::Socket* socket, const MessageReceivedCallback& callback) {
    DCHECK(!callback.is_null());
    message_received_callback_ = callback;
    message_reader_ = new MessageReader();
    message_reader_->Init(
        socket, base::Bind(&ProtobufMessageReader<T>::OnNewData,
                           base::Unretained(this)));
  }

 private:
  void OnNewData(scoped_ptr<CompoundBuffer> buffer,
                 const base::Closure& done_task) {
    scoped_ptr<T> message(new T());
    CompoundBufferInputStream stream(buffer.get());
    bool ret = message->ParseFromZeroCopyStream(&stream);
    if (!ret) {
      LOG(WARNING) << "Received message that is not a valid protocol buffer.";
    } else {
      DCHECK_EQ(stream.position(), buffer->total_bytes());
      message_received_callback_.Run(message.Pass(), done_task);
    }
  }

  scoped_refptr<MessageReader> message_reader_;
  MessageReceivedCallback message_received_callback_;
};

}  // namespace protocol
}  // namespace remoting

#endif  // REMOTING_PROTOCOL_MESSAGE_READER_H_


text:
opensemanticapi with go lang
==============================================

**Description**

Will allow you to create your own semantic wording database with redis. Otherwise there will be a open api to get related words by meaning. You could say, this implementation is a light version of the idea behind http://en.wikipedia.org/wiki/Latent_semantic_analysis in combination with http://en.wikipedia.org/wiki/Open-source_intelligence

![ScreenShot](https://raw.githubusercontent.com/monbro/opensemanticapi-go-lang/master/osapi_explanation.jpg)

documentation
==============================================

* [Concerns](/doc/concerns.md)

* [Examples](/doc/examples.md)

* [Installation](/doc/installation.md)

* [Usage](/doc/usage.md)

* [Testing](/doc/testing.md)

* [References / Notes](/doc/references.md)

**Licence**

This software is published under the MIT-License. See 'license' for more information.


text:
window.requestAnimationFrame(function () {
  new GameManager({ 'x': 1, 'y': 21 }, KeyboardInputManager, HTMLActuator, LocalScoreManager);
});


text:
@interface RFRateMe : NSObject
+(void)showRateAlert;
@end


text:
import React from 'react';

var Transfer = React.createClass({

    render() {
        return (
            <div />
        );
    }

});

export default Transfer;


text:
package com.epam.cdp.jee.todo.servlet;

import java.io.IOException;
import javax.inject.Inject;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import com.epam.cdp.jee.todo.persistence.Jdbc;
import com.epam.cdp.jee.todo.persistence.Jpa;
import com.epam.cdp.jee.todo.persistence.entity.Task;
import com.epam.cdp.jee.todo.persistence.repository.TaskRepository;
import com.epam.cdp.jee.todo.persistence.repository.UserRepository;
import com.epam.cdp.jee.todo.DateFormatConstants;

@WebServlet("/task/add.do")
@NoArgsConstructor
@Slf4j
public class AddTaskServlet extends HttpServlet {

    private final static DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormat.forPattern(DateFormatConstants.DATE_TIME);

    @Inject
    @Jdbc
    private TaskRepository taskRepository;

    @Inject
    @Jpa
    private UserRepository userRepository;

    @Override
    protected void doPost(final HttpServletRequest request, final HttpServletResponse response)
            throws ServletException, IOException {
        String login = request.getParameter("username");
        String taskName = request.getParameter("name");
        String dueDateParam = request.getParameter("dueDateTime");
        Task task = new Task();
        task.setName(taskName);
        task.setDueDateTime(DATE_TIME_FORMATTER.parseDateTime(dueDateParam));
        taskRepository.add(task);
        // TODO: add task assignment to user
        response.sendRedirect(request.getContextPath() + "/app.jsp");
    }
}


text:
package org.uberfire.io.impl.cluster.helix;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.helix.Criteria;
import org.apache.helix.HelixManager;
import org.apache.helix.InstanceType;
import org.apache.helix.NotificationContext;
import org.apache.helix.messaging.handling.HelixTaskResult;
import org.apache.helix.messaging.handling.MessageHandler;
import org.apache.helix.messaging.handling.MessageHandlerFactory;
import org.apache.helix.model.ExternalView;
import org.apache.helix.model.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.uberfire.commons.cluster.ClusterService;
import org.uberfire.commons.data.Pair;
import org.uberfire.commons.lifecycle.PriorityDisposableRegistry;
import org.uberfire.commons.message.AsyncCallback;
import org.uberfire.commons.message.MessageHandlerResolver;
import org.uberfire.commons.message.MessageType;
import org.uberfire.io.impl.cluster.ClusterMessageType;

import static java.util.Arrays.*;
import static java.util.UUID.*;
import static org.apache.helix.HelixManagerFactory.*;

public class ClusterServiceHelix implements ClusterService {

    private static final AtomicInteger counter = new AtomicInteger( 0 );
    private static final Logger logger = LoggerFactory.getLogger( ClusterServiceHelix.class );

    private final String clusterName;
    private final String instanceName;
    private final HelixManager participantManager;
    private final String resourceName;
    private final Map<String, MessageHandlerResolver> messageHandlerResolver = new ConcurrentHashMap<String, MessageHandlerResolver>();

    private final ReentrantLock lock = new ReentrantLock( true );

    public ClusterServiceHelix( final String clusterName,
                                final String zkAddress,
                                final String instanceName,
                                final String resourceName,
                                final MessageHandlerResolver messageHandlerResolver ) {
        this.clusterName = clusterName;
        this.instanceName = instanceName;
        this.resourceName = resourceName;
        addMessageHandlerResolver( messageHandlerResolver );
        this.participantManager = getZkHelixManager( clusterName, zkAddress, instanceName );
        PriorityDisposableRegistry.register( this );
        start();
    }

    HelixManager getZkHelixManager( String clusterName,
                                    String zkAddress,
                                    String instanceName ) {
        return getZKHelixManager( clusterName, instanceName, InstanceType.PARTICIPANT, zkAddress );
    }

    //TODO {porcelli} quick hack for now, the real solution would have a cluster per repo
    @Override
    public void addMessageHandlerResolver( final MessageHandlerResolver resolver ) {
        if ( resolver != null ) {
            this.messageHandlerResolver.put( resolver.getServiceId(), resolver );
        }
    }

    void start() {
        try {
            participantManager.getMessagingService().registerMessageHandlerFactory( Message.MessageType.USER_DEFINE_MSG.toString(), new MessageHandlerResolverWrapper().convert() );
            participantManager.getStateMachineEngine().registerStateModelFactory( "LeaderStandby", new LockTransitionalFactory() );
            participantManager.connect();
            offlinePartition();
        } catch ( final Exception ex ) {
            throw new RuntimeException( ex );
        }
    }

    String getNodeStatus() {
        final String partition = resourceName + "_0";
        final ExternalView view = getResourceExternalView();
        if ( clusterIsNotSetYet( view, partition ) ) {
            return "OFFLINE";
        }
        final Map<String, String> stateMap = view.getStateMap( partition );
        return stateMap.get( instanceName );
    }

    ExternalView getResourceExternalView() {
        return participantManager.getClusterManagmentTool().getResourceExternalView( clusterName, resourceName );
    }

    private boolean clusterIsNotSetYet( ExternalView view,
                                        String partition ) {
        //first start with fresh setup
        if ( view == null ) {
            return true;
        }
        final Map<String, String> stateMap = view.getStateMap( partition );

        return stateMap == null || stateMap.get( instanceName ) == null;
    }

    @Override
    public void dispose() {
        if ( participantManager != null && participantManager.isConnected() ) {
            participantManager.disconnect();
        }
    }

    @Override
    public void onStart( final Runnable runnable ) {
        runnable.run();
    }

    @Override
    public int getHoldCount() {
        return lock.getHoldCount();
    }

    private void offlinePartition() {
        if ( "OFFLINE".equals( getNodeStatus() ) ) {
            return;
        }
        participantManager.getClusterManagmentTool().enablePartition( false, clusterName, instanceName, resourceName, asList( resourceName + "_0" ) );
        while ( !"OFFLINE".equals( getNodeStatus() ) ) {
            try {
                Thread.sleep( 10 );
            } catch ( InterruptedException e ) {
            }
        }
    }

    private void enablePartition() {
        if ( "LEADER".equals( getNodeStatus() ) ) {
            return;
        }
        participantManager.getClusterManagmentTool().enablePartition( true, clusterName, instanceName, resourceName, asList( resourceName + "_0" ) );
        while ( !"LEADER".equals( getNodeStatus() ) ) {
            try {
                Thread.sleep( 10 );
            } catch ( InterruptedException e ) {
            }
        }
    }

    private void disablePartition() {
        String nodeStatus = getNodeStatus();
        if ( "STANDBY".equals( nodeStatus ) || "OFFLINE".equals( nodeStatus ) ) {
            return;
        }
        participantManager.getClusterManagmentTool().enablePartition( false, clusterName, instanceName, resourceName, asList( resourceName + "_0" ) );

        while ( !( "STANDBY".equals( nodeStatus ) || "OFFLINE".equals( nodeStatus ) ) ) {
            try {
                Thread.sleep( 10 );
                nodeStatus = getNodeStatus();
            } catch ( InterruptedException e ) {
            }
        }
    }

    @Override
    public void lock() {
        lock.lock();

        enablePartition();
    }

    @Override
    public void unlock() {
        disablePartition();

        lock.unlock();
    }

    @Override
    public void broadcastAndWait( final String serviceId,
                                  final MessageType type,
                                  final Map<String, String> content,
                                  int timeOut ) {
        participantManager.getMessagingService().sendAndWait( buildCriteria(), buildMessage( serviceId, type, content ), new org.apache.helix.messaging.AsyncCallback( timeOut ) {
            @Override
            public void onTimeOut() {
            }

            @Override
            public void onReplyMessage( final Message message ) {
            }
        }, timeOut );
    }

    @Override
    public void broadcastAndWait( final String serviceId,
                                  final MessageType type,
                                  final Map<String, String> content,
                                  final int timeOut,
                                  final AsyncCallback callback ) {
        int msg = participantManager.getMessagingService().sendAndWait( buildCriteria(), buildMessage( serviceId, type, content ), new org.apache.helix.messaging.AsyncCallback() {
            @Override
            public void onTimeOut() {
                callback.onTimeOut();
            }

            @Override
            public void onReplyMessage( final Message message ) {
                final MessageType type = buildMessageTypeFromReply( message );
                final Map<String, String> map = getMessageContentFromReply( message );

                callback.onReply( type, map );
            }
        }, timeOut );
        if ( msg == 0 ) {
            callback.onTimeOut();
        }
    }

    @Override
    public void broadcast( final String serviceId,
                           final MessageType type,
                           final Map<String, String> content ) {
        participantManager.getMessagingService().send( buildCriteria(), buildMessage( serviceId, type, content ) );
    }

    @Override
    public void broadcast( final String serviceId,
                           final MessageType type,
                           final Map<String, String> content,
                           final int timeOut,
                           final AsyncCallback callback ) {
        participantManager.getMessagingService().send( buildCriteria(), buildMessage( serviceId, type, content ), new org.apache.helix.messaging.AsyncCallback() {
            @Override
            public void onTimeOut() {
                callback.onTimeOut();
            }

            @Override
            public void onReplyMessage( final Message message ) {
                final MessageType type = buildMessageTypeFromReply( message );
                final Map<String, String> map = getMessageContent( message );

                callback.onReply( type, map );
            }
        }, timeOut );
    }

    @Override
    public void sendTo( final String serviceId,
                        final String resourceId,
                        final MessageType type,
                        final Map<String, String> content ) {
        participantManager.getMessagingService().send( buildCriteria( resourceId ), buildMessage( serviceId, type, content ) );
    }

    private Criteria buildCriteria( final String resourceId ) {
        return new Criteria() {{
            setInstanceName( resourceId );
            setRecipientInstanceType( InstanceType.PARTICIPANT );
            setResource( resourceName );
            setSelfExcluded( true );
            setSessionSpecific( true );
        }};
    }

    private Criteria buildCriteria() {
        return buildCriteria( "%" );
    }

    private Message buildMessage( final String serviceId,
                                  final MessageType type,
                                  final Map<String, String> content ) {
        return new Message( Message.MessageType.USER_DEFINE_MSG, randomUUID().toString() ) {{
            setMsgState( Message.MessageState.NEW );
            getRecord().setMapField( "content", content );
            getRecord().setSimpleField( "serviceId", serviceId );
            getRecord().setSimpleField( "type", type.toString() );
            getRecord().setSimpleField( "origin", instanceName );
        }};
    }

    @Override
    public int priority() {
        return Integer.MIN_VALUE + 200;
    }

    class MessageHandlerResolverWrapper {

        MessageHandlerFactory convert() {
            return new MessageHandlerFactory() {

                @Override
                public MessageHandler createHandler( final Message message,
                                                     final NotificationContext context ) {

                    return new MessageHandler( message, context ) {
                        @Override
                        public HelixTaskResult handleMessage() throws InterruptedException {
                            try {
                                final String serviceId = _message.getRecord().getSimpleField( "serviceId" );
                                final MessageType type = buildMessageType( _message.getRecord().getSimpleField( "type" ) );
                                final Map<String, String> map = getMessageContent( _message );

                                final MessageHandlerResolver resolver = messageHandlerResolver.get( serviceId );

                                if ( resolver == null ) {
                                    System.err.println( "serviceId not found '" + serviceId + "'" );
                                    return new HelixTaskResult() {{
                                        setSuccess( false );
                                        setMessage( "Can't find resolver" );
                                    }};
                                }

                                final org.uberfire.commons.message.MessageHandler handler = resolver.resolveHandler( serviceId, type );

                                if ( handler == null ) {
                                    System.err.println( "handler not found for '" + serviceId + "' and type '" + type.toString() + "'" );
                                    return new HelixTaskResult() {{
                                        setSuccess( false );
                                        setMessage( "Can't find handler." );
                                    }};
                                }

                                final Pair<MessageType, Map<String, String>> result = handler.handleMessage( type, map );

                                if ( result == null ) {
                                    return new HelixTaskResult() {{
                                        setSuccess( true );
                                    }};
                                }

                                return new HelixTaskResult() {{
                                    setSuccess( true );
                                    getTaskResultMap().put( "serviceId", serviceId );
                                    getTaskResultMap().put( "type", result.getK1().toString() );
                                    getTaskResultMap().put( "origin", instanceName );
                                    for ( Map.Entry<String, String> entry : result.getK2().entrySet() ) {
                                        getTaskResultMap().put( entry.getKey(), entry.getValue() );
                                    }
                                }};
                            } catch ( final Throwable e ) {
                                logger.error( "Error while processing cluster message", e );
                                return new HelixTaskResult() {{
                                    setSuccess( false );
                                    setMessage( e.getMessage() );
                                    setException( new RuntimeException( e ) );
                                }};
                            }
                        }

                        @Override
                        public void onError( final Exception e,
                                             final ErrorCode code,
                                             final ErrorType type ) {
                        }
                    };
                }

                @Override
                public String getMessageType() {
                    return Message.MessageType.USER_DEFINE_MSG.toString();
                }

                @Override
                public void reset() {
                }
            };
        }

    }

    private MessageType buildMessageType( final String _type ) {
        if ( _type == null ) {
            return null;
        }

        MessageType type;
        try {
            type = ClusterMessageType.valueOf( _type );
        } catch ( Exception ex ) {
            type = new MessageType() {
                @Override
                public String toString() {
                    return _type;
                }

                @Override
                public int hashCode() {
                    return _type.hashCode();
                }
            };
        }

        return type;
    }

    private MessageType buildMessageTypeFromReply( Message message ) {
        final Map<String, String> result = message.getRecord().getMapField( Message.Attributes.MESSAGE_RESULT.toString() );
        return buildMessageType( result.get( "type" ) );
    }

    private Map<String, String> getMessageContent( final Message message ) {
        return message.getRecord().getMapField( "content" );
    }

    private Map<String, String> getMessageContentFromReply( final Message message ) {
        return new HashMap<String, String>() {{
            for ( final Map.Entry<String, String> field : message.getRecord().getMapField( Message.Attributes.MESSAGE_RESULT.toString() ).entrySet() ) {
                if ( !field.getKey().equals( "serviceId" ) && !field.getKey().equals( "origin" ) && !field.getKey().equals( "type" ) ) {
                    put( field.getKey(), field.getValue() );
                }
            }
        }};
    }
}


text:
( function( $ ) {
if( !$ ) { return; }

$( document ).ready( function() {
    function addBeginIcon( target, iconClass ) {
        $( target ).each( function() {
            $( "<i>" ).addClass( iconClass ).prependTo( $( this ) );
        } );
    }

    function addBeginObject( target, text ) {
        $( target ).each( function() {
            $( "<strong>" ).text( text ).prependTo( $( this ) );
        } );
    }

    addBeginIcon( "tr.message.locked td.subject",       "fa fa-lock js-replace-fa-icon" );
    addBeginIcon( "tr.message.sticky td.subject",       "fa fa-arrow-right js-replace-fa-icon" );
    addBeginIcon( "tr.version.shared td.name",          "fa fa-link js-replace-fa-icon" );
    addBeginIcon( "table.members td.group",             "fa fa-users js-replace-fa-icon" );
    addBeginIcon( "div.flash.error, #errorExplanation", "fa fa-exclamation-circle js-replace-fa-icon" );
    addBeginIcon( "div.flash.notice",                   "fa fa-check js-replace-fa-icon" );
    addBeginIcon( "div.flash.warning, .conflict",       "fa fa-exclamation-triangle js-replace-fa-icon" );

    // Editor toolbar
    $( ".jstElements" ).removeClass( "jstElements" ).addClass( "js-replace-jstElements" );
    addBeginIcon( ".jstb_strong", "fa fa-bold" );
    addBeginIcon( ".jstb_em",     "fa fa-italic" );
    addBeginIcon( ".jstb_ins",    "fa fa-underline" );
    addBeginIcon( ".jstb_del",    "fa fa-strikethrough" );
    addBeginIcon( ".jstb_code",   "fa fa-code" );
    addBeginObject( ".jstb_h1", "H1" );
    addBeginObject( ".jstb_h2", "H2" );
    addBeginObject( ".jstb_h3", "H3" );
    addBeginIcon( ".jstb_ul", "fa fa-list-ul" );
    addBeginIcon( ".jstb_ol", "fa fa-list-ol" );
    addBeginIcon( ".jstb_bq", "fa fa-indent" );
    addBeginIcon( ".jstb_unbq", "fa fa-outdent" );
    addBeginObject( ".jstb_pre", "pre" );
    addBeginIcon( ".jstb_link", "fa fa-link" );
    addBeginIcon( ".jstb_img", "fa fa-picture-o" );
    addBeginIcon( ".jstb_help", "fa fa-question-circle" );

    // a > img icons
    $( "a[onclick*='removeFileField(this);']" ).addClass( "js-replace-icon-trash" ).empty();
    $( "a[data-method='delete']" ).addClass( "js-replace-icon-trash" );
    $( "img[src*='toggle_check.png']" ).replaceWith( $( "<i>" ).addClass( "js-replace-icon-check" ) );
    $( "a[href*='edit?section=']" ).addClass( "js-replace-icon-edit" ).empty();
    $( "a[href*='quoted?journal_id=']" ).addClass( "js-replace-icon-comment" ).empty();
    $( "a[onclick*='journals/edit']" ).addClass( "js-replace-icon-edit" ).empty();
} );

} )( jQuery );


text:
var express = require('express');
var router = express.Router();
var http = require('http');
/* GET home page. */
router.get('/', function(req, res, next) {
  res.render('index', { title: 'Express' });
});
router.post('/', function(req, res, next) {
  var user = req.body;
  var request = http.request({
    host:'localhost',
    port:4000,
    path:'/',
    method:'post',
    headers:{'Content-Type':'application/json'}
  },function(response){

  });
  request.write(JSON.stringify(user));
  request.end();
  res.end();
});

module.exports = router;


text:
namespace SpriterEngine
{

	GMImageFile::GMImageFile(std::string initialFilePath, point initialDefaultPivot) :
		ImageFile(initialFilePath,initialDefaultPivot)
	{
		initializeFile();

		if (!CSpriterGM::GetSingleton()->GetLastLoadedModel().IsAtlas())
			CSpriterGM::GetSingleton()->GetLastLoadedModel().AddSprite(initialFilePath);
	}

	void GMImageFile::initializeFile()
	{

	}

	void GMImageFile::renderObject(int ModelIndex, int InstanceIndex, UniversalObjectInterface *spriteInfo)
	{
		CSpriterGM::CSpriterGMModel &Model = CSpriterGM::GetSingleton()->GetSpriterGMModel(ModelIndex);
		CSpriterGM::CSpriterGMInstance &Instance = Model.GetInstance(InstanceIndex);

		CSpriterGM::CGMObjectInfo GMObjectInfo;

		CSpriterGM::CSprite *pSprite = NULL;

		if (atlasFile)
		{
			GMObjectInfo.SetSpriteName(atlasFile->path());
			GMObjectInfo.SetAtlasFile(true);
			GMObjectInfo.GetAtlasFrame().m_bRotated = atlasFrameData.rotated;
			GMObjectInfo.GetAtlasFrame().m_bTrimmed = atlasFrameData.trimmed;
			GMObjectInfo.GetAtlasFrame().m_FramePositionX = atlasFrameData.framePosition.x;
			GMObjectInfo.GetAtlasFrame().m_FramePositionY = atlasFrameData.framePosition.y;
			GMObjectInfo.GetAtlasFrame().m_FrameSizeX = atlasFrameData.frameSize.x;
			GMObjectInfo.GetAtlasFrame().m_FrameSizeY = atlasFrameData.frameSize.y;
			GMObjectInfo.GetAtlasFrame().m_SourceSizeX = atlasFrameData.sourceSize.x;
			GMObjectInfo.GetAtlasFrame().m_SourceSizeY = atlasFrameData.sourceSize.y;
			GMObjectInfo.GetAtlasFrame().m_SpriteSourcePositionX = atlasFrameData.spriteSourcePosition.x;
			GMObjectInfo.GetAtlasFrame().m_SpriteSourcePositionY = atlasFrameData.spriteSourcePosition.y;
			GMObjectInfo.GetAtlasFrame().m_SpriteSourceSizeX = atlasFrameData.spriteSourceSize.x;
			GMObjectInfo.GetAtlasFrame().m_SpriteSourceSizeY = atlasFrameData.spriteSourceSize.y;

			pSprite = Model.FindLoadedSprite(atlasFile->path());

		}
		else
		{
			pSprite = Model.FindLoadedSprite(spriteInfo->getImage()->path());
		}

		GMObjectInfo.SetSpriteName(spriteInfo->getImage()->path());
		GMObjectInfo.SetPosition(spriteInfo->getPosition());
		GMObjectInfo.SetPivot(spriteInfo->getPivot());
		GMObjectInfo.SetScale(spriteInfo->getScale());
		GMObjectInfo.SetAngle(spriteInfo->getAngle());
		GMObjectInfo.SetAlpha(spriteInfo->getAlpha());
		GMObjectInfo.SetRender(true);
		GMObjectInfo.SetType(CSpriterGM::CGMObjectInfo::IMAGE);

		if (pSprite)
		{
			GMObjectInfo.SetGMSpriteIndex(pSprite->GetPointer());
			GMObjectInfo.CalculateShape(*pSprite, true);
		}

		Instance.AddGMObjectInfo(GMObjectInfo);

	}

	void GMImageFile::renderSprite(UniversalObjectInterface * spriteInfo)
	{

	}

	// Overwritten so we can create the sprite from the texture.
	void GMImageFile::setAtlasFile(AtlasFile *initialAtlasFile, atlasframedata initialAtlasFrameData)
	{
		if (!CSpriterGM::GetSingleton()->GetLastLoadedModel().IsAtlas())
		{
			CSpriterGM::GetSingleton()->GetLastLoadedModel().SetAtlas(true);
			CSpriterGM::GetSingleton()->GetLastLoadedModel().ClearSprites();
		}

		ImageFile::setAtlasFile(initialAtlasFile, initialAtlasFrameData);

		CSpriterGM::GetSingleton()->GetLastLoadedModel().AddSprite(initialAtlasFile->path());
	}
}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.eclipsedroidapp"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="6"
        android:targetSdkVersion="17" />

    <uses-permission android:name="android.permission.SEND_SMS"></uses-permission>
    <uses-permission android:name="android.permission.RECEIVE_SMS"></uses-permission>
    <uses-permission android:name="android.permission.READ_SMS"></uses-permission>
    <uses-permission android:name="android.permission.WRITE_SMS"></uses-permission>
    <uses-permission android:name="android.permission.INTERNET"></uses-permission>

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >

        <activity
            android:name="com.example.eclipsedroidapp.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver android:name="com.example.eclipsedroidapp.SMSReceiver" >
            <intent-filter android:priority="999">
                <action android:name="android.provided.Telephony.SMS_RECEIVED" />
            </intent-filter>
        </receiver>

        <activity
            android:name="com.example.eclipsedroidapp.DisplayMessageActivity"
            android:label="@string/title_activity_display_message"
            android:parentActivityName="com.example.eclipsedroidapp.MainActivity" >
            <meta-data
                android:name="android.support.PARENT_ACTIVITY"
                android:value="com.example.eclipsedroidapp.MainActivity" />
        </activity>

    </application>

</manifest>


text:
//    Copyright 2015 Cloud Security Alliance EMEA (cloudsecurityalliance.org)
//
// 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.

package jsmm

import (
	"fmt"
)

type Expression interface {
	String() string
	Compile(m *Machine)
}

//
// Literal number
//
type literalNumberExpr struct {
	value string
}

func (e *literalNumberExpr) Compile(m *Machine) {
	m.AddIParam(i_load_const, m.AddConst(NewNumberString(e.value)))
}
func (l *literalNumberExpr) String() string {
	return l.value
}

//
// Literal string
//
type literalStringExpr struct {
	value string
}

func (e *literalStringExpr) Compile(m *Machine) {
	m.AddIParam(i_load_const, m.AddConst(NewString(e.value)))
}
func (e *literalStringExpr) String() string {
	return fmt.Sprintf("\"%s\"", e.value)
}

//
// Literal boolean
//
type literalBooleanExpr struct {
	value string
}

func (e *literalBooleanExpr) Compile(m *Machine) {
	m.AddIParam(i_load_const, m.AddConst(NewBooleanString(e.value)))
}
func (e *literalBooleanExpr) String() string {
	return e.value
}

//
// Literal null
//
type literalNullExpr struct  {}

func (n *literalNullExpr) Compile(m *Machine) {
	m.AddIParam(i_load_const, m.AddConst(NewNull()))
}
func (n *literalNullExpr) String() string {
	return "null"
}

//
// List def expression
//

type ExpressionList []Expression

func NewExpressionList() ExpressionList {
	return make([]Expression, 0, 4)
}
func (e ExpressionList) Length() int {
    return len(e)
}
func (e ExpressionList) Append(i Expression) ExpressionList {
	return append(e, i)
}
func (e ExpressionList) Get(i int) Expression {
    return e[i]
}

func (e ExpressionList) String() string {
	r := ""
	for _, item := range e {
		r += " " + item.String()
	}
	return r
}

//
// Function call
//

type functionCallExpr struct {
	base      Expression
	fname     Expression
	arguments ExpressionList
}

func (e *functionCallExpr) Compile(m *Machine) {
    for i:=e.arguments.Length()-1; i>=0; i-- {
        e.arguments.Get(i).Compile(m)
    }
	e.base.Compile(m)
	e.fname.Compile(m)
	m.AddIParam(i_call, e.arguments.Length()+1)
}

func (e *functionCallExpr) String() string {
	return "(fcall " + e.base.String() + "." + e.fname.String() + " " + e.arguments.String() + ")"
}

//
// Attribute selection
//

type attributeSelectionExpr struct {
	base      Expression
	selection Expression
}

func (e *attributeSelectionExpr) Compile(m *Machine) {
	e.base.Compile(m)
	e.selection.Compile(m)
	m.AddI(i_get_index)
}

func (e *attributeSelectionExpr) String() string {
	return "(. " + e.base.String() + " " + e.selection.String() + ")"
}

//
// Attribute base
//

type getGlobalObjectExpr struct{}

func (e *getGlobalObjectExpr) Compile(m *Machine) {
	m.AddI(i_get_global)
}

func (e *getGlobalObjectExpr) String() string {
	return "(load_global)"
}

//
// Array def expression
//

type arrayDefExpr struct {
	value ExpressionList
}

func (e *arrayDefExpr) Compile(m *Machine) {
	m.AddI(i_newarray)
    for i:=0; i<e.value.Length(); i++ {
        e.value.Get(i).Compile(m)
    }
}
func (e *arrayDefExpr) String() string {
	return "(newaray " + e.value.String() + ")"
}

//
// Object def expression
//

type objectDefExpr struct {
	value ExpressionList
}

func (e *objectDefExpr) Compile(m *Machine) {
	m.AddI(i_newobject)
    for i:=0; i<e.value.Length(); i++ {
        e.value.Get(i).Compile(m)
    }
}
func (e *objectDefExpr) String() string {
	return "(newobject " + e.value.String() + ")"
}

/*
type identifierExpr struct {
    value string
}
func (e *identifierExpr)String() string {
    return e.value
}

type sliceExpr struct {
    source  Expression
    start   Expression
    stop    Expression
}
func (e *sliceExpr)String() string {
    return fmt.Sprintf("([:] %s %s %s)",e.source.String(),e.start.String(),e.stop.String())
}

type callExpr struct {
    funcName string
    params []Expression
}
func (e *callExpr)String() string {
    s := "(" + e.funcName
    for _,v := range e.params {
        s+=" " + v.String()
    }
    s+=")"
    return s
}
func newCallExpr(fname string) *callExpr {
    return &callExpr{fname,make([]Expression,0,2)}
}
func (e *callExpr)addParam(p Expression) *callExpr {
    e.params = append(e.params,p)
    return e
}
*/

//
// Binary expression (+,-,*,/,&,<,>,<=,>=,==,!=,...)
//

type binExpr struct {
	op int
	x  Expression
	y  Expression
}

func (e *binExpr) String() string {
	return fmt.Sprintf("(%s %s %s)", Ops[e.op].name, e.x.String(), e.y.String())
}
func (e *binExpr) Compile(m *Machine) {
	e.x.Compile(m)
	e.y.Compile(m)
	m.AddI(byte(e.op))
}

//
// Unary op expression
//

type unaryExpr struct {
	op int
	x  Expression
}

func (e *unaryExpr) String() string {
	return fmt.Sprintf("(%s %s)", Ops[e.op].name, e.x.String())
}
func (e *unaryExpr) Compile(m *Machine) {
	e.x.Compile(m)
	m.AddI(byte(e.op))
}

/*
type symbolExpr struct {
    identifier string
    base bool
}
func (e *symbolExpr)String() string {
    return e.identifier
}
func (e *symbolExpr)Compile(m *Machine) {
    m.AddI(loadcOp(m.AddConst(NewString(e.identifier))))
    if e.base {
        m.AddI(getBaseOp(1))
    } else {
        m.AddI(getBaseOp(0))
    }
}
*/


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.widget.DrawerLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.uqroute.uqroute.LocationListActivity"
    android:id="@+id/activity_location_list">

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">
        <android.support.v7.widget.Toolbar
            android:id="@+id/location_toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="?attr/colorPrimary"
            android:elevation="4dp"
            android:theme="@style/ThemeOverlay.AppCompat.ActionBar"/>

        <android.support.v7.widget.RecyclerView
            android:id="@+id/location_list_view"
            android:scrollbars="vertical"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
     </LinearLayout>

    <ListView android:id="@+id/location_drawer_list"
        android:layout_width="240dp"
        android:layout_height="match_parent"
        android:layout_gravity="start"
        android:choiceMode="singleChoice"
        android:divider="@android:color/transparent"
        android:dividerHeight="0dp"
        android:background="#ffffff"/>
</android.support.v4.widget.DrawerLayout>


text:
namespace base {
class Value;
}

namespace dbus {

class MessageReader;
class MessageWriter;

// Pops a value from |reader| as a base::Value.
// Returns NULL if an error occurs.
// Note: Integer values larger than int32 (including uint32) are converted to
// double.  Non-string diciontary keys are converted to strings.
CHROME_DBUS_EXPORT base::Value* PopDataAsValue(MessageReader* reader);

// Appends a basic type value to |writer|.
CHROME_DBUS_EXPORT void AppendBasicTypeValueData(MessageWriter* writer,
                                                 const base::Value& value);

// Appends a basic type value to |writer| as a variant.
CHROME_DBUS_EXPORT void AppendBasicTypeValueDataAsVariant(
    MessageWriter* writer,
    const base::Value& value);

}  // namespace dbus

#endif  // DBUS_VALUES_UTIL_H_


text:
<?php namespace AleksandrAblizin\Ion;

use Backend;
use System\Classes\PluginBase;

class Plugin extends PluginBase
{
    public function pluginDetails()
    {
        return [
            'name'        => 'ion.js',
            'description' => 'Ajax-wrapper ion',
            'author'      => 'Alexandr Ablizin',
            'icon'        => 'icon-circle-o'
        ];
    }
    public function registerComponents()
    {
        return [
            'AleksandrAblizin\Ion\Components\Ion' => 'ion',
        ];
    }
}


text:
package sres;

import java.util.concurrent.RunnableFuture;

public interface RemoteRunnableFuture<T> extends RunnableFuture<T> {
	void processResponse(RemoteResult result);
	public default boolean cancel(boolean mayInterruptIfRunning) {
		// TODO Implement canceling
		return false;
	}

	public default boolean isCancelled() {
		// TODO Implement canceling
		return false;
	}

}