text:
package com.google.dataflow.v1beta3;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 *
 *
 *

 * Provides methods to manage snapshots of Google Cloud Dataflow jobs.
 *

 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler",
    comments = "Source: google/dataflow/v1beta3/snapshots.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class SnapshotsV1Beta3Grpc {

  private SnapshotsV1Beta3Grpc() {}

  public static final String SERVICE_NAME = "google.dataflow.v1beta3.SnapshotsV1Beta3";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<
          com.google.dataflow.v1beta3.GetSnapshotRequest, com.google.dataflow.v1beta3.Snapshot>
      getGetSnapshotMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetSnapshot",
      requestType = com.google.dataflow.v1beta3.GetSnapshotRequest.class,
      responseType = com.google.dataflow.v1beta3.Snapshot.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<
          com.google.dataflow.v1beta3.GetSnapshotRequest, com.google.dataflow.v1beta3.Snapshot>
      getGetSnapshotMethod() {
    io.grpc.MethodDescriptor<
            com.google.dataflow.v1beta3.GetSnapshotRequest, com.google.dataflow.v1beta3.Snapshot>
        getGetSnapshotMethod;
    if ((getGetSnapshotMethod = SnapshotsV1Beta3Grpc.getGetSnapshotMethod) == null) {
      synchronized (SnapshotsV1Beta3Grpc.class) {
        if ((getGetSnapshotMethod = SnapshotsV1Beta3Grpc.getGetSnapshotMethod) == null) {
          SnapshotsV1Beta3Grpc.getGetSnapshotMethod =
              getGetSnapshotMethod =
                  io.grpc.MethodDescriptor
                      .<com.google.dataflow.v1beta3.GetSnapshotRequest,
                          com.google.dataflow.v1beta3.Snapshot>
                          newBuilder()
                      .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
                      .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSnapshot"))
                      .setSampledToLocalTracing(true)
                      .setRequestMarshaller(
                          io.grpc.protobuf.ProtoUtils.marshaller(
                              com.google.dataflow.v1beta3.GetSnapshotRequest.getDefaultInstance()))
                      .setResponseMarshaller(
                          io.grpc.protobuf.ProtoUtils.marshaller(
                              com.google.dataflow.v1beta3.Snapshot.getDefaultInstance()))
                      .setSchemaDescriptor(
                          new SnapshotsV1Beta3MethodDescriptorSupplier("GetSnapshot"))
                      .build();
        }
      }
    }
    return getGetSnapshotMethod;
  }

  private static volatile io.grpc.MethodDescriptor<
          com.google.dataflow.v1beta3.DeleteSnapshotRequest,
          com.google.dataflow.v1beta3.DeleteSnapshotResponse>
      getDeleteSnapshotMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "DeleteSnapshot",
      requestType = com.google.dataflow.v1beta3.DeleteSnapshotRequest.class,
      responseType = com.google.dataflow.v1beta3.DeleteSnapshotResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<
          com.google.dataflow.v1beta3.DeleteSnapshotRequest,
          com.google.dataflow.v1beta3.DeleteSnapshotResponse>
      getDeleteSnapshotMethod() {
    io.grpc.MethodDescriptor<
            com.google.dataflow.v1beta3.DeleteSnapshotRequest,
            com.google.dataflow.v1beta3.DeleteSnapshotResponse>
        getDeleteSnapshotMethod;
    if ((getDeleteSnapshotMethod = SnapshotsV1Beta3Grpc.getDeleteSnapshotMethod) == null) {
      synchronized (SnapshotsV1Beta3Grpc.class) {
        if ((getDeleteSnapshotMethod = SnapshotsV1Beta3Grpc.getDeleteSnapshotMethod) == null) {
          SnapshotsV1Beta3Grpc.getDeleteSnapshotMethod =
              getDeleteSnapshotMethod =
                  io.grpc.MethodDescriptor
                      .<com.google.dataflow.v1beta3.DeleteSnapshotRequest,
                          com.google.dataflow.v1beta3.DeleteSnapshotResponse>
                          newBuilder()
                      .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
                      .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteSnapshot"))
                      .setSampledToLocalTracing(true)
                      .setRequestMarshaller(
                          io.grpc.protobuf.ProtoUtils.marshaller(
                              com.google.dataflow.v1beta3.DeleteSnapshotRequest
                                  .getDefaultInstance()))
                      .setResponseMarshaller(
                          io.grpc.protobuf.ProtoUtils.marshaller(
                              com.google.dataflow.v1beta3.DeleteSnapshotResponse
                                  .getDefaultInstance()))
                      .setSchemaDescriptor(
                          new SnapshotsV1Beta3MethodDescriptorSupplier("DeleteSnapshot"))
                      .build();
        }
      }
    }
    return getDeleteSnapshotMethod;
  }

  private static volatile io.grpc.MethodDescriptor<
          com.google.dataflow.v1beta3.ListSnapshotsRequest,
          com.google.dataflow.v1beta3.ListSnapshotsResponse>
      getListSnapshotsMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ListSnapshots",
      requestType = com.google.dataflow.v1beta3.ListSnapshotsRequest.class,
      responseType = com.google.dataflow.v1beta3.ListSnapshotsResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<
          com.google.dataflow.v1beta3.ListSnapshotsRequest,
          com.google.dataflow.v1beta3.ListSnapshotsResponse>
      getListSnapshotsMethod() {
    io.grpc.MethodDescriptor<
            com.google.dataflow.v1beta3.ListSnapshotsRequest,
            com.google.dataflow.v1beta3.ListSnapshotsResponse>
        getListSnapshotsMethod;
    if ((getListSnapshotsMethod = SnapshotsV1Beta3Grpc.getListSnapshotsMethod) == null) {
      synchronized (SnapshotsV1Beta3Grpc.class) {
        if ((getListSnapshotsMethod = SnapshotsV1Beta3Grpc.getListSnapshotsMethod) == null) {
          SnapshotsV1Beta3Grpc.getListSnapshotsMethod =
              getListSnapshotsMethod =
                  io.grpc.MethodDescriptor
                      .<com.google.dataflow.v1beta3.ListSnapshotsRequest,
                          com.google.dataflow.v1beta3.ListSnapshotsResponse>
                          newBuilder()
                      .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
                      .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListSnapshots"))
                      .setSampledToLocalTracing(true)
                      .setRequestMarshaller(
                          io.grpc.protobuf.ProtoUtils.marshaller(
                              com.google.dataflow.v1beta3.ListSnapshotsRequest
                                  .getDefaultInstance()))
                      .setResponseMarshaller(
                          io.grpc.protobuf.ProtoUtils.marshaller(
                              com.google.dataflow.v1beta3.ListSnapshotsResponse
                                  .getDefaultInstance()))
                      .setSchemaDescriptor(
                          new SnapshotsV1Beta3MethodDescriptorSupplier("ListSnapshots"))
                      .build();
        }
      }
    }
    return getListSnapshotsMethod;
  }

  /** Creates a new async stub that supports all call types for the service */
  public static SnapshotsV1Beta3Stub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<SnapshotsV1Beta3Stub> factory =
        new io.grpc.stub.AbstractStub.StubFactory<SnapshotsV1Beta3Stub>() {
          @java.lang.Override
          public SnapshotsV1Beta3Stub newStub(
              io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new SnapshotsV1Beta3Stub(channel, callOptions);
          }
        };
    return SnapshotsV1Beta3Stub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static SnapshotsV1Beta3BlockingStub newBlockingStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<SnapshotsV1Beta3BlockingStub> factory =
        new io.grpc.stub.AbstractStub.StubFactory<SnapshotsV1Beta3BlockingStub>() {
          @java.lang.Override
          public SnapshotsV1Beta3BlockingStub newStub(
              io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new SnapshotsV1Beta3BlockingStub(channel, callOptions);
          }
        };
    return SnapshotsV1Beta3BlockingStub.newStub(factory, channel);
  }

  /** Creates a new ListenableFuture-style stub that supports unary calls on the service */
  public static SnapshotsV1Beta3FutureStub newFutureStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<SnapshotsV1Beta3FutureStub> factory =
        new io.grpc.stub.AbstractStub.StubFactory<SnapshotsV1Beta3FutureStub>() {
          @java.lang.Override
          public SnapshotsV1Beta3FutureStub newStub(
              io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
            return new SnapshotsV1Beta3FutureStub(channel, callOptions);
          }
        };
    return SnapshotsV1Beta3FutureStub.newStub(factory, channel);
  }

  /**
   *
   *
   *

   * Provides methods to manage snapshots of Google Cloud Dataflow jobs.
   *

   */
  public abstract static class SnapshotsV1Beta3ImplBase implements io.grpc.BindableService {

    /**
     *
     *
     *

     * Gets information about a snapshot.
     *

     */
    public void getSnapshot(
        com.google.dataflow.v1beta3.GetSnapshotRequest request,
        io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.Snapshot> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(
          getGetSnapshotMethod(), responseObserver);
    }

    /**
     *
     *
     *

     * Deletes a snapshot.
     *

     */
    public void deleteSnapshot(
        com.google.dataflow.v1beta3.DeleteSnapshotRequest request,
        io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.DeleteSnapshotResponse>
            responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(
          getDeleteSnapshotMethod(), responseObserver);
    }

    /**
     *
     *
     *

     * Lists snapshots.
     *

     */
    public void listSnapshots(
        com.google.dataflow.v1beta3.ListSnapshotsRequest request,
        io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.ListSnapshotsResponse>
            responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(
          getListSnapshotsMethod(), responseObserver);
    }

    @java.lang.Override
    public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
              getGetSnapshotMethod(),
              io.grpc.stub.ServerCalls.asyncUnaryCall(
                  new MethodHandlers<
                      com.google.dataflow.v1beta3.GetSnapshotRequest,
                      com.google.dataflow.v1beta3.Snapshot>(this, METHODID_GET_SNAPSHOT)))
          .addMethod(
              getDeleteSnapshotMethod(),
              io.grpc.stub.ServerCalls.asyncUnaryCall(
                  new MethodHandlers<
                      com.google.dataflow.v1beta3.DeleteSnapshotRequest,
                      com.google.dataflow.v1beta3.DeleteSnapshotResponse>(
                      this, METHODID_DELETE_SNAPSHOT)))
          .addMethod(
              getListSnapshotsMethod(),
              io.grpc.stub.ServerCalls.asyncUnaryCall(
                  new MethodHandlers<
                      com.google.dataflow.v1beta3.ListSnapshotsRequest,
                      com.google.dataflow.v1beta3.ListSnapshotsResponse>(
                      this, METHODID_LIST_SNAPSHOTS)))
          .build();
    }
  }

  /**
   *
   *
   *

   * Provides methods to manage snapshots of Google Cloud Dataflow jobs.
   *

   */
  public static final class SnapshotsV1Beta3Stub
      extends io.grpc.stub.AbstractAsyncStub<SnapshotsV1Beta3Stub> {
    private SnapshotsV1Beta3Stub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected SnapshotsV1Beta3Stub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new SnapshotsV1Beta3Stub(channel, callOptions);
    }

    /**
     *
     *
     *

     * Gets information about a snapshot.
     *

     */
    public void getSnapshot(
        com.google.dataflow.v1beta3.GetSnapshotRequest request,
        io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.Snapshot> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetSnapshotMethod(), getCallOptions()),
          request,
          responseObserver);
    }

    /**
     *
     *
     *

     * Deletes a snapshot.
     *

     */
    public void deleteSnapshot(
        com.google.dataflow.v1beta3.DeleteSnapshotRequest request,
        io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.DeleteSnapshotResponse>
            responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getDeleteSnapshotMethod(), getCallOptions()),
          request,
          responseObserver);
    }

    /**
     *
     *
     *

     * Lists snapshots.
     *

     */
    public void listSnapshots(
        com.google.dataflow.v1beta3.ListSnapshotsRequest request,
        io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.ListSnapshotsResponse>
            responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getListSnapshotsMethod(), getCallOptions()),
          request,
          responseObserver);
    }
  }

  /**
   *
   *
   *

   * Provides methods to manage snapshots of Google Cloud Dataflow jobs.
   *

   */
  public static final class SnapshotsV1Beta3BlockingStub
      extends io.grpc.stub.AbstractBlockingStub<SnapshotsV1Beta3BlockingStub> {
    private SnapshotsV1Beta3BlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected SnapshotsV1Beta3BlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new SnapshotsV1Beta3BlockingStub(channel, callOptions);
    }

    /**
     *
     *
     *

     * Gets information about a snapshot.
     *

     */
    public com.google.dataflow.v1beta3.Snapshot getSnapshot(
        com.google.dataflow.v1beta3.GetSnapshotRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetSnapshotMethod(), getCallOptions(), request);
    }

    /**
     *
     *
     *

     * Deletes a snapshot.
     *

     */
    public com.google.dataflow.v1beta3.DeleteSnapshotResponse deleteSnapshot(
        com.google.dataflow.v1beta3.DeleteSnapshotRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getDeleteSnapshotMethod(), getCallOptions(), request);
    }

    /**
     *
     *
     *

     * Lists snapshots.
     *

     */
    public com.google.dataflow.v1beta3.ListSnapshotsResponse listSnapshots(
        com.google.dataflow.v1beta3.ListSnapshotsRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getListSnapshotsMethod(), getCallOptions(), request);
    }
  }

  /**
   *
   *
   *

   * Provides methods to manage snapshots of Google Cloud Dataflow jobs.
   *

   */
  public static final class SnapshotsV1Beta3FutureStub
      extends io.grpc.stub.AbstractFutureStub<SnapshotsV1Beta3FutureStub> {
    private SnapshotsV1Beta3FutureStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected SnapshotsV1Beta3FutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new SnapshotsV1Beta3FutureStub(channel, callOptions);
    }

    /**
     *
     *
     *

     * Gets information about a snapshot.
     *

     */
    public com.google.common.util.concurrent.ListenableFuture<com.google.dataflow.v1beta3.Snapshot>
        getSnapshot(com.google.dataflow.v1beta3.GetSnapshotRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetSnapshotMethod(), getCallOptions()), request);
    }

    /**
     *
     *
     *

     * Deletes a snapshot.
     *

     */
    public com.google.common.util.concurrent.ListenableFuture<
            com.google.dataflow.v1beta3.DeleteSnapshotResponse>
        deleteSnapshot(com.google.dataflow.v1beta3.DeleteSnapshotRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getDeleteSnapshotMethod(), getCallOptions()), request);
    }

    /**
     *
     *
     *

     * Lists snapshots.
     *

     */
    public com.google.common.util.concurrent.ListenableFuture<
            com.google.dataflow.v1beta3.ListSnapshotsResponse>
        listSnapshots(com.google.dataflow.v1beta3.ListSnapshotsRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getListSnapshotsMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_GET_SNAPSHOT = 0;
  private static final int METHODID_DELETE_SNAPSHOT = 1;
  private static final int METHODID_LIST_SNAPSHOTS = 2;

  private static final class MethodHandlers<Req, Resp>
      implements io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
          io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
          io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
          io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final SnapshotsV1Beta3ImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(SnapshotsV1Beta3ImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_GET_SNAPSHOT:
          serviceImpl.getSnapshot(
              (com.google.dataflow.v1beta3.GetSnapshotRequest) request,
              (io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.Snapshot>) responseObserver);
          break;
        case METHODID_DELETE_SNAPSHOT:
          serviceImpl.deleteSnapshot(
              (com.google.dataflow.v1beta3.DeleteSnapshotRequest) request,
              (io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.DeleteSnapshotResponse>)
                  responseObserver);
          break;
        case METHODID_LIST_SNAPSHOTS:
          serviceImpl.listSnapshots(
              (com.google.dataflow.v1beta3.ListSnapshotsRequest) request,
              (io.grpc.stub.StreamObserver<com.google.dataflow.v1beta3.ListSnapshotsResponse>)
                  responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private abstract static class SnapshotsV1Beta3BaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier,
          io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    SnapshotsV1Beta3BaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.google.dataflow.v1beta3.SnapshotsProto.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("SnapshotsV1Beta3");
    }
  }

  private static final class SnapshotsV1Beta3FileDescriptorSupplier
      extends SnapshotsV1Beta3BaseDescriptorSupplier {
    SnapshotsV1Beta3FileDescriptorSupplier() {}
  }

  private static final class SnapshotsV1Beta3MethodDescriptorSupplier
      extends SnapshotsV1Beta3BaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    SnapshotsV1Beta3MethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (SnapshotsV1Beta3Grpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor =
              result =
                  io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
                      .setSchemaDescriptor(new SnapshotsV1Beta3FileDescriptorSupplier())
                      .addMethod(getGetSnapshotMethod())
                      .addMethod(getDeleteSnapshotMethod())
                      .addMethod(getListSnapshotsMethod())
                      .build();
        }
      }
    }
    return result;
  }
}


text:
MASON_NAME=gdal
MASON_VERSION=1.11.1-big-pants
MASON_LIB_FILE=lib/libgdal.a

. ${MASON_DIR}/mason.sh

function mason_load_source {
    GIT_HASH=54cf139
    mason_download \
        https://github.com/springmeyer/gdal/tarball/${GIT_HASH} \
        fb0057ed8cdfccdfeca0e7ead9b38cdb0188c8e9

    mason_extract_tar_gz

    export MASON_BUILD_PATH=${MASON_ROOT}/.build/springmeyer-gdal-${GIT_HASH}
}

function mason_prepare_compile {
    cd $(dirname ${MASON_ROOT})
    # set up to fix libtool .la files
    # https://github.com/mapbox/mason/issues/61
    if [[ $(uname -s) == 'Darwin' ]]; then
        FIND="\/Users\/travis\/build\/mapbox\/mason"
    else
        FIND="\/home\/travis\/build\/mapbox\/mason"
    fi
    REPLACE="$(pwd)"
    REPLACE=${REPLACE////\\/}
    ${MASON_DIR}/mason install libtiff 4.0.4beta
    MASON_TIFF=$(${MASON_DIR}/mason prefix libtiff 4.0.4beta)
    perl -i -p -e "s/${FIND}/${REPLACE}/g;" ${MASON_TIFF}/lib/libtiff.la
    ${MASON_DIR}/mason install proj 4.8.0
    MASON_PROJ=$(${MASON_DIR}/mason prefix proj 4.8.0)
    perl -i -p -e "s/${FIND}/${REPLACE}/g;" ${MASON_PROJ}/lib/libproj.la
    ${MASON_DIR}/mason install jpeg_turbo 1.4.0
    MASON_JPEG=$(${MASON_DIR}/mason prefix jpeg_turbo 1.4.0)
    perl -i -p -e "s/${FIND}/${REPLACE}/g;" ${MASON_JPEG}/lib/libjpeg.la
    ${MASON_DIR}/mason install libpng 1.6.16
    MASON_PNG=$(${MASON_DIR}/mason prefix libpng 1.6.16)
    perl -i -p -e "s/${FIND}/${REPLACE}/g;" ${MASON_PNG}/lib/libpng.la
    ${MASON_DIR}/mason install expat 2.1.0
    MASON_EXPAT=$(${MASON_DIR}/mason prefix expat 2.1.0)
    perl -i -p -e "s/${FIND}/${REPLACE}/g;" ${MASON_EXPAT}/lib/libexpat.la
    ${MASON_DIR}/mason install libpq 9.4.0
    MASON_LIBPQ=$(${MASON_DIR}/mason prefix libpq 9.4.0)
    # depends on sudo apt-get install zlib1g-dev
    ${MASON_DIR}/mason install zlib system
    MASON_ZLIB=$(${MASON_DIR}/mason prefix zlib system)
    # depends on sudo apt-get install libc6-dev
    #${MASON_DIR}/mason install iconv system
    #MASON_ICONV=$(${MASON_DIR}/mason prefix iconv system)
    export LIBRARY_PATH=${MASON_LIBPQ}/lib:$LIBRARY_PATH
}

function mason_compile {
    cd gdal/
    CUSTOM_LIBS="-L${MASON_TIFF}/lib -ltiff -L${MASON_JPEG}/lib -ljpeg -L${MASON_PROJ}/lib -lproj -L${MASON_PNG}/lib -lpng -L${MASON_EXPAT}/lib -lexpat"
    CUSTOM_CFLAGS="${CFLAGS} -I${MASON_LIBPQ}/include -I${MASON_TIFF}/include -I${MASON_JPEG}/include -I${MASON_PROJ}/include -I${MASON_PNG}/include -I${MASON_EXPAT}/include"

    # very custom handling for libpq/postgres support
    # forcing our portable static library to be used
    MASON_LIBPQ_PATH=${MASON_LIBPQ}/lib/libpq.a
    if [[ $(uname -s) == 'Linux' ]]; then
        # on Linux passing -Wl will lead to libtool re-positioning libpq.a in the wrong place (no longer after libgdal.a)
        # which leads to unresolved symbols
        CUSTOM_LDFLAGS="${LDFLAGS} ${MASON_LIBPQ_PATH}"
    else
        # on OSX not passing -Wl will break libtool archive creation leading to confusing arch errors
        CUSTOM_LDFLAGS="${LDFLAGS} -Wl,${MASON_LIBPQ_PATH}"
    fi
    # we have to remove -lpq otherwise it will trigger linking to system /usr/lib/libpq
    perl -i -p -e "s/\-lpq //g;" configure
    # on linux -Wl,/path/to/libpq.a still does not work for the configure test
    # so we have to force it into LIBS. But we don't do this on OS X since it breaks libtool archive logic
    if [[ $(uname -s) == 'Linux' ]]; then
        CUSTOM_LIBS="${MASON_LIBPQ}/lib/libpq.a -pthread ${CUSTOM_LIBS}"
    fi

    # note: we put ${STDLIB_CXXFLAGS} into CXX instead of LDFLAGS due to libtool oddity:
    # http://stackoverflow.com/questions/16248360/autotools-libtool-link-library-with-libstdc-despite-stdlib-libc-option-pass
    if [[ $(uname -s) == 'Darwin' ]]; then
        CXX="${CXX} -stdlib=libc++ -std=c++11"
    fi

    # note: it might be tempting to build with --without-libtool
    # but I find that will only lead to a shared libgdal.so and will
    # not produce a static library even if --enable-static is passed
    LIBS="${CUSTOM_LIBS}" LDFLAGS="${CUSTOM_LDFLAGS}" CFLAGS="${CUSTOM_CFLAGS}" ./configure \
        --enable-static --disable-shared \
        ${MASON_HOST_ARG} \
        --prefix=${MASON_PREFIX} \
        --with-libz=${MASON_ZLIB} \
        --disable-rpath \
        --with-libjson-c=internal \
        --with-geotiff=internal \
        --with-expat=${MASON_EXPAT} \
        --with-threads=yes \
        --with-fgdb=no \
        --with-rename-internal-libtiff-symbols=no \
        --with-rename-internal-libgeotiff-symbols=no \
        --with-hide-internal-symbols=yes \
        --with-libtiff=${MASON_TIFF} \
        --with-jpeg=${MASON_JPEG} \
        --with-png=${MASON_PNG} \
        --with-pg=${MASON_LIBPQ}/bin/pg_config \
        --with-static-proj4=${MASON_PROJ} \
        --with-spatialite=no \
        --with-geos=no \
        --with-sqlite3=no \
        --with-curl=no \
        --with-xml2=no \
        --with-pcraster=no \
        --with-cfitsio=no \
        --with-odbc=no \
        --with-libkml=no \
        --with-pcidsk=no \
        --with-jasper=no \
        --with-gif=no \
        --with-grib=no \
        --with-freexl=no \
        --with-avx=no \
        --with-sse=no \
        --with-perl=no \
        --with-ruby=no \
        --with-python=no \
        --with-java=no \
        --with-podofo=no \
        --with-pam \
        --with-webp=no \
        --with-pcre=no \
        --with-liblzma=no \
        --with-netcdf=no \
        --with-poppler=no

    make -j${MASON_CONCURRENCY}
    make install

    # attempt to make paths relative in gdal-config
    python -c "data=open('$MASON_PREFIX/bin/gdal-config','r').read();open('$MASON_PREFIX/bin/gdal-config','w').write(data.replace('$MASON_PREFIX','\$( cd \"\$( dirname \$( dirname \"\$0\" ))\" && pwd )'))"
    cat $MASON_PREFIX/bin/gdal-config
}

function mason_cflags {
    echo "-I${MASON_PREFIX}/include/gdal"
}

function mason_ldflags {
    echo $(${MASON_PREFIX}/bin/gdal-config --static --libs)
}

function mason_clean {
    make clean
}

mason_run "$@"

redpajama_set_name: RedPajamaGithub


text:
export default function transformQuotedBindingsIntoJustBindings(env) {

  return {
    name: 'transform-quoted-bindings-into-just-bindings',

    visitors: {
      ElementNode(node) {
        let styleAttr = getStyleAttr(node);

        if (!validStyleAttr(styleAttr)) { return; }

        styleAttr.value = styleAttr.value.parts[0];
      }
    }
  };
}

function validStyleAttr(attr) {
  if (!attr) { return false; }

  let value = attr.value;

  if (!value ||
      value.type !== 'ConcatStatement' ||
      value.parts.length !== 1) { return false; }

  let onlyPart = value.parts[0];

  return onlyPart.type === 'MustacheStatement';
}

function getStyleAttr(node) {
  let attributes = node.attributes;

  for (let i = 0; i < attributes.length; i++) {
    if (attributes[i].name === 'style') {
      return attributes[i];
    }
  }
}


text:
class PlayerData:

    Id = -1
    Name = ''
    CurrentSceneId = -1
    ListItem = []
    ListScene = []

    def __init__(self, playerId, playerName, currentSceneId, listItem, listScene):
        self.Id = playerId
        self.Name = playerName
        self.CurrentSceneId = currentSceneId
        self.ListItem = listItem
        self.ListScene = listScene
        pass


text:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;

namespace SIL.Windows.Forms.ClearShare
{
	public class CreativeCommonsLicense : LicenseInfo
	{
		public enum DerivativeRules
		{
			NoDerivatives, DerivativesWithShareAndShareAlike, Derivatives
		}

		private bool _attributionRequired;
		public bool AttributionRequired
		{
			get { return _attributionRequired; }
			set
			{
				if (value != _attributionRequired)
				{
					HasChanges = true;
				}
				_attributionRequired = value;
			}
		}

		public override string ToString()
		{
			return Token;  //by-nc-sa
		}

		private bool _commercialUseAllowed;
		public bool CommercialUseAllowed
		{
			get { return _commercialUseAllowed; }
			set
			{
				if (value != _commercialUseAllowed)
				{
					HasChanges = true;
				}
				_commercialUseAllowed = value;
			}
		}

		private DerivativeRules _derivativeRule;
		public DerivativeRules DerivativeRule
		{
			get { return _derivativeRule; }
			set
			{
				if (value != _derivativeRule)
				{
					HasChanges = true;
				}
				_derivativeRule = value;
			}
		}

		public const string kDefaultVersion = "4.0";

		/// <summary>
		/// at the moment, we only use the license url, but in future we could add other custom provisions, like "ok to crop" (if they're allowed by cc?)
		/// </summary>
		public static LicenseInfo FromMetadata(Dictionary<string, string> metadataProperties)
		{
			if(!metadataProperties.ContainsKey("license"))
				throw new ApplicationException("A license property is required in order to make a Creative Commons License from metadata.");

			var result = FromLicenseUrl(metadataProperties["license"]);
			string rights;
			if (metadataProperties.TryGetValue("rights (en)", out rights))
				result.RightsStatement = rights;
			return result;
		}

		/// <summary>
		/// Create a CCL from a string produced by the Token method of a CCL.
		/// It will have the current default Version.
		/// Other values are not guaranteed to work, though at present they will.
		/// Enhance: Possibly we should try to verify that the token is a valid CCL one?
		/// </summary>
		/// <param name="token"></param>
		/// <returns></returns>
		public static LicenseInfo FromToken(string token)
		{
			var result = new CreativeCommonsLicense();
			// Note (JH): Since version was set to default, as I add the qualifier, I'm going to let it be default as well.
			result.Url = MakeUrlFromParts(token, kDefaultVersion, null);
			return result;
		}

		public static CreativeCommonsLicense FromLicenseUrl(string url)
		{
			if(url==null || url.Trim()=="")
			{
				throw new ArgumentOutOfRangeException();
			}
			var l = new CreativeCommonsLicense();
			l.Url = url;
			return l;
		}

		private CreativeCommonsLicense()
		{

		}
		public CreativeCommonsLicense(bool attributionRequired, bool commercialUseAllowed, DerivativeRules derivativeRule, string version)
		{
			AttributionRequired = attributionRequired;
			CommercialUseAllowed = commercialUseAllowed;
			DerivativeRule = derivativeRule;
			Version = version;
		}
		public CreativeCommonsLicense(bool attributionRequired, bool commercialUseAllowed, DerivativeRules derivativeRule)
			:this(attributionRequired, commercialUseAllowed, derivativeRule, kDefaultVersion)
		{
		}

		public override string Url
		{
			get
			{
				return MakeUrlFromParts(Token, Version, _qualifier);
			}
			set
			{
				if(value!=Url)
				{
					HasChanges = true;
				}
				CommercialUseAllowed = true;
				DerivativeRule = DerivativeRules.Derivatives;
				AttributionRequired = false;

				if (value.Contains("by"))
					AttributionRequired = true;
				if (value.Contains("nc"))
					CommercialUseAllowed = false;
				if (value.Contains("nd"))
					DerivativeRule = DerivativeRules.NoDerivatives;
				if (value.Contains("sa"))
					DerivativeRule = DerivativeRules.DerivativesWithShareAndShareAlike;

				var urlWithoutTrailingSlash = value.TrimEnd(new char[] {'/'});
				var parts = urlWithoutTrailingSlash.Split(new char[] { '/' });

				string version;
				try
				{
					version = parts[5];
				}
				catch (IndexOutOfRangeException)
				{
					// We had a problem with some urls getting saved without a version.
					// We fixed the save problem, but now we need to handle that bad data.
					// See http://issues.bloomlibrary.org/youtrack/issue/BL-4108.
					version = kDefaultVersion;
				}

				//just a sanity check on the version
				decimal result;
				if (decimal.TryParse(version, NumberStyles.AllowDecimalPoint, new CultureInfo("en-US"), out result))
					Version = version;

				if(parts.Length > 6)
					_qualifier = parts[6].ToLowerInvariant().Trim();
			}

		}

		private static string MakeUrlFromParts(string token, string version, string qualifier)
		{
			if(token == "cc0")
			{
				// this one is weird in a couple ways, including that it doesn't have /licenses/ in the path
				return "http://creativecommons.org/publicdomain/zero/" + version +"/";
			}

			var url = token + "/";
			if (token.StartsWith("cc-"))
				url = url.Substring("cc-".Length); // don't want this as part of URL.

			if (!string.IsNullOrEmpty(version))
				url += version + "/";

			if (!string.IsNullOrWhiteSpace(qualifier))
				url += qualifier + "/"; // e.g, igo as in https://creativecommons.org/licenses/by/3.0/igo/

			return "http://creativecommons.org/licenses/" + url;
		}

		/// <summary>
		/// A string form used for serialization
		/// </summary>
		/// <remarks>
		/// REVIEW: (asked by Hatton Oct 2016) Serialization by whom? Why not just use the url, which is the canonical form?
		/// Note that this does not include any qualifier (of which at the moment the one one is "igo", but who knows
		/// what the future holds.
		///</remarks>
		public override string Token
		{
			get
			{
				var token = "cc-";
				if (AttributionRequired)
					token += "by-";
				if (!CommercialUseAllowed)
					token += "nc-";
				switch (DerivativeRule)
				{
					case DerivativeRules.NoDerivatives:
						token += "nd";
						break;
					case DerivativeRules.DerivativesWithShareAndShareAlike:
						token += "sa";
						break;
					case DerivativeRules.Derivatives:
						break;
					default:
						throw new ArgumentOutOfRangeException("derivativeRule");
				}
				token = token.TrimEnd(new char[] {'-'});
				if (token == "cc")
					token = "cc0"; // public domain
				return token;
			}
		}

		/// <summary>
		/// A compact form of of this license that doesn't introduce any new text (though the license may itself have text)
		/// E.g. CC-BY-NC
		/// </summary>
		public override string GetMinimalFormForCredits(IEnumerable<string> languagePriorityIds, out string idOfLanguageUsed)
		{
			idOfLanguageUsed = "*";

			var form = "CC-";
			if (AttributionRequired)
				form += "BY-";
			if (!CommercialUseAllowed)
				form += "NC-";
			switch (DerivativeRule)
			{
				case DerivativeRules.NoDerivatives:
					form += "ND";
					break;
				case DerivativeRules.DerivativesWithShareAndShareAlike:
					form += "SA";
					break;
				case DerivativeRules.Derivatives:
					break;
				default:
					throw new ArgumentOutOfRangeException("derivativeRule");
			}
			form = form.TrimEnd(new char[] { '-' });

			var additionalRights = (RightsStatement != null ? ". " + RightsStatement : "");
			return (form + " " + (IntergovernmentalOriganizationQualifier ? "IGO " : "") + Version + additionalRights).Trim();
			;
		}

		/// <summary>
		/// Get a simple, non-legal summary of the license, using the "best" language for which we can find a translation.
		/// </summary>
		/// <param name="languagePriorityIds"></param>
		/// <param name="idOfLanguageUsed">The id of the language we were able to use. Unreliable if we had to use a mix of languages.</param>
		/// <returns>The description of the license.</returns>
		public override string GetDescription(IEnumerable<string> languagePriorityIds, out string idOfLanguageUsed)
		{
			//Enhance labs.creativecommons.org has a lot of code, some of which might be useful, especially if we wanted a full, rather than concise, description.

			//Note that this isn't going to be able to convey to the caller the situation if some strings are translatable in some language, but others in some other language.
			//It will just end up being an amalgam in that case.

			//This IGO qualifier thing is new, and I'm not clear how I want to convey it on the page.
			//We could introduce text like "For more information, see", but the price of needing new
			// localizations at this point is somewhat daunting... for now, it seems enough that the "/igo/" is shown in the URL, if
			//it is in use in this license.

			string s= Url + System.Environment.NewLine;

			if(!AttributionRequired)
			{
				return GetComponentOfLicenseInBestLanguage("PublicDomain", "You can copy, modify, and distribute this work, even for commercial purposes, all without asking permission.", languagePriorityIds, out idOfLanguageUsed) + " ";
			}

			if (CommercialUseAllowed)
				s += GetComponentOfLicenseInBestLanguage("CommercialUseAllowed", "You are free to make commercial use of this work.", languagePriorityIds, out idOfLanguageUsed) + " ";
			else
				s += GetComponentOfLicenseInBestLanguage("NonCommercial", "You may not use this work for commercial purposes.", languagePriorityIds, out idOfLanguageUsed) + " ";

			if(DerivativeRule == DerivativeRules.Derivatives)
				s += GetComponentOfLicenseInBestLanguage("Derivatives", "You may adapt and add to this work.", languagePriorityIds, out idOfLanguageUsed) + " ";

			if (DerivativeRule == DerivativeRules.NoDerivatives)
				s += GetComponentOfLicenseInBestLanguage("NoDerivatives", "You may not make changes or build upon this work without permission.", languagePriorityIds, out idOfLanguageUsed) + " ";

			if (DerivativeRule == DerivativeRules.DerivativesWithShareAndShareAlike)
				s += GetComponentOfLicenseInBestLanguage("DerivativesWithShareAndShareAlike", "You may adapt and add to this work, but you may distribute the resulting work only under the same or similar license to this one.", languagePriorityIds, out idOfLanguageUsed) + " ";

			if (AttributionRequired)
				s += GetComponentOfLicenseInBestLanguage("AttributionRequired", "You must keep the copyright and credits for authors, illustrators, etc.", languagePriorityIds, out idOfLanguageUsed) + " ";

			return s.Trim();
		}

		private string GetComponentOfLicenseInBestLanguage(string idSuffix, string englishText, IEnumerable<string> languagePriorityIds, out string idOfLanguageUsed)
		{
			const string comment = "See http://creativecommons.org/ to find out how this is normally translated in your language. What we're aiming for here is an easy to understand summary.";

			//Note: GetBestLicenseTranslation will prepend "MetadataDisplay.Licenses.", we should not include it here
			return GetBestLicenseTranslation("CreativeCommons." + idSuffix, englishText, comment, languagePriorityIds, out idOfLanguageUsed);
		}

		public override Image GetImage()
		{
			if (AttributionRequired && CommercialUseAllowed && DerivativeRule == DerivativeRules.Derivatives)
				return LicenseLogos.by;

			if (AttributionRequired && CommercialUseAllowed && DerivativeRule == DerivativeRules.NoDerivatives)
				return LicenseLogos.by_nd;

			if (AttributionRequired && CommercialUseAllowed && DerivativeRule == DerivativeRules.DerivativesWithShareAndShareAlike)
				return LicenseLogos.by_sa;

			if (AttributionRequired && !CommercialUseAllowed && DerivativeRule == DerivativeRules.NoDerivatives)
				return LicenseLogos.by_nc_nd;

			if (AttributionRequired && !CommercialUseAllowed && DerivativeRule == DerivativeRules.Derivatives)
				return LicenseLogos.by_nc;

			if (AttributionRequired && !CommercialUseAllowed && DerivativeRule == DerivativeRules.DerivativesWithShareAndShareAlike)
				return LicenseLogos.by_nc_sa;

			return LicenseLogos.cc0;
		}

		public override bool EditingAllowed
		{
			get { return false; }
		}

		private string _version;
		public string Version
		{
			get { return _version; }
			set
			{
				if (value != _version)
				{
					HasChanges = true;
				}
				_version = value;
			}
		}

		// For information on this qualifier, see https://wiki.creativecommons.org/wiki/Intergovernmental_Organizations
		private string _qualifier = null;
		public bool IntergovernmentalOriganizationQualifier
		{
			get { return _qualifier == "igo"; }
			set
			{
				var newValue = value ? "igo" : null;
				if (newValue != _qualifier)
				{
					HasChanges = true;
					if (!value)
					{
						_version = kDefaultVersion; // Undo the switch to 3.0 below
					}
				}
				_qualifier = newValue;
				if(value)
				{
					_version = "3.0";// as of November 2016, igo only had a 3.0 version, while normal cc licenses were up to 4.0
				}
			}
		}

	}
}


text:
package visdebugger.eclipseuiactions;

import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IWatchExpression;
import org.eclipse.jdt.debug.core.IJavaArray;
import org.eclipse.jdt.debug.core.IJavaArrayType;
import org.eclipse.jdt.debug.core.IJavaObject;
import org.eclipse.jdt.debug.core.IJavaReferenceType;
import org.eclipse.jdt.debug.core.IJavaType;
import org.eclipse.jdt.debug.core.IJavaValue;
import org.eclipse.jdt.debug.core.IJavaVariable;
import org.eclipse.jdt.internal.debug.core.model.JDIObjectValue;
import org.eclipse.jdt.internal.debug.core.model.JDIType;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IObjectActionDelegate;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.PluginAction;

import visdebugger.arrays.control.ArraysMainController;
import visdebugger.arrays.model.ArrayExpression;

import com.sun.jdi.ArrayType;
import com.sun.jdi.IntegerType;
import com.sun.jdi.Type;

/**
 * This class acts as an {@link IObjectActionDelegate} to handle the "Visualize" Action invoked
 * on an {@link IJavaVariable} object in the "Variables" view in Eclipse
 * or on an {@link IWatchExpression} object in the "Expressions" view in Eclipse
 * @author Bilal
 *
 */
@SuppressWarnings("restriction")
public class ValueVisActionDelegate implements IObjectActionDelegate {

	public ValueVisActionDelegate() {
	}

	@Override
	public void run(IAction action) {
		// selection must has 1 and only 1 element (as defined in the extension
		StructuredSelection selection = (StructuredSelection)((PluginAction)action).getSelection();
		String itemName = null;
		IJavaValue value = null;
		try {
			if (selection.getFirstElement() instanceof IJavaVariable) {
				IJavaVariable variable = (IJavaVariable)selection.getFirstElement();
				itemName = variable.getName();
				value = (IJavaValue) variable.getValue();
			}
			else if (selection.getFirstElement() instanceof IWatchExpression) {
				IWatchExpression expression = (IWatchExpression)selection.getFirstElement();
				itemName = expression.getExpressionText();
				value = (IJavaValue) expression.getValue();
			}

			if (value != null) {
				if (value instanceof IJavaArray) {
					/*IJavaArray arrValue = (IJavaArray)value;
					int arrLen = arrValue.getLength();
					IJavaType compType = ((IJavaArrayType)arrValue.getJavaType()).getComponentType();
					if (compType instanceof IJavaReferenceType) {
					}
					Type javaType = ((JDIType)compType).getUnderlyingType();
					if (javaType instanceof IntegerType) {

					}
					IJavaValue jvalue = arrValue.getValue(arrLen);
					if (jvalue instanceof IJavaObject) {
						((JDIObjectValue)jvalue).getField("", false).getValue();
					}*/
					ArraysMainController.addExpression(new ArrayExpression(itemName, (IJavaArray)value));
				}

				/*Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
			    MessageBox mb = new MessageBox(shell, SWT.OK);
				// TODO open the suitable visualizer view
			    mb.setText("Visualize Value:");
			    mb.setMessage(itemName + " of type: " + value.getJavaType()
			    			+ " has value " + value);
			    mb.open();*/
			}
		} catch (DebugException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void selectionChanged(IAction action, ISelection selection) {
	}

	@Override
	public void setActivePart(IAction action, IWorkbenchPart targetPart) {

	}

}


text:
/* Easy way to allow for build of multiple binaries */

#include "config.h"
#include "doublefann.h"

#include "fann.c"
#include "fann_io.c"
#include "fann_train.c"
#include "fann_train_data.c"
#include "fann_error.c"
#include "fann_cascade.c"
#include "parallel_fann.c"


text:
import Ember from 'ember';
import UiAspect from 'ui-list/components/ui-aspect';

export default UiAspect.extend({
  aspectType: 'title',
  title: Ember.computed.alias('value')
});


text:
namespace GRU_H4
{
    partial class LogIn
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.label2 = new System.Windows.Forms.Label();
            this.txtbox_id = new System.Windows.Forms.TextBox();
            this.txtbox_pw = new System.Windows.Forms.TextBox();
            this.btn_logIn = new System.Windows.Forms.Button();
            this.label3 = new System.Windows.Forms.Label();
            this.label4 = new System.Windows.Forms.Label();
            this.panel2 = new System.Windows.Forms.Panel();
            this.panel3 = new System.Windows.Forms.Panel();
            this.SuspendLayout();
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 11.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label1.Location = new System.Drawing.Point(234, 64);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(77, 18);
            this.label1.TabIndex = 0;
            this.label1.Text = "Kennitala";
            //
            // label2
            //
            this.label2.AutoSize = true;
            this.label2.Font = new System.Drawing.Font("Microsoft Sans Serif", 11.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label2.Location = new System.Drawing.Point(234, 139);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(67, 18);
            this.label2.TabIndex = 1;
            this.label2.Text = "Lykilorð";
            //
            // txtbox_id
            //
            this.txtbox_id.Font = new System.Drawing.Font("Microsoft Sans Serif", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.txtbox_id.Location = new System.Drawing.Point(237, 85);
            this.txtbox_id.Name = "txtbox_id";
            this.txtbox_id.Size = new System.Drawing.Size(216, 24);
            this.txtbox_id.TabIndex = 1;
            //
            // txtbox_pw
            //
            this.txtbox_pw.Font = new System.Drawing.Font("Microsoft Sans Serif", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.txtbox_pw.Location = new System.Drawing.Point(237, 160);
            this.txtbox_pw.Name = "txtbox_pw";
            this.txtbox_pw.PasswordChar = '*';
            this.txtbox_pw.Size = new System.Drawing.Size(216, 24);
            this.txtbox_pw.TabIndex = 2;
            this.txtbox_pw.KeyDown += new System.Windows.Forms.KeyEventHandler(this.txtbox_pw_KeyDown);
            //
            // btn_logIn
            //
            this.btn_logIn.BackColor = System.Drawing.SystemColors.Control;
            this.btn_logIn.Font = new System.Drawing.Font("Microsoft Sans Serif", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.btn_logIn.Location = new System.Drawing.Point(356, 190);
            this.btn_logIn.Name = "btn_logIn";
            this.btn_logIn.Size = new System.Drawing.Size(97, 30);
            this.btn_logIn.TabIndex = 3;
            this.btn_logIn.Text = "Skrá inn";
            this.btn_logIn.UseVisualStyleBackColor = false;
            this.btn_logIn.Click += new System.EventHandler(this.btn_logIn_Click);
            //
            // label3
            //
            this.label3.AutoSize = true;
            this.label3.Font = new System.Drawing.Font("Minion Pro", 18F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label3.Location = new System.Drawing.Point(22, 23);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(115, 32);
            this.label3.TabIndex = 7;
            this.label3.Text = "Miðasalan";
            //
            // label4
            //
            this.label4.AutoSize = true;
            this.label4.Font = new System.Drawing.Font("Minion Pro Med", 18F, ((System.Drawing.FontStyle)((System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Italic))), System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label4.Location = new System.Drawing.Point(69, 46);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(147, 33);
            this.label4.TabIndex = 8;
            this.label4.Text = "Miða Miðlun";
            //
            // panel2
            //
            this.panel2.BackColor = System.Drawing.Color.SteelBlue;
            this.panel2.Location = new System.Drawing.Point(28, 174);
            this.panel2.Name = "panel2";
            this.panel2.Size = new System.Drawing.Size(113, 100);
            this.panel2.TabIndex = 5;
            //
            // panel3
            //
            this.panel3.BackColor = System.Drawing.Color.LightSkyBlue;
            this.panel3.Location = new System.Drawing.Point(89, 102);
            this.panel3.Name = "panel3";
            this.panel3.Size = new System.Drawing.Size(113, 100);
            this.panel3.TabIndex = 6;
            //
            // LogIn
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.BackColor = System.Drawing.SystemColors.Control;
            this.ClientSize = new System.Drawing.Size(482, 293);
            this.Controls.Add(this.label4);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.panel3);
            this.Controls.Add(this.panel2);
            this.Controls.Add(this.btn_logIn);
            this.Controls.Add(this.txtbox_pw);
            this.Controls.Add(this.txtbox_id);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.label1);
            this.Name = "LogIn";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = " Innskráning";
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.TextBox txtbox_id;
        private System.Windows.Forms.TextBox txtbox_pw;
        private System.Windows.Forms.Button btn_logIn;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.Label label4;
        private System.Windows.Forms.Panel panel2;
        private System.Windows.Forms.Panel panel3;
    }
}


text:
namespace eCollabro.BAL.Entities.Models
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Data.Entity.Spatial;

    [Table("Navigation")]
    public partial class Navigation
    {
        public Navigation()
        {
            Navigation1 = new HashSet<Navigation>();
        }

        public int NavigationId { get; set; }

        [Required]
        [StringLength(10)]
        public string NavigationCode { get; set; }

        [Required]
        [StringLength(50)]
        public string NavigationText { get; set; }

        [StringLength(255)]
        public string AdditionalHtml { get; set; }

        public int SiteId { get; set; }

        public int? NavigationParentId { get; set; }

        public int NavigationTypeId { get; set; }

        public int? FeatureId { get; set; }

        public int? ContentPageId { get; set; }

        [StringLength(255)]
        public string Link { get; set; }

        public int? DisplayOrder { get; set; }

        public bool IsAnomynousAccess { get; set; }

        public bool IsDeleted { get; set; }

        public bool IsActive { get; set; }

        public int CreatedById { get; set; }

        public DateTime CreatedOn { get; set; }

        public int? ModifiedById { get; set; }

        public DateTime? ModifiedOn { get; set; }

        public virtual Feature Feature { get; set; }

        public virtual lkpNavigationType lkpNavigationType { get; set; }

        public virtual ICollection<Navigation> Navigation1 { get; set; }

        public virtual Navigation Navigation2 { get; set; }

        public virtual Site Site { get; set; }
    }
}


text:
@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    HCDObjectStructure *o = [[HCDObjectStructure alloc]init];

    HCDConcreteElementA *eA = [HCDConcreteElementA new];

    HCDConcreteElementB *eB = [HCDConcreteElementB new];

    [o attach:eA];

    [o attach:eB];

    HCDConcreteVisitor1
    *v1 = [HCDConcreteVisitor1 new];

    HCDConcreteVisitor2
    *v2 = [HCDConcreteVisitor2 new];

    [o accept: v1];

    [o accept: v2];

}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end


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

    <string name="app_name">Shapeways</string>
    <string name="action_settings">Settings</string>
    <string name="button_invoke_api">Invoke API</string>

    <!-- API -->
    <string name="shapeways_web_error_title">Error</string>
    <string name="shapeways_web_error">The following error has occurred: %s</string>
    <string name="shapeways_dialog_exit">Exit</string>
    <string name="shapeways_dialog_reload">Reload</string>
    <string name="shapeways_retry">Retry…</string>
    <string name="shapeways_authentication_failed">Authentication Failed</string>
    <string name="shapeways_loading">Loading…</string>

</resources>


text:
package com.bilalalp.patentsearcher.business.parser;

import com.bilalalp.patentsearcher.config.PatentSearcherApplicationContextAware;
import com.bilalalp.patentsearcher.dto.ConfigDto;
import com.bilalalp.patentsearcher.dto.CrawlingDto;
import com.bilalalp.patentsearcher.dto.SearchInfoDto;
import com.bilalalp.patentsearcher.entity.PatentInfo;
import com.bilalalp.patentsearcher.entity.SearchInfo;
import com.bilalalp.patentsearcher.service.searchinfo.SearchInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;

@Service
public class ParserService {

    @Autowired
    private PatentSearcherApplicationContextAware patentSearcherApplicationContextAware;

    @Autowired
    private SearchInfoService searchInfoService;

    @Transactional
    public void crawl(final SearchInfoDto searchInfoDto, final ConfigDto configDto) {

        final Map<String, PatentContentParserService> beansOfType = patentSearcherApplicationContextAware.getContext().getBeansOfType(PatentContentParserService.class);

        final SearchInfo searchInfo = searchInfoService.findById(searchInfoDto.getId());
        final List<PatentInfo> patentInfoList = searchInfo.getPatentInfoList();

        final CrawlingDto crawlingDto = configDto.getCrawlingDto();
        crawlingDto.setTotalCrawlingCount(patentInfoList.size());

        for (final PatentInfo patentInfo : patentInfoList) {

            crawlingDto.setCrawlCount(crawlingDto.getCrawlCount() + 1);
            for (final Map.Entry<String, PatentContentParserService> entry : beansOfType.entrySet()) {

                final PatentContentParserService patentContentParserService = entry.getValue();

                if (patentContentParserService.getSiteUrl().equals(patentInfo.getSiteInfo().getSiteAddres())) {
                    patentContentParserService.getPatentContents(patentInfo, configDto);
                }
            }
        }
    }
}


text:
package org.apache.lucene.analysis.cjk;

import java.io.IOException;
import java.io.Reader;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.BaseTokenStreamTestCase;
import org.apache.lucene.analysis.MockTokenizer;
import org.apache.lucene.analysis.ReusableAnalyzerBase;
import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.KeywordTokenizer;

/**
 * Tests for {@link CJKWidthFilter}
 */
public class TestCJKWidthFilter extends BaseTokenStreamTestCase {
  private Analyzer analyzer = new ReusableAnalyzerBase() {
    @Override
    protected TokenStreamComponents createComponents(String fieldName, Reader reader) {
      Tokenizer source = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
      return new TokenStreamComponents(source, new CJKWidthFilter(source));
    }
  };

  /**
   * Full-width ASCII forms normalized to half-width (basic latin)
   */
  public void testFullWidthASCII() throws IOException {
    assertAnalyzesTo(analyzer, "Test 1234",
      new String[] { "Test",  "1234" },
      new int[] { 0, 5 },
      new int[] { 4, 9 });
  }

  /**
   * Half-width katakana forms normalized to standard katakana.
   * A bit trickier in some cases, since half-width forms are decomposed
   * and voice marks need to be recombined with a preceding base form.
   */
  public void testHalfWidthKana() throws IOException {
    assertAnalyzesTo(analyzer, "カタカナ",
      new String[] { "カタカナ" });
    assertAnalyzesTo(analyzer, "ヴィッツ",
      new String[] { "ヴィッツ" });
    assertAnalyzesTo(analyzer, "パナソニック",
      new String[] { "パナソニック" });
  }

  public void testRandomData() throws IOException {
    checkRandomData(random, analyzer, 10000*RANDOM_MULTIPLIER);
  }

  public void testEmptyTerm() throws IOException {
    Analyzer a = new ReusableAnalyzerBase() {
      @Override
      protected TokenStreamComponents createComponents(String fieldName, Reader reader) {
        Tokenizer tokenizer = new KeywordTokenizer(reader);
        return new TokenStreamComponents(tokenizer, new CJKWidthFilter(tokenizer));
      }
    };
    checkOneTermReuse(a, "", "");
  }
}