text:
var connector;

Cti.Platform = function () {
    // some initialization
    Cti.log("Loading connector");

    $('#status').html("Loading connector...");
    $('#status')
            .removeClass()
            .addClass('label label-warning');

    connector = new Cti.Connector({
        // callback
        onMessage: this.onMessage
    });
};

Cti.Platform.prototype = {
    username: null,
    run: function () {
        if (!connector.isConnected()) {

            document.title = "Ready";
            $('#status')
                    .html("Platform ready: Not connected.")
                    .removeClass()
                    .addClass('label label-info');
        }
    },
    login: function () {
        var username = arguments[0];
        $('#status')
            .html("Authentication " + username + "...")
            .removeClass()
            .addClass('label label-warning');

        this.username = username;

        connector.login.apply(connector, arguments);
    },
    logout: function () {
        this.username = null;

        connector.logout();
    },
    answer: function () {
        document.title = "Answering";

        connector.answer();
    },
    call: function (destination) {
        document.title = "Connecting";

        connector.call(destination);
    },
    terminate: function (callId) {
        document.title = "Terminating";

        $('#status')
                .html("Terminating...")
                .removeClass()
                .addClass('label label-warning');

        connector.terminate(callId);
    },
    transfer: function (callId, destination) {
        document.title = "Transfering";

        $('#status')
                .html("Transfering call to " + destination + "...")
                .removeClass()
                .addClass('label label-warning');

        connector.transfer(callId, destination);
    },
    onMessage: function (event) {

        Cti.log(event);

        if (event.name === Cti.EVENT.READY) {
            document.title = "Available";

            $('#status')
                    .html("Available")
                    .removeClass()
                    .addClass('label label-success');

            $('#disconnect').show();
            $('#call-outbound').prop('disabled', false);
            $('#login-form').hide();
            $('#disconnect').show();
            $('#outboundcall-form').show();
        }

        if (event.name === Cti.EVENT.INITIAL) {
            $('#status')
                    .html("Softphone ringing...")
                    .removeClass()
                    .addClass('label label-warning');
        }

        if (event.name === Cti.EVENT.ACCEPTED) {
            $('#status')
                    .html("Softphone accepted...")
                    .removeClass()
                    .addClass('label label-warning');
        }

        if (event.name === Cti.EVENT.RINGING) {
            $('#disconnect').prop('disabled', true);
            $('#call-outbound').prop('disabled', true);

            // Incoming call
            if (event.call.direction === Cti.DIRECTION.IN) {

                document.title = "Incoming";
                $('#call-answer').show();
                $('#status')
                        .html("Incoming call from " + event.call.source)
                        .removeClass()
                        .addClass('label label-warning');
            } else {
                $('#status')
                        .html("Connecting to " + event.call.destination + "...")
                        .removeClass()
                        .addClass('label label-warning');
            }
        }

        if (event.name === Cti.EVENT.CONNECTED) {
            document.title = "Connected";

            $('#status')
                    .removeClass()
                    .addClass('label label-success');

            // Incoming call
            if (event.call.direction === Cti.DIRECTION.IN) {
                $('#status')
                        .html("Connected (" + event.call.sourceName + ")");
            } else {
                $('#status')
                        .html("Connected (" + event.call.destination + ")");
            }

            $('#disconnect').prop('disabled', true);
            $('#call-outbound').prop('disabled', true);
            // show buttons
            $('#toolbar-form').show();
            // hide call form
            $('#outboundcall-form').hide();
            $('#call-answer').hide();

            $('#call-terminate, #call-transfer').attr('call-id', event.call.id);
        }

        if (event.name === Cti.EVENT.ON_HOLD) {
            document.title = "OnHold";

            $('#status')
                    .html("On hold")
                    .removeClass()
                    .addClass('label label-info');

            // show buttons
            $('#toolbar-form').show();
            // hide call form
            $('#outboundcall-form').hide();
        }

        if ($.inArray(event.name, [Cti.EVENT.HANGUP, Cti.EVENT.CANCEL]) !== -1) {
            document.title = "Available";

            $('#status')
                    .html("Available")
                    .removeClass()
                    .addClass('label label-success');

            $('#disconnect').prop('disabled', false);
            $('#call-outbound').prop('disabled', false);
            // hide buttons
            $('#toolbar-form').hide();
            // show call form
            $('#outboundcall-form').show();
            $('#toolbar-form').hide();
            $('#transfer-table').hide();
            $('#call-answer').hide();

            $('#call-terminate, #call-transfer').removeAttr('call-id');

            if (event.name === Cti.EVENT.CANCEL && event.call.cause) {
                alert(event.call.cause);
            }
        }

        if ($.inArray(event.name, [Cti.EVENT.ERROR, Cti.EVENT.INFO]) !== -1) {
            document.title = "Error";

            $('#status')
                    .html("Error")
                    .removeClass()
                    .addClass('label label-danger');

            alert(event.message);
        }

        if (event.name === Cti.EVENT.LOGGED_IN) {
            // add code if needed
        }

        if (event.name === Cti.EVENT.LOGGED_OUT) {
            document.title = "Ready";

            $('#status')
                    .html("Platform ready: Not connected.")
                    .removeClass()
                    .addClass('label label-info');

            $('#login-form').show();
            $('#disconnect').hide();
            $('#outboundcall-form').hide();
        }
    }
};


text:
A very simple library for fast Read/Write reflection operations in .NET

###Quick Example
```cs

class User{
  public Guid Id {get; set;}
  public string Name {get; set;}
  [McFlectIgnore]
  public string Password {get; set;}

  //Don't actually reference your database context in a model.
  public void SaveUser(){
    var props = MC.McFlect.Util.GetProps<User>(); //Could also use typeof(User)
    SomeDataContext.WithContext(db =>{
      var existing = db.Users.First(x => x.Id == this.Id);
      foreach(var prop in props.ValueAndStringProperties){
        var currentVal = prop.GetVal(this);
        var oldVal = prop.GetVal(existing);
        if(!object.Equals(currentVal, oldVal)){
          db.AuditLogs.Add(new AuditLog("User", this.Id, prop.Name, oldVal, currentVal));
          prop.SetVal(existing, currentVal);
        }
      }
      db.SaveChanges();
    });
  }

  BetterLookingSaveUser(){
    var props = MC.McFlect.Util.GetProps<User>();
    SomeDataContext.WithContext(db =>{
      var existing = db.Users.First(x => x.Id == this.Id);
      foreach(var prop in props.ValueAndStringProperties){
        if(!prop.IsEqual(this, existing)){
          db.AuditLogs.Add(new AuditLog("User", this.Id, prop.Name, prop.GetVal(existing), prop.GetVal(this)));
          prop.Copy(this, existing);
        }
      }
      db.SaveChanges();
    });
  }
}
```

###How do I get this in my project?
1. **Add the package source: https://www.myget.org/F/mc/api/v3/index.json**
 1. Visual Studio->Tools->NuGet Package Manager->Package Manager Settings
 2. Package Sources
 3. Click the big green plus.
 4.
  Name: MC
  VS2015 Source: https://www.myget.org/F/mc/api/v3/index.json
  VS2012 Source: https://www.myget.org/F/mc/api/v2
 5. Click 'Update'.
 6. Click 'OK'
2. **Install-Package McFlect**
 1. Tools->NuGet Package Manager->Package Manager Console
 2. Change Package Source to 'All' or 'MC'
 3. Type "Install-Package McFlect" into the Console and hit enter.

### How It Works
MC.McFlect.Util.GetProps(someType) returns a PropertyCache for someType.
These let you access generic properties for a given type by Name,
or by sorting through attributes of the PropertyInfo associated with the type. You can then dynamically Get/Set/Copy
values to and from any object.

This is the same as what can be done with a PropertyInfo object using reflection, however it's much faster.

In the background, whenever a PropertyCache of a given type is requested for the
first time, a GetVal Func and SetVal Action for each property are dynamically generated using the functionality available
in the Linq.Expressions namespace and normal reflection. The generated cache is then stored in a static dictionary
for later use.

This means that the first time PropertyCache.GetCache is called for a type, it will take a moment
(something like 1/100th of a second) to run, but that future calls will only take the time of the dictionary lookup.
If this is an issue, then PropertyCache.GetCache can be run on app start for types which will be commonly used. This also
means that the lifetime of the caches is the lifetime of your static variables.

```

redpajama_set_name: RedPajamaGithub


text:
package org.visallo.web.structuredingest.core;

import org.visallo.core.model.properties.types.StringVisalloProperty;

public class StructuredIngestOntology {
    public static final String IRI = "http://visallo.org/structured-file";
    public static final String ELEMENT_HAS_SOURCE_IRI = IRI + "#elementHasSource";

    public static final StringVisalloProperty ERROR_MESSAGE_PROPERTY = new StringVisalloProperty(IRI + "#errorMessage");
    public static final StringVisalloProperty TARGET_PROPERTY = new StringVisalloProperty(IRI + "#targetPropertyName");
    public static final StringVisalloProperty RAW_CELL_VALUE_PROPERTY = new StringVisalloProperty(IRI + "#rawCellValue");
    public static final StringVisalloProperty SHEET_PROPERTY = new StringVisalloProperty(IRI + "#sheet");
    public static final StringVisalloProperty ROW_PROPERTY = new StringVisalloProperty(IRI + "#row");
}


text:
require "spec_helper"
require "octopolo/scripts/accept_pull"

module Octopolo
  module Scripts
    describe AcceptPull do
      let(:config) { stub(:config, :github_repo => "tstmedia/foo", :deploy_branch => "master") }
      let(:cli) { stub }
      let(:git) { stub(:Git) }
      let(:pull_request_id) { 42 }
      let(:pull_request) { stub(:PullRequest, branch: "cool-feature", url: "http://example.com/") }

      subject { AcceptPull.new '' }

      before do
        subject.git = git
        subject.config = config
        subject.cli = cli
      end

      context "#execute" do
        before do
          subject.pull_request_id = pull_request_id
        end

        it "merges the change and updates the changelog" do
          GitHub.should_receive(:connect).and_yield
          GitHub::PullRequest.should_receive(:new).with(config.github_repo, pull_request_id) { pull_request }
          subject.should_receive(:merge).with(pull_request)
          subject.should_receive(:update_changelog).with(pull_request)

          subject.execute
        end

        it "does not if given an invalid pull request number" do
          GitHub.should_receive(:connect).and_yield
          GitHub::PullRequest.should_receive(:new).and_raise(GitHub::PullRequest::NotFound)
          subject.should_receive(:merge).never
          subject.should_receive(:update_changelog).never
          cli.should_receive(:say).with("Unable to find a pull request #{pull_request_id} for #{config.github_repo}. Please verify.")

          subject.execute
        end
      end

      context "#merge" do
        let(:pull_request) { stub(branch: "foobranch") }
        before { subject.stub(:pull_request_id => pull_request_id) }

        context "when mergeable and status checks passed" do
          before { pull_request.stub(mergeable?: true, status_checks_passed?: true) }

          it "fetches and merges the request's branch" do
            Git.should_receive(:fetch)
            cli.should_receive(:perform).with "git merge --no-ff origin/#{pull_request.branch} -m \"Merge pull request ##{pull_request_id} from origin/#{pull_request.branch}\""

            subject.merge pull_request
          end
        end

        context "when not mergeable" do
          before do
            pull_request.stub(mergeable?: false)
            allow(subject).to receive(:exit!)
          end

          it "performs the merge and alerts about potential failures" do
            Git.should_receive(:fetch)
            cli.stub(:say)
            cli.should_not_receive(:perform).with "git merge --no-ff origin/#{pull_request.branch} -m \"Merge pull request ##{pull_request_id} from origin/#{pull_request.branch}\""

            cli.should_receive(:say).with /merge conflict/
            expect(subject).to receive(:exit!)
            subject.merge pull_request
          end
        end

        context "when mergeable and status checks have not passed" do
          before do
            pull_request.stub(mergeable?: true, status_checks_passed?: false)
            allow(subject).to receive(:exit!)
          end

          it "performs the merge and alerts about potential failures" do
            Git.should_receive(:fetch)
            cli.stub(:say)
            cli.should_not_receive(:perform).with "git merge --no-ff origin/#{pull_request.branch} -m \"Merge pull request ##{pull_request_id} from origin/#{pull_request.branch}\""

            cli.should_receive(:say).with 'Previous action not completed. Status checks have not passed on this pull request.'
            expect(subject).to receive(:exit!)
            subject.merge pull_request
          end
        end

        context "when failed status checks should be ignored" do
          subject { described_class.new(pull_request_id, force: true) }
          before { pull_request.stub(mergeable?: true, status_checks_passed?: false) }

          it "fetches and merges the request's branch" do
            Git.should_receive(:fetch)
            cli.should_receive(:perform).with "git merge --no-ff origin/#{pull_request.branch} -m \"Merge pull request ##{pull_request_id} from origin/#{pull_request.branch}\""

            subject.merge pull_request
          end
        end
      end
    end
  end
end


text:
'use strict';

const leftPad = require('left-pad');

function toFixedHex(length: number, number: number): string {
  return leftPad(number.toString(16), length, '0');
}

module.exports = toFixedHex;


text:
ez_smb_sync - Synchronizing directories via network using samba or compatible networking protocol!
=============

GrooVim Doc

What is ez_smb_sync?
-----

It's a shell script that uses "unison" for synchronizing directories via network using samba or compatible networking protocol. It's perfect for software development using virtualized environments (VMWare, VirtualBox...), allowing synchronize a local (on your host) and a remote directory (on guest). The synchronization occurs when you start or stop "ez_smb_sync" or if you type the "sync" command when "ez_smb_sync" is running.

How to use!
-----

 * Install "unison" (Debian based example)...

```
apt-get install unison
```

 * Make a copy of the file "model.sh" and give it a name to identify. Examples: "my_project.sh", "my_client_name.sh" and so on...
    - I: This file must be in the same directory of "ez_smb_sync.sh" file;
    - II: For different targets use different copies of the file "model.sh". In that way you can have different settings for different targets easily;
    - III: The synchronization of directories is made bi-directionally.

 * Set the following attributes according to their descriptions in "model.sh":

```
# User name/password to authenticate on samba share!
NET_SHARE_USER = "user_name"
NET_SHARE_PSW = "user_pwd"

# "samba share" on remote machine!
NET_SHARE_REMOTE = "//IP_OR_NAME/FOLDER_A"

# Folder to mount the "share" above!
DIR_MOUNT_REMOTE = "/FOLDER_A/FOLDER_B"

# Enable or disable synchronization. You needn't to inform
# "DIR_MOUNT_SYNC_REMOTE" and "DIR_MOUNT_SYNC_LOCAL" if "SYNC_ENABLED"
# is equal to 0!
SYNC_ENABLED=1

# Remote (mounted) diretory to synchronize!
DIR_MOUNT_SYNC_REMOTE = "/FOLDER_A/FOLDER_B/FOLDER_C"

# Local diretory to synchronize!
DIR_MOUNT_SYNC_LOCAL = "/FOLDER_A/FOLDER_B/FOLDER_C"
```

 * Give execute permissions:

```
chmod a+x ez_smb_sync.sh
chmod a+x model_copy.sh
```

 * Open a terminal and run...

```
sh model_copy.sh
```

... and let the magic happen!

 * Commands - Type at the terminal while "model_copy.sh" ("ez_smb_sync.sh") is running:
    - quit - To exit;
    - sync - To start a synchronizing between "DIR_MOUNT_SYNC_REMOTE" and "DIR_MOUNT_SYNC_LOCAL" directories.

Contact
-----

groovimdoc@gmail.com

Brazil-DF


text:
"""TensorSignature class and utilities."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import collections

from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import parsing_ops

class TensorSignature(collections.namedtuple(
    "TensorSignature", ["dtype", "shape", "is_sparse"])):
  """Signature of the `Tensor` object.

  Useful to check compatibility of tensors.

  Attributes:
    dtype: `DType` object.
    shape: `TensorShape` object.
  """

  def __new__(cls, tensor):
    if isinstance(tensor, ops.SparseTensor):
      return super(TensorSignature, cls).__new__(
          cls, dtype=tensor.values.dtype, shape=None, is_sparse=True)
    return super(TensorSignature, cls).__new__(
        cls, dtype=tensor.dtype, shape=tensor.get_shape(), is_sparse=False)

  def is_compatible_with(self, other):
    """Returns True if signatures are compatible."""

    def _shape_is_compatible_0dim(this, other):
      other = tensor_shape.as_shape(other)
      if this.ndims != other.ndims:
        return False
      for dim, (x_dim, y_dim) in enumerate(zip(this.dims, other.dims)):
        if dim == 0:
          continue
        if not x_dim.is_compatible_with(y_dim):
          return False
      return True

    if other.is_sparse:
      return self.is_sparse and self.dtype.is_compatible_with(other.dtype)
    return (self.dtype.is_compatible_with(other.dtype) and
            _shape_is_compatible_0dim(self.shape, other.shape) and
            not self.is_sparse)

  def get_placeholder(self):
    if self.is_sparse:
      return array_ops.sparse_placeholder(dtype=self.dtype)
    return array_ops.placeholder(dtype=self.dtype,
                                 shape=[None] + list(self.shape[1:]))

  def get_feature_spec(self):
    if self.is_sparse:
      return parsing_ops.VarLenFeature(dtype=self.dtype)
    return parsing_ops.FixedLenFeature(shape=self.shape[1:], dtype=self.dtype)

def tensors_compatible(tensors, signatures):
  """Check that tensors are compatible with signatures.

  Args:
    tensors: Dict of `Tensor` objects or single `Tensor` object.
    signatures: Dict of `TensorSignature` objects or
                single `TensorSignature` object.

  Returns:
    True if all tensors are compatible, False otherwise.
  """
  # Dict of Tensors as input.
  if isinstance(tensors, dict):
    if not isinstance(signatures, dict):
      return False
    for key in signatures:
      if key not in tensors:
        return False
      if not TensorSignature(tensors[key]).is_compatible_with(signatures[key]):
        return False
    return True

  # Single tensor as input.
  if isinstance(signatures, dict):
    return False
  return TensorSignature(tensors).is_compatible_with(signatures)

def create_signatures(tensors):
  """Creates TensorSignature objects for given tensors.

  Args:
    tensors: Dict of `Tensor` objects or single `Tensor`.

  Returns:
    Dict of `TensorSignature` objects or single `TensorSignature`.
  """
  if isinstance(tensors, dict):
    return {
        key: TensorSignature(tensors[key]) for key in tensors}
  return TensorSignature(tensors)

def create_placeholders_from_signatures(signatures):
  """Creates placeholders from given signatures.

  Args:
    signatures: Dict of `TensorSignature` objects or single `TensorSignature`.

  Returns:
    Dict of `tf.placeholder` objects or single `tf.placeholder`.
  """
  if not isinstance(signatures, dict):
    return signatures.get_placeholder()
  return {
      key: signatures[key].get_placeholder()
      for key in signatures}

def create_example_parser_from_signatures(signatures, examples_batch,
                                          single_feature_name="feature"):
  """Creates example parser from given signatures.

  Args:
    signatures: Dict of `TensorSignature` objects or single `TensorSignature`.
    examples_batch: string `Tensor` of serialized `Example` proto.
    single_feature_name: string, single feature name.

  Returns:
    features: `Tensor` or `dict` of `Tensor` objects.
  """
  feature_spec = {}
  if not isinstance(signatures, dict):
    feature_spec[single_feature_name] = signatures.get_feature_spec()
  else:
    feature_spec = {key: signatures[key].get_feature_spec()
                    for key in signatures}
  return parsing_ops.parse_example(examples_batch, feature_spec)


text:
<ng-template #inputTemplate>
  <ng-content></ng-content>
</ng-template>

<ng-template #buttonsTemplate>

    <button
      aria-label="Button 1"
      class="sky-btn sky-btn-default host-service-button-1"
      type="button"
    ></button>

    <button
      aria-label="Button 2"
      class="sky-btn sky-btn-default host-service-button-2"
      type="button"
    ></button>

</ng-template>


text:
package org.apache.tez.http.async.netty;

import org.asynchttpclient.AsyncHandler;
import org.asynchttpclient.HttpResponseBodyPart;
import org.asynchttpclient.HttpResponseStatus;
import org.asynchttpclient.Response;
import org.apache.hadoop.classification.InterfaceAudience;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.handler.codec.http.HttpHeaders;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * Same as {@link org.asynchttpclient.BodyDeferringAsyncHandler} with additional checks handle
 * errors in getResponse(). Based on testing, at very high load {@link org.asynchttpclient
 * .BodyDeferringAsyncHandler} gets to hung state in getResponse() as it tries to wait
 * indefinitely for headers to arrive.  This class tries to fix the problem by waiting only for
 * the connection timeout.
 */
@InterfaceAudience.Private
class TezBodyDeferringAsyncHandler implements AsyncHandler<Response> {
  private static final Logger LOG = LoggerFactory.getLogger(TezBodyDeferringAsyncHandler.class);

  private final Response.ResponseBuilder responseBuilder = new Response.ResponseBuilder();
  private final CountDownLatch headersArrived = new CountDownLatch(1);
  private final OutputStream output;

  private volatile boolean responseSet;
  private volatile boolean statusReceived;
  private volatile Response response;
  private volatile Throwable throwable;

  private final Semaphore semaphore = new Semaphore(1);

  private final URL url;
  private final int headerReceiveTimeout;

  TezBodyDeferringAsyncHandler(final OutputStream os, final URL url, final int timeout) {
    this.output = os;
    this.responseSet = false;
    this.url = url;
    this.headerReceiveTimeout = timeout;
  }

  public void onThrowable(Throwable t) {
    this.throwable = t;
    // Counting down to handle error cases too.
    // In "premature exceptions" cases, the onBodyPartReceived() and
    // onCompleted()
    // methods will never be invoked, leaving caller of getResponse() method
    // blocked forever.
    try {
      semaphore.acquire();
    } catch (InterruptedException e) {
      // Ignore
    } finally {
      LOG.error("Error in asyncHandler ", t);
      headersArrived.countDown();
      semaphore.release();
    }
    try {
      closeOut();
    } catch (IOException e) {
      // ignore
    }
  }

  public AsyncHandler.State onStatusReceived(HttpResponseStatus responseStatus) throws Exception {
    responseBuilder.reset();
    responseBuilder.accumulate(responseStatus);
    statusReceived = true;
    return AsyncHandler.State.CONTINUE;
  }

  @Override
  public AsyncHandler.State onHeadersReceived(HttpHeaders headers) throws Exception {
    responseBuilder.accumulate(headers);
    return AsyncHandler.State.CONTINUE;
  }

  public AsyncHandler.State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
    // body arrived, flush headers
    if (!responseSet) {
      response = responseBuilder.build();
      responseSet = true;
      headersArrived.countDown();
    }
    output.write(bodyPart.getBodyPartBytes());
    return AsyncHandler.State.CONTINUE;
  }

  protected void closeOut() throws IOException {
    try {
      output.flush();
    } finally {
      output.close();
    }
  }

  public Response onCompleted() throws IOException {
    if (!responseSet) {
      response = responseBuilder.build();
      responseSet = true;
    }
    // Counting down to handle error cases too.
    // In "normal" cases, latch is already at 0 here
    // But in other cases, for example when because of some error
    // onBodyPartReceived() is never called, the caller
    // of getResponse() would remain blocked infinitely.
    // By contract, onCompleted() is always invoked, even in case of errors
    headersArrived.countDown();
    closeOut();
    try {
      semaphore.acquire();
      if (throwable != null) {
        IOException ioe = new IOException(throwable.getMessage());
        ioe.initCause(throwable);
        throw ioe;
      } else {
        // sending out current response
        return responseBuilder.build();
      }
    } catch (InterruptedException e) {
      return null;
    } finally {
      semaphore.release();
    }
  }

  /**
   * This method -- unlike Future<Reponse>.get() -- will block only as long,
   * as headers arrive. This is useful for large transfers, to examine headers
   * ASAP, and defer body streaming to it's fine destination and prevent
   * unneeded bandwidth consumption. The response here will contain the very
   * 1st response from server, so status code and headers, but it might be
   * incomplete in case of broken servers sending trailing headers. In that
   * case, the "usual" Future<Response>.get() method will return complete
   * headers, but multiple invocations of getResponse() will always return the
   * 1st cached, probably incomplete one. Note: the response returned by this
   * method will contain everything except the response body itself,
   * so invoking any method like Response.getResponseBodyXXX() will result in
   * error! Also, please not that this method might return null
   * in case of some errors.
   *
   * @return a {@link Response}
   * @throws InterruptedException
   */
  public Response getResponse() throws InterruptedException, IOException {
    /**
     * Based on testing, it is possible that it is in connected state, but the headers are not
     * received. Instead of waiting forever, close after timeout for next retry.
     */
    boolean result = headersArrived.await(headerReceiveTimeout, TimeUnit.MILLISECONDS);
    if (!result) {
      LOG.error("Breaking after timeout={}, url={}, responseSet={} statusReceived={}",
          headerReceiveTimeout, url, responseSet, statusReceived);
      return null;
    }
    try {
      semaphore.acquire();
      if (throwable != null) {
        IOException ioe = new IOException(throwable.getMessage());
        ioe.initCause(throwable);
        throw ioe;
      } else {
        return response;
      }
    } finally {
      semaphore.release();
    }
  }

  /**
   * A simple helper class that is used to perform automatic "join" for async
   * download and the error checking of the Future of the request.
   */
  static class BodyDeferringInputStream extends FilterInputStream {
    private final Future<Response> future;
    private final TezBodyDeferringAsyncHandler bdah;

    public BodyDeferringInputStream(final Future<Response> future,
        final TezBodyDeferringAsyncHandler bdah, final InputStream in) {
      super(in);
      this.future = future;
      this.bdah = bdah;
    }

    /**
     * Closes the input stream, and "joins" (wait for complete execution
     * together with potential exception thrown) of the async request.
     */
    public void close() throws IOException {
      // close
      super.close();
      // "join" async request
      try {
        getLastResponse();
      } catch (Exception e) {
        IOException ioe = new IOException(e.getMessage());
        ioe.initCause(e);
        throw ioe;
      }
    }

    /**
     * Delegates to {@link TezBodyDeferringAsyncHandler#getResponse()}. Will
     * blocks as long as headers arrives only. Might return
     * null. See
     * {@link TezBodyDeferringAsyncHandler#getResponse()} method for details.
     *
     * @return a {@link Response}
     * @throws InterruptedException
     */
    public Response getAsapResponse() throws InterruptedException, IOException {
      return bdah.getResponse();
    }

    /**
     * Delegates to Future<Response>#get() method. Will block
     * as long as complete response arrives.
     *
     * @return a {@link Response}
     * @throws InterruptedException
     * @throws java.util.concurrent.ExecutionException
     */
    public Response getLastResponse() throws InterruptedException, ExecutionException {
      return future.get();
    }
  }
}


text:
//
// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

/*  Implements an utility which takes GLSL source code (either defined in a file, or explicitly by the user) and converts it
 *  to a SPIR-V blob. The blob can then be used to initialize a Anvil::ShaderModule instance.
 *
 *  Optionally, users can inject arbitrary number of #defines (with or without the accompanying value).
 **/
#ifndef MISC_GLSL_TO_SPIRV_H
#define MISC_GLSL_TO_SPIRV_H

#include "config.h"
#include "misc/debug.h"
#include "misc/types.h"
#include <map>
#include <memory>
#include <sstream>
#include <vector>

#ifdef ANVIL_LINK_WITH_GLSLANG
    #ifdef _MSC_VER
        #pragma warning(push)
        #pragma warning(disable: 4619)
        #pragma warning(disable: 4464)
    #endif

    #include "../../deps/glslang/glslang/Public/ShaderLang.h"

    #ifdef _MSC_VER
        #pragma warning(pop)
    #endif
#endif

namespace Anvil
{
    #ifdef ANVIL_LINK_WITH_GLSLANG
        /** Holds glslang limit values, extracted from a physical device instance. */
        class GLSLangLimits
        {
        public:
            /* Constructor. */
            explicit GLSLangLimits(std::weak_ptr<Anvil::BaseDevice> device_ptr);

            /* Destructor */
            ~GLSLangLimits()
            {
                /* Stub */
            }

            /** Retrieves a pointer to an initialized TBuiltInResource instance */
            const struct TBuiltInResource* get_resource_ptr() const
            {
                return m_resources_ptr.get();
            }

        private:
            /* Private functions */
            ANVIL_DISABLE_ASSIGNMENT_OPERATOR(GLSLangLimits);
            ANVIL_DISABLE_COPY_CONSTRUCTOR(GLSLangLimits);

            /* Private fields */
            std::unique_ptr<struct TBuiltInResource> m_resources_ptr;
        };
    #endif

    /** Loads a GLSL shader from the file specified at creation time, customizes it with a user-specified set of #defines,
     *  and then converts the source code to a SPIR-V blob.
     **/
    class GLSLShaderToSPIRVGenerator
    {
    public:
        /* Public type definitions */
        typedef enum
        {
            EXTENSION_BEHAVIOR_DISABLE,
            EXTENSION_BEHAVIOR_ENABLE,
            EXTENSION_BEHAVIOR_REQUIRE,
            EXTENSION_BEHAVIOR_WARN,
        } ExtensionBehavior;

        typedef enum
        {
            MODE_LOAD_SOURCE_FROM_FILE,
            MODE_USE_SPECIFIED_SOURCE
        } Mode;

        /* Public functions */

        /** Creates a new GLSLShaderToSPIRVGenerator instance.
         *
         *  @param evice_ptr    Logical device, whose limit values should be passed to glslang. Must not
         *                      be NULL.
         *  @param mode         Defines type of contents specified under @param data.
         *  @param data         If @param mode is MODE_LOAD_SOURCE_FROM_FILE, @param data holds the name
         *                      of the file (possibly including path) where the GLSL source code is stored.
         *                      If @param mode is MODE_USE_SPECIFIED_SOURCE, @param data holds GLSL source code
         *                      which should be used. This mode is NOT supported if ANVIL_LINK_WITH_GLSLANG
         *                      macro is undefined.
         *  @param shader_stage Shader stage described by the file.
         **/
         static std::shared_ptr<GLSLShaderToSPIRVGenerator> create(std::weak_ptr<Anvil::BaseDevice> device_ptr,
                                                                   const Mode&                      mode,
                                                                   std::string                      data,
                                                                   ShaderStage                      shader_stage);

         /** Destructor. Releases all created Vulkan objects, as well as the SPIR-V blob data. */
         ~GLSLShaderToSPIRVGenerator();

         /** Adds a "#define [definition_name] [value]" line after the first newline found in the
          *  source code.
          *
          *  The definition will be inserted AFTER extensions, if any have been requested by using
          *  the add_extension_behavior() mechanism.
          *
          *  @param definition_name As specified above.
          *  @param value           As specified above.
          *
          *  @return true if the function succeeded, false otherwise.
          **/
         bool add_definition_value_pair(std::string definition_name,
                                        std::string value);

         /** Adds a "#define [definition_name] [value]" line after the first newline found in the
          *  source code.
          *
          *  The definitions will be inserted AFTER extensions, if any have been requested by using
          *  the add_extension_behavior() mechanism.
          *
          *  @param definition_name As specified above.
          *  @param value           As specified above.
          *
          *  @return true if the function succeeded, false otherwise.
          **/
         template <typename T>
         bool add_definition_value_pair(std::string definition_name,
                                        T           value)
         {
            std::stringstream value_sstream;

            value_sstream << value;

            return add_definition_value_pair(definition_name,
                                             value_sstream.str() );
         }

         /** Adds a "#define [definition_name]" line after the first newline found in the source code.
          *
          *  The definition will be inserted AFTER extensions, if any have been requested by using
          *  the add_extension_behavior() mechanism.
          *
          *  @param definition_name As specified above.
          *
          *  @return true if the function succeeded, false otherwise.
          **/
         bool add_empty_definition(std::string definition_name);

         /* Registers a new extension behavior specification.
          *
          * At baking time, a new line, specifying the extension behavior, will be added
          * at the beginning of the shader.
          *
          * @param extension_name Name of the GLSL extension
          * @param behavior       Behavior to use for the extension. See documentation of
          *                       the enum for more details.
          *
          * @return true if successful, false otherwise.
          **/
         bool add_extension_behavior(std::string       extension_name,
                                     ExtensionBehavior behavior);

         /* Loads the GLSL source code, injects the requested #defines and writes the result code
          * to a temporary file. Then, the func invokes glslangvalidator to build a SPIR-V blob
          * of the updated GLSL shader, deletes the temp file, loads up the blob and purges it.
          *
          * @return true if successful, false otherwise.
          **/
         bool bake_spirv_blob();

         /* Converts a ExtensionBehavior enum value to a corresponding GLSL definition */
         std::string get_extension_behavior_glsl_code(const ExtensionBehavior& value) const;

         /** Tells what shader stage the encapsulated GLSL shader descirbes. */
         ShaderStage get_shader_stage() const
         {
             return m_shader_stage;
         }

         /** Bakes a SPIR-V blob by injecting earlier specified #define name+value pairs into the
          *  GLSL source code and passing such shader code to glslangvalidator.
          *
          *  The baking is only performed once. If the shader has already been baked, the blob
          *  will not be re-created
          *
          *  @return SPIR-V blob or nullptr if the function failed.
          **/
         const char* get_spirv_blob()
         {
             if (m_spirv_blob == nullptr)
             {
                 bool result = bake_spirv_blob();

                 ANVIL_REDUNDANT_VARIABLE(result);

                 anvil_assert(result);
                 anvil_assert(m_spirv_blob != nullptr);
             }

             return m_spirv_blob;
         }

         /** Returns the number of bytes the SPIR-V blob, accessible via get_spirv_blob(), takes. */
         const uint32_t get_spirv_blob_size()
         {
             if (m_spirv_blob == nullptr)
             {
                 bool result = bake_spirv_blob();

                 ANVIL_REDUNDANT_VARIABLE(result);

                 anvil_assert(result);
             }

             anvil_assert(m_spirv_blob_size > 0);

             return m_spirv_blob_size;
         }

    private:
        /* Private type declarations */
        typedef std::map<std::string, ExtensionBehavior> ExtensionNameToExtensionBehaviorMap;
        typedef std::map<std::string, std::string>       DefinitionNameToValueMap;

        /* Private functions */
        ANVIL_DISABLE_ASSIGNMENT_OPERATOR(GLSLShaderToSPIRVGenerator);
        ANVIL_DISABLE_COPY_CONSTRUCTOR   (GLSLShaderToSPIRVGenerator);

        /* Constructor. Please see create() documentation for specification */
        explicit GLSLShaderToSPIRVGenerator(std::weak_ptr<Anvil::BaseDevice> device_ptr,
                                            const Mode&                      mode,
                                            std::string                      data,
                                            ShaderStage                      shader_stage);

        #ifdef ANVIL_LINK_WITH_GLSLANG
            bool        bake_spirv_blob_by_calling_glslang(const char* body);
            EShLanguage get_glslang_shader_stage          () const;
        #else
            bool bake_spirv_blob_by_spawning_glslang_process(const std::string& glsl_filename_with_path,
                                                             const std::string& spirv_filename_with_path);
        #endif

        /* Private members */
        #ifdef ANVIL_LINK_WITH_GLSLANG
            GLSLangLimits m_limits;
        #endif

        std::string m_data;
        Mode        m_mode;

        ShaderStage m_shader_stage;
        char*       m_spirv_blob;
        uint32_t    m_spirv_blob_size;

        DefinitionNameToValueMap            m_definition_values;
        ExtensionNameToExtensionBehaviorMap m_extension_behaviors;
    };
}; /* namespace Anvil */

#endif /* MISC_GLSL_TO_SPIRV_H */


text:
About

Created by Alykhan Kanji.

This is an open source application available on GitHub here.

Contains information provided by the University of Waterloo under license on an 'as is' basis.

    Contact Me

  {% import 'footer.html' as footer %}
  {{ footer.setFooter('About') }}


text:
This folder contains scripts and files for testing requests against the server from the client side.

### Rested.App scripts - see: http://www.helloresolven.com/portfolio/rested/

./rested/*

- Health.request - Validate Health ping is returning 200 OK.
- Info.request - Receives information on the server and 200 OK.
- Metrics.request - Receives information and metrics on the server and 200 OK.
- Deploy.request - Used to send a deploy service requests to CoreOS fleet 200 OK.
- Status.request - Used to check on the status of a deploy 200 OK.


text:
* [
        louisdh / panelkit
](https://github.com/louisdh/panelkit):
        A UI framework that enables panels on iOS.

* [
        jerkoch / SwipeCellKit
](https://github.com/jerkoch/SwipeCellKit):
        Swipeable UITableViewCell based on the stock Mail.app, implemented in Swift.

* [
        WenchaoD / FSPagerView
](https://github.com/WenchaoD/FSPagerView):
        FSPagerView is an elegant Screen Slide Library. It is extremely helpful for making Banner、Product Show、Welcome/Guide Pages、Screen/ViewController Sliders.

* [
        631106979 / WCLShineButton
](https://github.com/631106979/WCLShineButton):
        This is a UI lib for iOS. Effects like shining.

* [
        saoudrizwan / Dance
](https://github.com/saoudrizwan/Dance):
        A radical & elegant animation library built for iOS.

* [
        KelvinJin / AnimatedCollectionViewLayout
](https://github.com/KelvinJin/AnimatedCollectionViewLayout):
        A UICollectionViewLayout subclass that adds custom transitions/animations to the UICollectionView without effecting your existing code.

* [
        hyperoslo / Spots
](https://github.com/hyperoslo/Spots):

🎍 Spots is a cross-platform view controller framework for building component-based UIs

* [
        Ramotion / folding-cell
](https://github.com/Ramotion/folding-cell):
        FoldingCell is an expanding content cell inspired by folding paper material

* [
        danielgindi / Charts
](https://github.com/danielgindi/Charts):
        Beautiful charts for iOS/tvOS/OSX! The Apple side of the crossplatform MPAndroidChart.

* [
        vsouza / awesome-ios
](https://github.com/vsouza/awesome-ios):
        A curated list of awesome iOS ecosystem, including Objective-C and Swift Projects

* [
        DholStudio / DSGradientProgressView
](https://github.com/DholStudio/DSGradientProgressView):
        A simple animated progress bar in Swift

* [
        Alamofire / Alamofire
](https://github.com/Alamofire/Alamofire):
        Elegant HTTP Networking in Swift

* [
        eggswift / ESTabBarController
](https://github.com/eggswift/ESTabBarController):
        ESTabBarController is a Swift model for customize UI, badge and adding animation to tabbar items. Support lottie!

* [
        raywenderlich / swift-algorithm-club
](https://github.com/raywenderlich/swift-algorithm-club):
        Algorithms and data structures in Swift, with explanations!

* [
        lkzhao / Hero
](https://github.com/lkzhao/Hero):
        Elegant transition library for iOS & tvOS

* [
        devxoul / graygram-ios
](https://github.com/devxoul/graygram-ios):
        [40시간만에 Swift로 iOS 앱 만들기] 흑백 사진 전용 소셜 미디어 앱

* [
        dkhamsing / open-source-ios-apps
](https://github.com/dkhamsing/open-source-ios-apps):

📱 Collaborative List of Open-Source iOS Apps

* [
        roberthein / TinyConstraints
](https://github.com/roberthein/TinyConstraints):
        Nothing but sugar.

* [
        lhc70000 / iina
](https://github.com/lhc70000/iina):
        The modern video player for macOS.

* [
        ReactiveCocoa / ReactiveCocoa
](https://github.com/ReactiveCocoa/ReactiveCocoa):
        Streams of values over time

* [
        SwiftyJSON / SwiftyJSON
](https://github.com/SwiftyJSON/SwiftyJSON):
        The better way to deal with JSON data in Swift

* [
        Moya / Moya
](https://github.com/Moya/Moya):
        Network abstraction layer written in Swift.

* [
        CosmicMind / Material
](https://github.com/CosmicMind/Material):
        An animation and graphics framework for Material Design in Swift.

* [
        remirobert / Dotzu
](https://github.com/remirobert/Dotzu):

📱👀 In-App iOS Debugging Tool With Enhanced Logging, Networking Info, Crash reporting And More.

* [
        ReactiveX / RxSwift
](https://github.com/ReactiveX/RxSwift):
        Reactive Programming in Swift

#### objective-c
* [
        airbnb / lottie-ios
](https://github.com/airbnb/lottie-ios):
        An iOS library to natively render After Effects vector animations

* [
        hawk0620 / ZPCamera
](https://github.com/hawk0620/ZPCamera):
        An OpenSource Camera App.You can see the introduction in http://hawk0620.github.io/blog/2017/02/17/zpcamera-opensource-share/

* [
        filelife / SnapseedImitation
](https://github.com/filelife/SnapseedImitation):
        App of imitation SnapSeed.

* [
        imlifengfeng / FFToast
](https://github.com/imlifengfeng/FFToast):
        This is a simple extension of an iOS message notifications that can be used to pop up a prompt at the top or bottom of the screen. You can customize it according to their own display.

* [
        Instagram / IGListKit
](https://github.com/Instagram/IGListKit):
        A data-driven UICollectionView framework for building fast and flexible lists.

* [
        Jasonette / JASONETTE-iOS
](https://github.com/Jasonette/JASONETTE-iOS):

📡 Native App over HTTP, on iOS

* [
        bang590 / JSPatch
](https://github.com/bang590/JSPatch):
        JSPatch bridge Objective-C and Javascript using the Objective-C runtime. You can call any Objective-C class and method in JavaScript by just including a small engine. JSPatch is generally used to hotfix iOS App.

* [
        iOSSinger / SGLivingPublisher
](https://github.com/iOSSinger/SGLivingPublisher):
        不用第三方写一个简单的推流软件

* [
        Draveness / iOS-Source-Code-Analyze
](https://github.com/Draveness/iOS-Source-Code-Analyze):
        深入解析 iOS 开源项目

* [
        ibireme / YYKit
](https://github.com/ibireme/YYKit):
        A collection of iOS components.

* [
        rs / SDWebImage
](https://github.com/rs/SDWebImage):
        Asynchronous image downloader with cache support as a UIImageView category

* [
        Assuner-Lee / LPDQuoteImagesView
](https://github.com/Assuner-Lee/LPDQuoteImagesView):
        (pickImage and quote 仿qq微信)只需要几行简单的代码,就可以引入多选照片并引用的功能模块(贴上一个view,就获得了全部).

* [
        realm / realm-cocoa
](https://github.com/realm/realm-cocoa):
        Realm is a mobile database: a replacement for Core Data & SQLite

* [
        Kapeli / Dash-iOS
](https://github.com/Kapeli/Dash-iOS):
        Dash gives your iPad and iPhone instant offline access to 150+ API documentation sets

* [
        BradLarson / GPUImage
](https://github.com/BradLarson/GPUImage):
        An open source iOS framework for GPU-based image and video processing

* [
        nicklockwood / iCarousel
](https://github.com/nicklockwood/iCarousel):
        A simple, highly customisable, data-driven 3D carousel for iOS and Mac OS

* [
        buginux / WeChatRedEnvelop
](https://github.com/buginux/WeChatRedEnvelop):
        iOS版微信抢红包Tweak

* [
        WenchaoD / FSCalendar
](https://github.com/WenchaoD/FSCalendar):
        A fully customizable iOS calendar library, compatible with Objective-C and Swift

* [
        MortimerGoro / MGSwipeTableCell
](https://github.com/MortimerGoro/MGSwipeTableCell):
        An easy to use UITableViewCell subclass that allows to display swippable buttons with a variety of transitions.

* [
        alibaba / BeeHive
](https://github.com/alibaba/BeeHive):

🐝 BeeHive is a solution for iOS Application module programs, it absorbed the Spring Framework API service concept to avoid to coupling between modules.

* [
        robbiehanson / CocoaAsyncSocket
](https://github.com/robbiehanson/CocoaAsyncSocket):
        Asynchronous socket networking library for Mac and iOS

* [
        nerdycat / NerdyUI
](https://github.com/nerdycat/NerdyUI):
        An easy way to create and layout UI components for iOS.

* [
        Flipboard / FLEX
](https://github.com/Flipboard/FLEX):
        An in-app debugging and exploration tool for iOS

* [
        jessesquires / JSQMessagesViewController
](https://github.com/jessesquires/JSQMessagesViewController):
        An elegant messages UI library for iOS

* [
        marcuswestin / WebViewJavascriptBridge
](https://github.com/marcuswestin/WebViewJavascriptBridge):
        An iOS/OSX bridge for sending messages between Obj-C and JavaScript in UIWebViews/WebViews

#### go
* [
        upspin / upspin
](https://github.com/upspin/upspin):
        Upspin

* [
        xiaojiaqi / 10billionhongbaos
](https://github.com/xiaojiaqi/10billionhongbaos):
        golang 实现单机支持100万用户,同时模拟了2015年微信红包的1400万QPS的场景,让服务器在压力下,轻松地完成业务。

* [
        wspl / creeper
](https://github.com/wspl/creeper):

🐾 Creeper - The Next Generation Crawler Framework (Go)

* [
        kubernetes / kubernetes
](https://github.com/kubernetes/kubernetes):
        Production-Grade Container Scheduling and Management

* [
        asciimoo / wuzz
](https://github.com/asciimoo/wuzz):
        Interactive cli tool for HTTP inspection

* [
        wallix / awless
](https://github.com/wallix/awless):
        A Mighty CLI for AWS

* [
        golang / go
](https://github.com/golang/go):
        The Go programming language

* [
        docker / docker
](https://github.com/docker/docker):
        Docker - the open-source application container engine

* [
        avelino / awesome-go
](https://github.com/avelino/awesome-go):
        A curated list of awesome Go frameworks, libraries and software

* [
        seiflotfy / hyperbitbit
](https://github.com/seiflotfy/hyperbitbit):
        HyperBitBit

* [
        hellofresh / janus
](https://github.com/hellofresh/janus):
        An Api Gateway written in Go

* [
        muesli / beehive
](https://github.com/muesli/beehive):
        A flexible event and agent system with lots of bees 🐝

* [
        astaxie / build-web-application-with-golang
](https://github.com/astaxie/build-web-application-with-golang):
        A golang ebook intro how to build a web with golang

* [
        mholt / caddy
](https://github.com/mholt/caddy):
        Fast, cross-platform HTTP/2 web server with automatic HTTPS

* [
        pingcap / tidb
](https://github.com/pingcap/tidb):
        TiDB is a distributed NewSQL database compatible with MySQL protocol

* [
        getlantern / lantern
](https://github.com/getlantern/lantern):

🔴Lantern lastest version https://github.com/getlantern/lantern/releases/tag/latest 🔴 蓝灯最新版本下载 https://github.com/getlantern/forum/issues/833 🔴

* [
        natdm / typewriter
](https://github.com/natdm/typewriter):
        Synchronize your front-end models with your Go models

* [
        astaxie / beego
](https://github.com/astaxie/beego):
        beego is an open-source, high-performance web framework for the Go programming language.

* [
        tj / mmake
](https://github.com/tj/mmake):
        Modern Make

* [
        zikes / chrisify
](https://github.com/zikes/chrisify):
        Adds some much needed Chris to an image.

* [
        grafana / grafana
](https://github.com/grafana/grafana):
        The tool for beautiful monitoring and metric analytics & dashboards for Graphite, InfluxDB & Prometheus & More

* [
        cockroachdb / cockroach
](https://github.com/cockroachdb/cockroach):
        CockroachDB - the scalable, survivable, strongly-consistent SQL database

* [
        prometheus / prometheus
](https://github.com/prometheus/prometheus):
        The Prometheus monitoring system and time series database.

* [
        kubernetes / kops
](https://github.com/kubernetes/kops):
        Kubernetes Operations (kops) - Production Grade K8s Installation, Upgrades, and Management

* [
        spf13 / hugo
](https://github.com/spf13/hugo):
        A Fast and Flexible Static Site Generator built with love in GoLang

#### javascript
* [
        freeCodeCamp / freeCodeCamp
](https://github.com/freeCodeCamp/freeCodeCamp):
        The https://freeCodeCamp.com open source codebase and curriculum. Learn to code and help nonprofits.

* [
        tebelorg / TA.Gui
](https://github.com/tebelorg/TA.Gui):
        Tool for non-developers and business users to automate web apps

* [
        vuejs / vue
](https://github.com/vuejs/vue):
        A progressive, incrementally-adoptable JavaScript framework for building UI on the web.

* [
        botpress / botpress
](https://github.com/botpress/botpress):

🤖 The only sane way of building great bots. 👉

* [
        facebook / react
](https://github.com/facebook/react):
        A declarative, efficient, and flexible JavaScript library for building user interfaces.

* [
        ecmadao / hacknical
](https://github.com/ecmadao/hacknical):
        A website for github user to make a better resume.

* [
        getify / You-Dont-Know-JS
](https://github.com/getify/You-Dont-Know-JS):
        A book series on JavaScript. @YDKJS on twitter.

* [
        idoco / intergram
](https://github.com/idoco/intergram):
        Free live chat widget linked to your Telegram messenger

* [
        stojanovic / alexa-skill-kit
](https://github.com/stojanovic/alexa-skill-kit):
        Library for effortless Alexa Skill development with AWS Lambda

* [
        airbnb / javascript
](https://github.com/airbnb/javascript):
        JavaScript Style Guide

* [
        KELiON / cerebro
](https://github.com/KELiON/cerebro):
        Open-source productivity booster with a brain

* [
        twbs / bootstrap
](https://github.com/twbs/bootstrap):
        The most popular HTML, CSS, and JavaScript framework for developing responsive, mobile first projects on the web.

* [
        github / open-source-guide
](https://github.com/github/open-source-guide):
        Community guides for open source creators

* [
        NekR / offline-plugin
](https://github.com/NekR/offline-plugin):
        Offline plugin (ServiceWorker, AppCache) for webpack (http://webpack.github.io/)

* [
        mzabriskie / axios
](https://github.com/mzabriskie/axios):
        Promise based HTTP client for the browser and node.js

* [
        queckezz / fmt-obj
](https://github.com/queckezz/fmt-obj):
        Prettifies any javascript object in your console. Make it look awesome! 💄

* [
        d4t4x / data-selfie
](https://github.com/d4t4x/data-selfie):
* [
        Jianru-Lin / lambda-view
](https://github.com/Jianru-Lin/lambda-view):
        A New Tool for Reading JavaScript Code in 2017

* [
        webpack / webpack
](https://github.com/webpack/webpack):
        A bundler for javascript and friends. Packs many modules into a few bundled assets. Code Splitting allows to load parts for the application on demand. Through "loaders," modules can be CommonJs, AMD, ES6 modules, CSS, Images, JSON, Coffeescript, LESS, ... and your custom stuff.

* [
        d3 / d3
](https://github.com/d3/d3):
        Bring data to life with SVG, Canvas and HTML. 📊📈🎉

* [
        facebookincubator / create-react-app
](https://github.com/facebookincubator/create-react-app):
        Create React apps with no build configuration.

* [
        bilbof / purser
](https://github.com/bilbof/purser):
        A lightweight JavaScript library for preserving user data from first website visit to signup.

* [
        facebook / react-native
](https://github.com/facebook/react-native):
        A framework for building native apps with React.

* [
        QingWei-Li / docsify
](https://github.com/QingWei-Li/docsify):

🃏 A magical documentation site generator.

* [
        vadimdemedes / trevor
](https://github.com/vadimdemedes/trevor):

🚦 Your own mini Travis CI to run tests locally

#### ruby
* [
        jondot / awesome-react-native
](https://github.com/jondot/awesome-react-native):
        An "awesome" type curated list of React Native components, news, tools, and learning material

* [
        rails / rails
](https://github.com/rails/rails):
        Ruby on Rails

* [
        jekyll / jekyll
](https://github.com/jekyll/jekyll):

🌐 Jekyll is a blog-aware, static site generator in Ruby

* [
        fastlane / fastlane
](https://github.com/fastlane/fastlane):

🚀 The easiest way to automate building and releasing your iOS and Android apps

* [
        kilimchoi / engineering-blogs
](https://github.com/kilimchoi/engineering-blogs):
        A curated list of engineering blogs

* [
        Homebrew / brew
](https://github.com/Homebrew/brew):

🍺 The missing package manager for macOS

* [
        discourse / discourse
](https://github.com/discourse/discourse):
        A platform for community discussion. Free, open, simple.

* [
        mitchellh / vagrant
](https://github.com/mitchellh/vagrant):
        Vagrant is a tool for building and distributing development environments.

* [
        Tim9Liu9 / TimLiu-iOS
](https://github.com/Tim9Liu9/TimLiu-iOS):
        iOS开发常用三方库、插件、知名博客等等

* [
        Thibaut / devdocs
](https://github.com/Thibaut/devdocs):
        API Documentation Browser

* [
        bayandin / awesome-awesomeness
](https://github.com/bayandin/awesome-awesomeness):
        A curated list of awesome awesomeness

* [
        rapid7 / metasploit-framework
](https://github.com/rapid7/metasploit-framework):
        Metasploit Framework

* [
        caskroom / homebrew-cask
](https://github.com/caskroom/homebrew-cask):
        A CLI workflow for the administration of Mac applications distributed as binaries

* [
        Homebrew / homebrew-core
](https://github.com/Homebrew/homebrew-core):

🍻 Core formulae for the Homebrew package manager

* [
        danger / danger
](https://github.com/danger/danger):

🚫 Stop saying "you forgot to …" in code review

* [
        kigster / simple-feed
](https://github.com/kigster/simple-feed):
        This gem implements a flexible time-ordered activity feeds commonly used within social networking applications. As events occur, they are pushed into the Feed and distributed to all users that need to see the event. Upon the user visiting their "feed page", a pre-populated ordered list of events is returned by the library.

* [
        plataformatec / devise
](https://github.com/plataformatec/devise):
        Flexible authentication solution for Rails with Warden.

* [
        exercism / exercism.io
](https://github.com/exercism/exercism.io):
        Quickly ramp up in new programming languages.

* [
        shakacode / react_on_rails
](https://github.com/shakacode/react_on_rails):
        Integration of React + Webpack + Rails to build Universal (Isomorphic) Apps

* [
        ruby / ruby
](https://github.com/ruby/ruby):
        The Ruby Programming Language

* [
        bbatsov / rubocop
](https://github.com/bbatsov/rubocop):
        A Ruby static code analyzer, based on the community Ruby style guide.

* [
        rails / webpacker
](https://github.com/rails/webpacker):
        Use Webpack to manage app-like JavaScript modules in Rails

* [
        rails-api / active_model_serializers
](https://github.com/rails-api/active_model_serializers):
        ActiveModel::Serializer implementation and Rails hooks

* [
        thoughtbot / guides
](https://github.com/thoughtbot/guides):
        A guide for programming in style.

* [
        EugenMayer / docker-sync
](https://github.com/EugenMayer/docker-sync):
        Run your application at full speed while syncing your code for development, finally empowering you to utilize docker for development under OSX


text:
static const char THIS_FILE[] = __FILE__;
#define new DEBUG_NEW

#endif

//////////////////////////////////////////////////////////////////////
// Code

// Register the standard CSerialWnd COM message
const UINT CSerialWnd::mg_nDefaultComMsg = ::RegisterWindowMessage(_T("CSerialWnd_DefaultComMsg"));

CSerialWnd::CSerialWnd()
	: m_hwndDest(0)
	, m_nComMsg(WM_NULL)
	, m_lParam(0)
{
}

CSerialWnd::~CSerialWnd()
{
	// Check if the thread handle is still there. If so, then we
	// didn't close the serial port. We cannot depend on the
	// CSerial destructor, because if it calls Close then it
	// won't call our overridden Close.
	if (m_hThread)
	{
		// Display a warning
		_RPTF0(_CRT_WARN, "CSerialWnd::~CSerialWnd - Serial port not closed\n");

		// Close implicitly
		Close();
	}
}

LONG CSerialWnd::Open (LPCTSTR lpszDevice, HWND hwndDest, UINT nComMsg, LPARAM lParam, DWORD dwInQueue, DWORD dwOutQueue)
{
	// Call the base class first
	long lLastError = CSerialEx::Open(lpszDevice,dwInQueue,dwOutQueue);
	if (lLastError != ERROR_SUCCESS)
		return lLastError;

	// Save the window handle, notification message and user message
	m_hwndDest = hwndDest;
	m_nComMsg  = nComMsg?nComMsg:mg_nDefaultComMsg;
	m_lParam   = lParam;

	// Start the listener thread
	lLastError = StartListener();
	if (lLastError != ERROR_SUCCESS)
	{
		// Close the serial port
		Close();

		// Return the error-code
		m_lLastError = lLastError;
		return m_lLastError;
	}

	// Return the error
	m_lLastError = ERROR_SUCCESS;
	return m_lLastError;
}

LONG CSerialWnd::Close (void)
{
	// Reset all members
	m_hwndDest   = 0;
	m_nComMsg    = WM_NULL;

	// Call the base class
	return CSerialEx::Close();
}

void CSerialWnd::OnEvent (EEvent eEvent, EError eError)
{
	// Post message to the client window
	::PostMessage(m_hwndDest,m_nComMsg,MAKEWPARAM(eEvent,eError),LPARAM(m_lParam));
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
N. Amer. Fl. (New York) 10(2): (1917)

#### Original name
Bolbitius gloiocyaneus G.F. Atk.

### Remarks
null


text:
export default {
  maxWidth: 1180,
  headerHeight: 58,

  // material ui themeing options
  // can also be used in styled components as well to keep things consistent.
  fontFamily: 'Open Sans, Helvetica Neue, Helvetica, Arial, sans-serif',
  palette: {
    textColor: '#656565',
  },
};


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.1.9-03/31/2009 04:14 PM(snajper)-fcs
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2009.05.19 at 10:15:07 AM CEST
//

package org.openehealth.ipf.commons.ihe.xds.core.stub.ebrs21.query;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for AuditableEventQueryType complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="AuditableEventQueryType">
 *   <complexContent>
 *     <extension base="{urn:oasis:names:tc:ebxml-regrep:query:xsd:2.1}RegistryObjectQueryType">
 *       <sequence>
 *         <element ref="{urn:oasis:names:tc:ebxml-regrep:query:xsd:2.1}AuditableEventFilter" minOccurs="0"/>
 *         <element ref="{urn:oasis:names:tc:ebxml-regrep:query:xsd:2.1}RegistryObjectQuery" minOccurs="0"/>
 *         <element ref="{urn:oasis:names:tc:ebxml-regrep:query:xsd:2.1}RegistryEntryQuery" minOccurs="0"/>
 *         <element ref="{urn:oasis:names:tc:ebxml-regrep:query:xsd:2.1}UserBranch" minOccurs="0"/>
 *       </sequence>
 *     </extension>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "AuditableEventQueryType", propOrder = {
    "auditableEventFilter",
    "registryObjectQuery",
    "registryEntryQuery",
    "userBranch"
})
public class AuditableEventQueryType
    extends RegistryObjectQueryType
{

    @XmlElement(name = "AuditableEventFilter")
    protected FilterType auditableEventFilter;
    @XmlElement(name = "RegistryObjectQuery")
    protected RegistryObjectQueryType registryObjectQuery;
    @XmlElement(name = "RegistryEntryQuery")
    protected RegistryEntryQueryType registryEntryQuery;
    @XmlElement(name = "UserBranch")
    protected UserBranch userBranch;

    /**
     * Gets the value of the auditableEventFilter property.
     *
     * @return
     *     possible object is
     *     {@link FilterType }
     *
     */
    public FilterType getAuditableEventFilter() {
        return auditableEventFilter;
    }

    /**
     * Sets the value of the auditableEventFilter property.
     *
     * @param value
     *     allowed object is
     *     {@link FilterType }
     *
     */
    public void setAuditableEventFilter(FilterType value) {
        this.auditableEventFilter = value;
    }

    /**
     * Gets the value of the registryObjectQuery property.
     *
     * @return
     *     possible object is
     *     {@link RegistryObjectQueryType }
     *
     */
    public RegistryObjectQueryType getRegistryObjectQuery() {
        return registryObjectQuery;
    }

    /**
     * Sets the value of the registryObjectQuery property.
     *
     * @param value
     *     allowed object is
     *     {@link RegistryObjectQueryType }
     *
     */
    public void setRegistryObjectQuery(RegistryObjectQueryType value) {
        this.registryObjectQuery = value;
    }

    /**
     * Gets the value of the registryEntryQuery property.
     *
     * @return
     *     possible object is
     *     {@link RegistryEntryQueryType }
     *
     */
    public RegistryEntryQueryType getRegistryEntryQuery() {
        return registryEntryQuery;
    }

    /**
     * Sets the value of the registryEntryQuery property.
     *
     * @param value
     *     allowed object is
     *     {@link RegistryEntryQueryType }
     *
     */
    public void setRegistryEntryQuery(RegistryEntryQueryType value) {
        this.registryEntryQuery = value;
    }

    /**
     * Gets the value of the userBranch property.
     *
     * @return
     *     possible object is
     *     {@link UserBranch }
     *
     */
    public UserBranch getUserBranch() {
        return userBranch;
    }

    /**
     * Sets the value of the userBranch property.
     *
     * @param value
     *     allowed object is
     *     {@link UserBranch }
     *
     */
    public void setUserBranch(UserBranch value) {
        this.userBranch = value;
    }

}


text:
/**
 * Given a template string to format and serveral strings
 * to fill the template, it returns the formatted string.
 * @param template This is a string containing zero, one or
 *                 more occurrences of "%s".
 * @param ...strings
 * @returns The formattted template.
 */
function format(subject) {
  'use strict';

  var
    replaces = Array.prototype.slice.apply(arguments, [1, arguments.length]),
    parts = null,
    output,
    i;

  if ((subject.match(/%s/g) === null && replaces.length > 0) || replaces.length !== subject.match(/%s/g).length) {
    throw 'Format error: The string count to replace do not matches the argument count. Subject: ' + subject + '. Replaces: ' + replaces;
  }

  output = subject;
  for (i = 1; i < arguments.length; i += 1) {
    parts = output.split('%s');
    output = parts[0] + arguments[i] + parts.slice(1, parts.length).join('%s');
  }

  return output;
}

module.exports = format;


text:
package com.github.albertocsm.example;

import java.util.Date;

import javax.persistence.*;

import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Table;

@Entity
@javax.persistence.Table(name = "ORDERS")
@Table(appliesTo = "ORDERS")
public class Order {

  // members
  @Id
  @GeneratedValue(generator = "increment")
  @GenericGenerator(name = "increment", strategy = "increment")
  @Column(name = "order_id")
  private long id;

  @Column(length = 300)
  private String order_info;

  @javax.persistence.Temporal(TemporalType.DATE)
  private Date order_date;

  @ManyToOne
  @JoinColumn(name = "customer_id", insertable = false, updatable = false)
  private Customer customer;

  //getter & setters
  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getOrderInfo() {
    return order_info;
  }

  public void setOrderInfo(String orderInfo) {
    this.order_info = orderInfo;
  }

  public Date getOrderDate() {
    return order_date;
  }

  public void setOrderDate(Date order_date) {
    this.order_date = order_date;
  }

  public Customer getCustomer() {
    return customer;
  }

  public void setCustomer(Customer customer) {
    this.customer = customer;
  }

  //public API
  public Order() {

  }
}


text:
using AzureFromTheTrenches.Commanding.Abstractions;

namespace AzureFromTheTrenches.Commanding.Implementation
{
    class DisabledCorrelationIdProvider : ICommandCorrelationIdProvider
    {
        public string Create()
        {
            return string.Empty;
        }
    }
}


text:
cask 'dwgsee' do
  version :latest
  sha256 :no_check

  url 'https://www.dwgsee.com/download/dwgseemac.dmg'
  name 'DWGSee'
  homepage 'https://dwgsee.com/'

  app 'DWGSee.app'
end


text:
``` diff
+namespace System.Web.Routing {
+    public class HttpMethodConstraint : IRouteConstraint {
+        public HttpMethodConstraint(params string[] allowedMethods);
+        public ICollection<string> AllowedMethods { get; private set; }
+        protected virtual bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection);
+        bool System.Web.Routing.IRouteConstraint.Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection);
+    }
+    public interface IRouteConstraint {
+        bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection);
+    }
+    public interface IRouteHandler {
+        IHttpHandler GetHttpHandler(RequestContext requestContext);
+    }
+    public class PageRouteHandler : IRouteHandler {
+        public PageRouteHandler(string virtualPath);
+        public PageRouteHandler(string virtualPath, bool checkPhysicalUrlAccess);
+        public bool CheckPhysicalUrlAccess { get; private set; }
+        public string VirtualPath { get; private set; }
+        public virtual IHttpHandler GetHttpHandler(RequestContext requestContext);
+        public string GetSubstitutedVirtualPath(RequestContext requestContext);
+    }
+    public class RequestContext {
+        public RequestContext();
+        public RequestContext(HttpContextBase httpContext, RouteData routeData);
+        public virtual HttpContextBase HttpContext { get; set; }
+        public virtual RouteData RouteData { get; set; }
+    }
+    public class Route : RouteBase {
+        public Route(string url, IRouteHandler routeHandler);
+        public Route(string url, RouteValueDictionary defaults, IRouteHandler routeHandler);
+        public Route(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, IRouteHandler routeHandler);
+        public Route(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler);
+        public RouteValueDictionary Constraints { get; set; }
+        public RouteValueDictionary DataTokens { get; set; }
+        public RouteValueDictionary Defaults { get; set; }
+        public IRouteHandler RouteHandler { get; set; }
+        public string Url { get; set; }
+        public override RouteData GetRouteData(HttpContextBase httpContext);
+        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values);
+        protected virtual bool ProcessConstraint(HttpContextBase httpContext, object constraint, string parameterName, RouteValueDictionary values, RouteDirection routeDirection);
+    }
+    public abstract class RouteBase {
+        protected RouteBase();
+        public bool RouteExistingFiles { get; set; }
+        public abstract RouteData GetRouteData(HttpContextBase httpContext);
+        public abstract VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values);
+    }
+    public class RouteCollection : Collection<RouteBase> {
+        public RouteCollection();
+        public RouteCollection(VirtualPathProvider virtualPathProvider);
+        public bool AppendTrailingSlash { get; set; }
+        public bool LowercaseUrls { get; set; }
+        public bool RouteExistingFiles { get; set; }
+        public RouteBase this[string name] { get; }
+        public void Add(string name, RouteBase item);
+        protected override void ClearItems();
+        public IDisposable GetReadLock();
+        public RouteData GetRouteData(HttpContextBase httpContext);
+        public VirtualPathData GetVirtualPath(RequestContext requestContext, string name, RouteValueDictionary values);
+        public VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values);
+        public IDisposable GetWriteLock();
+        public void Ignore(string url);
+        public void Ignore(string url, object constraints);
+        protected override void InsertItem(int index, RouteBase item);
+        public Route MapPageRoute(string routeName, string routeUrl, string physicalFile);
+        public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess);
+        public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess, RouteValueDictionary defaults);
+        public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess, RouteValueDictionary defaults, RouteValueDictionary constraints);
+        public Route MapPageRoute(string routeName, string routeUrl, string physicalFile, bool checkPhysicalUrlAccess, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens);
+        protected override void RemoveItem(int index);
+        protected override void SetItem(int index, RouteBase item);
+    }
+    public class RouteData {
+        public RouteData();
+        public RouteData(RouteBase route, IRouteHandler routeHandler);
+        public RouteValueDictionary DataTokens { get; }
+        public RouteBase Route { get; set; }
+        public IRouteHandler RouteHandler { get; set; }
+        public RouteValueDictionary Values { get; }
+        public string GetRequiredString(string valueName);
+    }
+    public enum RouteDirection {
+        IncomingRequest = 0,
+        UrlGeneration = 1,
+    }
+    public class RouteTable {
+        public RouteTable();
+        public static RouteCollection Routes { get; }
+    }
+    public class RouteValueDictionary : ICollection<KeyValuePair<string, object>>, IDictionary<string, object>, IEnumerable, IEnumerable<KeyValuePair<string, object>> {
+        public RouteValueDictionary();
+        public RouteValueDictionary(IDictionary<string, object> dictionary);
+        public RouteValueDictionary(object values);
+        public int Count { get; }
+        public Dictionary<string, object>.KeyCollection Keys { get; }
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.IsReadOnly { get; }
+        ICollection<string> System.Collections.Generic.IDictionary<System.String,System.Object>.Keys { get; }
+        ICollection<object> System.Collections.Generic.IDictionary<System.String,System.Object>.Values { get; }
+        public object this[string key] { get; set; }
+        public Dictionary<string, object>.ValueCollection Values { get; }
+        public void Add(string key, object value);
+        public void Clear();
+        public bool ContainsKey(string key);
+        public bool ContainsValue(object value);
+        public Dictionary<string, object>.Enumerator GetEnumerator();
+        public bool Remove(string key);
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.Add(KeyValuePair<string, object> item);
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.Contains(KeyValuePair<string, object> item);
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex);
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.Remove(KeyValuePair<string, object> item);
+        IEnumerator<KeyValuePair<string, object>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.String,System.Object>>.GetEnumerator();
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        public bool TryGetValue(string key, out object value);
+    }
+    public class StopRoutingHandler : IRouteHandler {
+        public StopRoutingHandler();
+        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext);
+        IHttpHandler System.Web.Routing.IRouteHandler.GetHttpHandler(RequestContext requestContext);
+    }
+    public abstract class UrlRoutingHandler : IHttpHandler {
+        protected UrlRoutingHandler();
+        protected virtual bool IsReusable { get; }
+        public RouteCollection RouteCollection { get; set; }
+        bool System.Web.IHttpHandler.IsReusable { get; }
+        protected virtual void ProcessRequest(HttpContext httpContext);
+        protected virtual void ProcessRequest(HttpContextBase httpContext);
+        void System.Web.IHttpHandler.ProcessRequest(HttpContext context);
+        protected abstract void VerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext);
+    }
+    public class UrlRoutingModule : IHttpModule {
+        public UrlRoutingModule();
+        public RouteCollection RouteCollection { get; set; }
+        protected virtual void Dispose();
+        protected virtual void Init(HttpApplication application);
+        public virtual void PostMapRequestHandler(HttpContextBase context);
+        public virtual void PostResolveRequestCache(HttpContextBase context);
+        void System.Web.IHttpModule.Dispose();
+        void System.Web.IHttpModule.Init(HttpApplication application);
+    }
+    public class VirtualPathData {
+        public VirtualPathData(RouteBase route, string virtualPath);
+        public RouteValueDictionary DataTokens { get; }
+        public RouteBase Route { get; set; }
+        public string VirtualPath { get; set; }
+    }
+}
```


text:
SparkJava MicroServices, Google Cloud, Heroku application for Khan Squash IO

## Deploy
```
mvn clean heroku:deploy-war
```
## Run locally
```
mvn jetty:run
```


text:
<CartClearResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2011-08-01">
  <OperationRequest>
    <HTTPHeaders>
      <Header Name="UserAgent" Value="Python-urllib/2.6"/>
    </HTTPHeaders>
    <RequestId>1ZY2YJM0PBA517CQREDV</RequestId>
    <Arguments>
      <Argument Name="AssociateTag" Value="XXXXXXXXXXXXXXX"/>
      <Argument Name="Service" Value="AWSECommerceService"/>
      <Argument Name="Signature" Value="XXXXXXXXXXXXXXX"/>
      <Argument Name="HMAC" Value="xw2pgBIJekEgmH3uA2taSjRi5Gc="/>
      <Argument Name="Operation" Value="CartClear"/>
      <Argument Name="CartId" Value="275-5902239-8661153"/>
      <Argument Name="AWSAccessKeyId" Value="XXXXXXXXXXXXXXX"/>
      <Argument Name="Timestamp" Value="2011-11-08T21:47:24Z"/>
      <Argument Name="Version" Value="2011-08-01"/>
    </Arguments>
    <RequestProcessingTime>0.0836029052734375</RequestProcessingTime>
  </OperationRequest>
  <Cart>
    <Request>
      <IsValid>True</IsValid>
      <CartClearRequest>
        <CartId>275-5902239-8661153</CartId>
        <HMAC>xw2pgBIJekEgmH3uA2taSjRi5Gc=</HMAC>
      </CartClearRequest>
    </Request>
    <CartId>275-5902239-8661153</CartId>
    <HMAC>xw2pgBIJekEgmH3uA2taSjRi5Gc=</HMAC>
    <URLEncodedHMAC>xw2pgBIJekEgmH3uA2taSjRi5Gc%3D</URLEncodedHMAC>
  </Cart>
</CartClearResponse>


text:
.class Landroid/widget/Editor$SelectionActionModeCallback;
.super Ljava/lang/Object;
.source "Editor.java"

# interfaces
.implements Landroid/view/ActionMode$Callback;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/widget/Editor;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x2
    name = "SelectionActionModeCallback"
.end annotation

# instance fields
.field final synthetic this$0:Landroid/widget/Editor;

# direct methods
.method private constructor <init>(Landroid/widget/Editor;)V
    .locals 0
    .parameter

    .prologue
    .line 2674
    iput-object p1, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    return-void
.end method

.method synthetic constructor <init>(Landroid/widget/Editor;Landroid/widget/Editor$1;)V
    .locals 0
    .parameter "x0"
    .parameter "x1"

    .prologue
    .line 2674
    invoke-direct {p0, p1}, Landroid/widget/Editor$SelectionActionModeCallback;-><init>(Landroid/widget/Editor;)V

    return-void
.end method

# virtual methods
.method public onActionItemClicked(Landroid/view/ActionMode;Landroid/view/MenuItem;)Z
    .locals 2
    .parameter "mode"
    .parameter "item"

    .prologue
    .line 2757
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    if-eqz v0, :cond_0

    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    invoke-interface {v0, p1, p2}, Landroid/view/ActionMode$Callback;->onActionItemClicked(Landroid/view/ActionMode;Landroid/view/MenuItem;)Z

    move-result v0

    if-eqz v0, :cond_0

    .line 2759
    const/4 v0, 0x1

    .line 2761
    :goto_0
    return v0

    :cond_0
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v0}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v0

    invoke-interface {p2}, Landroid/view/MenuItem;->getItemId()I

    move-result v1

    invoke-virtual {v0, v1}, Landroid/widget/TextView;->onTextContextMenuItem(I)Z

    move-result v0

    goto :goto_0
.end method

.method public onCreateActionMode(Landroid/view/ActionMode;Landroid/view/Menu;)Z
    .locals 8
    .parameter "mode"
    .parameter "menu"

    .prologue
    const/4 v7, 0x6

    const/4 v4, 0x1

    const/4 v3, 0x0

    .line 2678
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v5}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v5

    invoke-virtual {v5}, Landroid/widget/TextView;->getContext()Landroid/content/Context;

    move-result-object v5

    sget-object v6, Lcom/android/internal/R$styleable;->SelectionModeDrawables:[I

    invoke-virtual {v5, v6}, Landroid/content/Context;->obtainStyledAttributes([I)Landroid/content/res/TypedArray;

    move-result-object v2

    .line 2681
    .local v2, styledAttributes:Landroid/content/res/TypedArray;
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v5}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v5

    invoke-virtual {v5}, Landroid/widget/TextView;->getContext()Landroid/content/Context;

    move-result-object v5

    invoke-virtual {v5}, Landroid/content/Context;->getResources()Landroid/content/res/Resources;

    move-result-object v5

    const v6, 0x1110036

    invoke-virtual {v5, v6}, Landroid/content/res/Resources;->getBoolean(I)Z

    move-result v0

    .line 2684
    .local v0, allowText:Z
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v5}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v5

    invoke-virtual {v5}, Landroid/widget/TextView;->getContext()Landroid/content/Context;

    move-result-object v5

    const v6, 0x10403c0

    invoke-virtual {v5, v6}, Landroid/content/Context;->getString(I)Ljava/lang/String;

    move-result-object v5

    invoke-virtual {p1, v5}, Landroid/view/ActionMode;->setTitle(Ljava/lang/CharSequence;)V

    .line 2686
    const/4 v5, 0x0

    invoke-virtual {p1, v5}, Landroid/view/ActionMode;->setSubtitle(Ljava/lang/CharSequence;)V

    .line 2687
    invoke-virtual {p1, v4}, Landroid/view/ActionMode;->setTitleOptionalHint(Z)V

    .line 2689
    const/4 v1, 0x0

    .line 2690
    .local v1, selectAllIconId:I
    if-nez v0, :cond_0

    .line 2692
    const/4 v5, 0x3

    invoke-virtual {v2, v5, v3}, Landroid/content/res/TypedArray;->getResourceId(II)I

    move-result v1

    .line 2696
    :cond_0
    const v5, 0x102001f

    const v6, 0x104000d

    invoke-interface {p2, v3, v5, v3, v6}, Landroid/view/Menu;->add(IIII)Landroid/view/MenuItem;

    move-result-object v5

    invoke-interface {v5, v1}, Landroid/view/MenuItem;->setIcon(I)Landroid/view/MenuItem;

    move-result-object v5

    const/16 v6, 0x61

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setAlphabeticShortcut(C)Landroid/view/MenuItem;

    move-result-object v5

    invoke-interface {v5, v7}, Landroid/view/MenuItem;->setShowAsAction(I)V

    .line 2702
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v5}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v5

    invoke-virtual {v5}, Landroid/widget/TextView;->canCut()Z

    move-result v5

    if-eqz v5, :cond_1

    .line 2703
    const v5, 0x1020020

    const v6, 0x1040003

    invoke-interface {p2, v3, v5, v3, v6}, Landroid/view/Menu;->add(IIII)Landroid/view/MenuItem;

    move-result-object v5

    invoke-virtual {v2, v3, v3}, Landroid/content/res/TypedArray;->getResourceId(II)I

    move-result v6

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setIcon(I)Landroid/view/MenuItem;

    move-result-object v5

    const/16 v6, 0x78

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setAlphabeticShortcut(C)Landroid/view/MenuItem;

    move-result-object v5

    invoke-interface {v5, v7}, Landroid/view/MenuItem;->setShowAsAction(I)V

    .line 2711
    :cond_1
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v5}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v5

    invoke-virtual {v5}, Landroid/widget/TextView;->canCopy()Z

    move-result v5

    if-eqz v5, :cond_2

    .line 2712
    const v5, 0x1020021

    const v6, 0x1040001

    invoke-interface {p2, v3, v5, v3, v6}, Landroid/view/Menu;->add(IIII)Landroid/view/MenuItem;

    move-result-object v5

    invoke-virtual {v2, v4, v3}, Landroid/content/res/TypedArray;->getResourceId(II)I

    move-result v6

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setIcon(I)Landroid/view/MenuItem;

    move-result-object v5

    const/16 v6, 0x63

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setAlphabeticShortcut(C)Landroid/view/MenuItem;

    move-result-object v5

    invoke-interface {v5, v7}, Landroid/view/MenuItem;->setShowAsAction(I)V

    .line 2720
    :cond_2
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v5}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v5

    invoke-virtual {v5}, Landroid/widget/TextView;->canPaste()Z

    move-result v5

    if-eqz v5, :cond_3

    .line 2721
    const v5, 0x1020022

    const v6, 0x104000b

    invoke-interface {p2, v3, v5, v3, v6}, Landroid/view/Menu;->add(IIII)Landroid/view/MenuItem;

    move-result-object v5

    const/4 v6, 0x2

    invoke-virtual {v2, v6, v3}, Landroid/content/res/TypedArray;->getResourceId(II)I

    move-result v6

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setIcon(I)Landroid/view/MenuItem;

    move-result-object v5

    const/16 v6, 0x76

    invoke-interface {v5, v6}, Landroid/view/MenuItem;->setAlphabeticShortcut(C)Landroid/view/MenuItem;

    move-result-object v5

    invoke-interface {v5, v7}, Landroid/view/MenuItem;->setShowAsAction(I)V

    .line 2729
    :cond_3
    invoke-virtual {v2}, Landroid/content/res/TypedArray;->recycle()V

    .line 2731
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v5, v5, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    if-eqz v5, :cond_5

    .line 2732
    iget-object v5, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v5, v5, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    invoke-interface {v5, p1, p2}, Landroid/view/ActionMode$Callback;->onCreateActionMode(Landroid/view/ActionMode;Landroid/view/Menu;)Z

    move-result v5

    if-nez v5, :cond_5

    .line 2743
    :cond_4
    :goto_0
    return v3

    .line 2738
    :cond_5
    invoke-interface {p2}, Landroid/view/Menu;->hasVisibleItems()Z

    move-result v5

    if-nez v5, :cond_6

    invoke-virtual {p1}, Landroid/view/ActionMode;->getCustomView()Landroid/view/View;

    move-result-object v5

    if-eqz v5, :cond_4

    .line 2739
    :cond_6
    iget-object v3, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    invoke-virtual {v3}, Landroid/widget/Editor;->getSelectionController()Landroid/widget/Editor$SelectionModifierCursorController;

    move-result-object v3

    invoke-virtual {v3}, Landroid/widget/Editor$SelectionModifierCursorController;->show()V

    .line 2740
    iget-object v3, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v3}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v3

    invoke-virtual {v3, v4}, Landroid/widget/TextView;->setHasTransientState(Z)V

    move v3, v4

    .line 2741
    goto :goto_0
.end method

.method public onDestroyActionMode(Landroid/view/ActionMode;)V
    .locals 2
    .parameter "mode"

    .prologue
    .line 2766
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    if-eqz v0, :cond_0

    .line 2767
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    invoke-interface {v0, p1}, Landroid/view/ActionMode$Callback;->onDestroyActionMode(Landroid/view/ActionMode;)V

    .line 2775
    :cond_0
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-boolean v0, v0, Landroid/widget/Editor;->mPreserveDetachedSelection:Z

    if-nez v0, :cond_1

    .line 2776
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v0}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v0

    invoke-virtual {v0}, Landroid/widget/TextView;->getText()Ljava/lang/CharSequence;

    move-result-object v0

    check-cast v0, Landroid/text/Spannable;

    iget-object v1, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v1}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v1

    invoke-virtual {v1}, Landroid/widget/TextView;->getSelectionEnd()I

    move-result v1

    invoke-static {v0, v1}, Landroid/text/Selection;->setSelection(Landroid/text/Spannable;I)V

    .line 2778
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    #getter for: Landroid/widget/Editor;->mTextView:Landroid/widget/TextView;
    invoke-static {v0}, Landroid/widget/Editor;->access$600(Landroid/widget/Editor;)Landroid/widget/TextView;

    move-result-object v0

    const/4 v1, 0x0

    invoke-virtual {v0, v1}, Landroid/widget/TextView;->setHasTransientState(Z)V

    .line 2781
    :cond_1
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mSelectionModifierCursorController:Landroid/widget/Editor$SelectionModifierCursorController;

    if-eqz v0, :cond_2

    .line 2782
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mSelectionModifierCursorController:Landroid/widget/Editor$SelectionModifierCursorController;

    invoke-virtual {v0}, Landroid/widget/Editor$SelectionModifierCursorController;->hide()V

    .line 2785
    :cond_2
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    const/4 v1, 0x0

    iput-object v1, v0, Landroid/widget/Editor;->mSelectionActionMode:Landroid/view/ActionMode;

    .line 2786
    return-void
.end method

.method public onPrepareActionMode(Landroid/view/ActionMode;Landroid/view/Menu;)Z
    .locals 1
    .parameter "mode"
    .parameter "menu"

    .prologue
    .line 2749
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    if-eqz v0, :cond_0

    .line 2750
    iget-object v0, p0, Landroid/widget/Editor$SelectionActionModeCallback;->this$0:Landroid/widget/Editor;

    iget-object v0, v0, Landroid/widget/Editor;->mCustomSelectionActionModeCallback:Landroid/view/ActionMode$Callback;

    invoke-interface {v0, p1, p2}, Landroid/view/ActionMode$Callback;->onPrepareActionMode(Landroid/view/ActionMode;Landroid/view/Menu;)Z

    move-result v0

    .line 2752
    :goto_0
    return v0

    :cond_0
    const/4 v0, 0x1

    goto :goto_0
.end method


text:
package bot.simulation.collision;

import bot.simulation.objects.Movable;
import bot.simulation.objects.Point;

public class MovablePointCollision extends _SafeStr_220 {
    private Point _SafeStr_1747;

    public MovablePointCollision(Movable _arg_1, Point _arg_2, double _arg_3, double _arg_4) {
        super(_arg_1, _arg_3, _arg_4);
        this._SafeStr_1747 = _arg_2;
    }

    public Point _SafeStr_1158() {
        return (this._SafeStr_1747);
    }
}


text:
package client

import (
	"fmt"
	"net/url"
	"strings"

	"github.com/hyperhq/hyper/engine"
	"github.com/hyperhq/runv/hypervisor/types"

	gflag "github.com/jessevdk/go-flags"
)

func (cli *HyperClient) HyperCmdKill(args ...string) error {
	var parser = gflag.NewParser(nil, gflag.Default)
	parser.Usage = "kill VM_ID\n\nTerminate a VM instance"
	args, err := parser.ParseArgs(args)
	if err != nil {
		if !strings.Contains(err.Error(), "Usage") {
			return err
		} else {
			return nil
		}
	}
	if len(args) == 0 {
		return fmt.Errorf("\"kill\" requires a minimum of 1 argument, please provide VM ID.\n")
	}

	vmId := args[0]
	v := url.Values{}
	v.Set("vm", vmId)
	body, _, err := readBody(cli.call("DELETE", "/vm?"+v.Encode(), nil, nil))
	if err != nil {
		return err
	}
	out := engine.NewOutput()
	remoteInfo, err := out.AddEnv()
	if err != nil {
		return err
	}

	if _, err := out.Write(body); err != nil {
		fmt.Printf("Error reading remote info: %s", err)
		return err
	}
	out.Close()
	if remoteInfo.GetInt("Code") != types.E_VM_SHUTDOWN {
		fmt.Fprintf(cli.err, "VM(%s) is failed to shutdown, %s\n", remoteInfo.Get("ID"), remoteInfo.Get("Cause"))
	}

	return nil
}