text:
;(function ( $, window, document, undefined ) {

$.fn.modal = function(parameters) {
  var
    $allModules = $(this),
    $window     = $(window),
    $document   = $(document),

    time            = new Date().getTime(),
    performance     = [],

    query           = arguments[0],
    methodInvoked   = (typeof query == 'string'),
    queryArguments  = [].slice.call(arguments, 1),

    invokedResponse
  ;

  $allModules
    .each(function() {
      var
        settings    = ( $.isPlainObject(parameters) )
          ? $.extend(true, {}, $.fn.modal.settings, parameters)
          : $.extend({}, $.fn.modal.settings),

        selector        = settings.selector,
        className       = settings.className,
        namespace       = settings.namespace,
        error           = settings.error,

        eventNamespace  = '.' + namespace,
        moduleNamespace = 'module-' + namespace,
        moduleSelector  = $allModules.selector || '',

        $module      = $(this),
        $context     = $(settings.context),
        $otherModals = $allModules.not($module),
        $close       = $module.find(selector.close),

        $focusedElement,
        $dimmable,
        $dimmer,

        element      = this,
        instance     = $module.data(moduleNamespace),
        module
      ;

      module  = {

        initialize: function() {
          module.verbose('Initializing dimmer', $context);

          $dimmable = $context
            .dimmer({
              closable : false,
              show     : settings.duration * 0.95,
              hide     : settings.duration * 1.05
            })
            .dimmer('add content', $module)
          ;
          $dimmer = $dimmable
            .dimmer('get dimmer')
          ;

          module.verbose('Attaching close events', $close);
          $close
            .on('click' + eventNamespace, module.event.close)
          ;
          $window
            .on('resize', function() {
              module.event.debounce(module.refresh, 50);
            })
          ;
          module.instantiate();
        },

        instantiate: function() {
          module.verbose('Storing instance of modal');
          instance = module;
          $module
            .data(moduleNamespace, instance)
          ;
        },

        destroy: function() {
          module.verbose('Destroying previous modal');
          $module
            .removeData(moduleNamespace)
            .off(eventNamespace)
          ;
          $close
            .off(eventNamespace)
          ;
          $context
            .dimmer('destroy')
          ;
        },

        refresh: function() {
          module.remove.scrolling();
          module.cacheSizes();
          module.set.type();
          module.set.position();
        },

        attachEvents: function(selector, event) {
          var
            $toggle = $(selector)
          ;
          event = $.isFunction(module[event])
            ? module[event]
            : module.toggle
          ;
          if($toggle.size() > 0) {
            module.debug('Attaching modal events to element', selector, event);
            $toggle
              .off(eventNamespace)
              .on('click' + eventNamespace, event)
            ;
          }
          else {
            module.error(error.notFound);
          }
        },

        event: {
          close: function() {
            module.verbose('Closing element pressed');
            if( $(this).is(selector.approve) ) {
              $.proxy(settings.onApprove, element)();
            }
            if( $(this).is(selector.deny) ) {
              $.proxy(settings.onDeny, element)();
            }
            module.hide();
          },
          click: function(event) {
            module.verbose('Determining if event occured on dimmer', event);
            if( $dimmer.find(event.target).size() === 0 ) {
              module.hide();
              event.stopImmediatePropagation();
            }
          },
          debounce: function(method, delay) {
            clearTimeout(module.timer);
            module.timer = setTimeout(method, delay);
          },
          keyboard: function(event) {
            var
              keyCode   = event.which,
              escapeKey = 27
            ;
            if(keyCode == escapeKey) {
              if(settings.closable) {
                module.debug('Escape key pressed hiding modal');
                module.hide();
              }
              else {
                module.debug('Escape key pressed, but closable is set to false');
              }
              event.preventDefault();
            }
          },
          resize: function() {
            if( $dimmable.dimmer('is active') ) {
              module.refresh();
            }
          }
        },

        toggle: function() {
          if( module.is.active() ) {
            module.hide();
          }
          else {
            module.show();
          }
        },

        show: function() {
          module.showDimmer();
          module.cacheSizes();
          module.set.position();
          module.hideAll();
          if(settings.transition && $.fn.transition !== undefined) {
            $module
              .transition(settings.transition + ' in', settings.duration, module.set.active)
            ;
          }
          else {
            $module
              .fadeIn(settings.duration, settings.easing, module.set.active)
            ;
          }
          module.debug('Triggering dimmer');
          $.proxy(settings.onShow, element)();
        },

        showDimmer: function() {
          module.debug('Showing modal');
          $dimmable.dimmer('show');
        },

        hide: function() {
          if(settings.closable) {
            $dimmer
              .off('click' + eventNamespace)
            ;
          }
          if( $dimmable.dimmer('is active') ) {
            $dimmable.dimmer('hide');
          }
          if( module.is.active() ) {
            module.hideModal();
            $.proxy(settings.onHide, element)();
          }
          else {
            module.debug('Cannot hide modal, modal is not visible');
          }
        },

        hideDimmer: function() {
          module.debug('Hiding dimmer');
          $dimmable.dimmer('hide');
        },

        hideModal: function() {
          module.debug('Hiding modal');
          module.remove.keyboardShortcuts();
          if(settings.transition && $.fn.transition !== undefined) {
            $module
              .transition(settings.transition + ' out', settings.duration, function() {
                module.remove.active();
                module.restore.focus();
              })
            ;
          }
          else {
            $module
              .fadeOut(settings.duration, settings.easing, function() {
                module.remove.active();
                module.restore.focus();
              })
            ;
          }
        },

        hideAll: function() {
          $otherModals
            .filter(':visible')
            .modal('hide')
          ;
        },

        add: {
          keyboardShortcuts: function() {
            module.verbose('Adding keyboard shortcuts');
            $document
              .on('keyup' + eventNamespace, module.event.keyboard)
            ;
          }
        },

        save: {
          focus: function() {
            $focusedElement = $(document.activeElement).blur();
          }
        },

        restore: {
          focus: function() {
            if($focusedElement.size() > 0) {
              $focusedElement.focus();
            }
          }
        },

        remove: {
          active: function() {
            $module.removeClass(className.active);
          },
          keyboardShortcuts: function() {
            module.verbose('Removing keyboard shortcuts');
            $document
              .off('keyup' + eventNamespace)
            ;
          },
          scrolling: function() {
            $dimmable.removeClass(className.scrolling);
            $module.removeClass(className.scrolling);
          }
        },

        cacheSizes: function() {
          module.cache = {
            height        : $module.outerHeight() + settings.offset,
            contextHeight : (settings.context == 'body')
              ? $(window).height()
              : $dimmable.height()
          };
          module.debug('Caching modal and container sizes', module.cache);
        },

        can: {
          fit: function() {
            return (module.cache.height < module.cache.contextHeight);
          }
        },

        is: {
          active: function() {
            return $module.hasClass(className.active);
          }
        },

        set: {
          active: function() {
            module.add.keyboardShortcuts();
            module.save.focus();
            module.set.type();
            $module
              .addClass(className.active)
            ;
            if(settings.closable) {
              $dimmer
                .on('click' + eventNamespace, module.event.click)
              ;
            }
          },
          scrolling: function() {
            $dimmable.addClass(className.scrolling);
            $module.addClass(className.scrolling);
          },
          type: function() {
            if(module.can.fit()) {
              module.verbose('Modal fits on screen');
              module.remove.scrolling();
            }
            else {
              module.verbose('Modal cannot fit on screen setting to scrolling');
              module.set.scrolling();
            }
          },
          position: function() {
            module.verbose('Centering modal on page', module.cache, module.cache.height / 2);
            if(module.can.fit()) {
              $module
                .css({
                  top: '',
                  marginTop: -(module.cache.height / 2)
                })
              ;
            }
            else {
              $module
                .css({
                  marginTop : '1em',
                  top       : $document.scrollTop()
                })
              ;
            }
          }
        },

        setting: function(name, value) {
          if(value !== undefined) {
            if( $.isPlainObject(name) ) {
              $.extend(true, settings, name);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function(name, value) {
          if(value !== undefined) {
            if( $.isPlainObject(name) ) {
              $.extend(true, module, name);
            }
            else {
              module[name] = value;
            }
          }
          else {
            return module[name];
          }
        },
        debug: function() {
          if(settings.debug) {
            if(settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function() {
          if(settings.verbose && settings.debug) {
            if(settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function() {
          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
          module.error.apply(console, arguments);
        },
        performance: {
          log: function(message) {
            var
              currentTime,
              executionTime,
              previousTime
            ;
            if(settings.performance) {
              currentTime   = new Date().getTime();
              previousTime  = time || currentTime;
              executionTime = currentTime - previousTime;
              time          = currentTime;
              performance.push({
                'Element'        : element,
                'Name'           : message[0],
                'Arguments'      : [].slice.call(message, 1) || '',
                'Execution Time' : executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display, 100);
          },
          display: function() {
            var
              title = settings.name + ':',
              totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function(index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if(moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if( (console.group !== undefined || console.table !== undefined) && performance.length > 0) {
              console.groupCollapsed(title);
              if(console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function(index, data) {
                  console.log(data['Name'] + ': ' + data['Execution Time']+'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function(query, passedArguments, context) {
          var
            maxDepth,
            found,
            response
          ;
          passedArguments = passedArguments || queryArguments;
          context         = element         || context;
          if(typeof query == 'string' && instance !== undefined) {
            query    = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function(depth, value) {
              var camelCaseValue = (depth != maxDepth)
                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                : query
              ;
              if( $.isPlainObject( instance[value] ) && (depth != maxDepth) ) {
                instance = instance[value];
              }
              else if( $.isPlainObject( instance[camelCaseValue] ) && (depth != maxDepth) ) {
                instance = instance[camelCaseValue];
              }
              else if( instance[value] !== undefined ) {
                found = instance[value];
                return false;
              }
              else if( instance[camelCaseValue] !== undefined ) {
                found = instance[camelCaseValue];
                return false;
              }
              else {
                module.error(error.method);
                return false;
              }
            });
          }
          if ( $.isFunction( found ) ) {
            response = found.apply(context, passedArguments);
          }
          else if(found !== undefined) {
            response = found;
          }
          if($.isArray(invokedResponse)) {
            invokedResponse.push(response);
          }
          else if(typeof invokedResponse == 'string') {
            invokedResponse = [invokedResponse, response];
          }
          else if(response !== undefined) {
            invokedResponse = response;
          }
          return found;
        }
      };

      if(methodInvoked) {
        if(instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if(instance !== undefined) {
          module.destroy();
        }
        module.initialize();
      }
    })
  ;

  return (invokedResponse !== undefined)
    ? invokedResponse
    : this
  ;
};

$.fn.modal.settings = {

  name        : 'Modal',
  namespace   : 'modal',
  verbose     : true,
  debug       : true,
  performance : true,

  closable    : true,
  context     : 'body',
  duration    : 500,
  easing      : 'easeOutExpo',
  offset      : 0,
  transition  : 'scale',

  onShow      : function(){},
  onHide      : function(){},
  onApprove   : function(){},
  onDeny      : function(){},

  selector    : {
    close    : '.close, .actions .button',
    approve  : '.actions .positive, .actions .approve',
    deny     : '.actions .negative, .actions .cancel'
  },
  error : {
    method : 'The method you called is not defined.'
  },
  className : {
    active    : 'active',
    scrolling : 'scrolling'
  },
};

})( jQuery, window , document );


text:
package org.jgroups.protocols.raft;

import org.jgroups.Global;
import org.jgroups.annotations.MBean;
import org.jgroups.annotations.Property;
import org.jgroups.conf.AttributeType;
import org.jgroups.conf.ClassConfigurator;
import org.jgroups.raft.Settable;
import org.jgroups.stack.Protocol;
import org.jgroups.util.MessageBatch;
import org.jgroups.util.Util;

import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;

/**
 * Protocol listening on a socket for client requests. Dispatches them to the leader (via {@link REDIRECT}) and sends
 * back the response. Requests and responses are always sent as
 * <pre>
 *     | RequestType (byte) | request-id (int) | length (int) | byte[] buffer |
 * </pre>
 * @author Bela Ban
 * @since  0.2
 */
@MBean(description="Listens on a socket for client requests, forwards them to the leader and send responses")
public class CLIENT extends Protocol implements Runnable {
    protected static final short  CLIENT_ID = 523;
    protected static final byte[] BUF={};

    public enum RequestType {set_req, add_server, remove_server, type, rsp}

    static {
        ClassConfigurator.addProtocol(CLIENT_ID, CLIENT.class);
    }

    @Property(name="bind_addr",
      description="The bind address which should be used by the server socket. The following special values " +
        "are also recognized: GLOBAL, SITE_LOCAL, LINK_LOCAL, NON_LOOPBACK, match-interface, match-host, match-address",
      systemProperty={Global.BIND_ADDR},writable=false)
    protected InetAddress       bind_addr;

    @Property(description="Port to listen for client requests",writable=false)
    protected int               port=1965;

    @Property(description="The min threads in the thread pool")
    protected int               min_threads;

    @Property(description="Max number of threads in the thread pool")
    protected int               max_threads=100;

    @Property(description="Number of ms a thread can be idle before being removed from the thread pool",
      type=AttributeType.TIME)
    protected long              idle_time=5000;

    @Property(description="Number of bytes of the server socket's receive buffer",type=AttributeType.BYTES)
    protected int               recv_buf_size;

    protected Settable settable;
    protected DynamicMembership dyn_membership;
    protected ServerSocket      sock;
    protected ExecutorService   thread_pool; // to handle requests
    protected Thread            acceptor;

    public InetAddress getBindAddress()              {return bind_addr;}
    public CLIENT      setBindAddress(InetAddress b) {this.bind_addr=b; return this;}
    public int         getPort()                     {return port;}
    public CLIENT      setPort(int p)                {this.port=p; return this;}
    public int         getMinThreads()               {return min_threads;}
    public CLIENT      setMinThreads(int t)          {this.min_threads=t; return this;}
    public int         getMaxThreads()               {return max_threads;}
    public CLIENT      setMaxThreads(int t)          {this.max_threads=t; return this;}
    public long        getIdleTime()                 {return idle_time;}
    public CLIENT      setIdleTime(long t)           {this.idle_time=t; return this;}
    public int         getReceiveBufferSize()        {return recv_buf_size;}
    public CLIENT      setReceiveBufferSize(int s)   {this.recv_buf_size=s; return this;}

    public void init() throws Exception {
        super.init();
        if((settable=RAFT.findProtocol(Settable.class, this, true)) == null)
            throw new IllegalStateException("did not find a protocol implementing Settable (e.g. REDIRECT or RAFT)");
        if((dyn_membership=RAFT.findProtocol(DynamicMembership.class, this, true)) == null)
            throw new IllegalStateException("did not find a protocol implementing DynamicMembership (e.g. REDIRECT or RAFT)");
    }

    public void start() throws Exception {
        super.start();
        sock=Util.createServerSocket(getSocketFactory(), "CLIENR.srv_sock", bind_addr, port, port+50, recv_buf_size);
        if(sock == null)
            throw new IllegalStateException(String.format("failed creating server socket at %s:%d", bind_addr, port));
        thread_pool=new ThreadPoolExecutor(min_threads, max_threads, idle_time, TimeUnit.MILLISECONDS,
                                           new SynchronousQueue<>(), getThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
        acceptor=new Thread(this, "CLIENT.Acceptor");
        acceptor.start();
    }

    public void stop() {
        super.stop();
        Util.close(sock);
        if(thread_pool != null)
            thread_pool.shutdown();
    }

    @Override
    public void destroy() {
        super.destroy();
        Util.close(sock);
        if(thread_pool != null)
            thread_pool.shutdown();
    }

    public void run() {
        while(true) {
            try {
                Socket client_sock=sock.accept();
                thread_pool.execute(new RequestHandler(client_sock));
            }
            catch(IOException ignored) {
                if(sock.isClosed())
                    return;
            }
            catch(Throwable ex) {
                log.error("error accepting new connection", ex);
            }
        }
    }

    public void up(MessageBatch batch) {
        up_prot.up(batch);
    }

    protected class RequestHandler implements Runnable {
        protected final Socket client_sock;

        public RequestHandler(Socket client_sock) {
            this.client_sock=client_sock;
        }

        public void run() {
            DataInputStream in=null; DataOutputStream out=null;
            CompletionHandler completion_handler=null;
            try {
                in=new DataInputStream(client_sock.getInputStream());
                out=new DataOutputStream(client_sock.getOutputStream());
                RequestType type=RequestType.values()[in.readByte()];
                int request_id=in.readInt();
                completion_handler=new CompletionHandler(client_sock, in, out, request_id);
                int length=in.readInt();
                byte[] buffer=new byte[length];
                in.readFully(buffer);
                switch(type) {
                    case set_req:
                        settable.setAsync(buffer, 0, buffer.length).whenComplete(completion_handler);
                        break;
                    case add_server:
                        dyn_membership.addServer(Util.bytesToString(buffer)).whenComplete(completion_handler);
                        break;
                    case remove_server:
                        dyn_membership.removeServer(Util.bytesToString(buffer)).whenComplete(completion_handler);
                        break;
                    case rsp:
                        // not handled on the server side
                        break;
                }
            }
            catch(Throwable ex) {
                log.error("failed handling request", ex);
                if(completion_handler != null)
                    completion_handler.accept(null, ex); // sends back an error response
                Util.close(in,out,client_sock);
            }
        }

        protected void send(DataOutput out, RequestType type, int request_id,
                            byte[] buffer, int offset, int length) throws Exception {
            out.writeByte((byte)type.ordinal());
            out.writeInt(request_id);
            int len=buffer == null? 0 : length;
            out.writeInt(len);
            if(len > 0)
                out.write(buffer, offset, length);
        }

        protected class CompletionHandler implements BiConsumer<byte[],Throwable> {
            protected final Socket           s;
            protected final DataInputStream  input;
            protected final DataOutputStream output;
            protected final int              req_id;

            public CompletionHandler(Socket client_sock, DataInputStream input, DataOutputStream output, int req) {
                this.s=client_sock;
                this.input=input;
                this.output=output;
                this.req_id=req;
            }

            public void accept(byte[] buf, Throwable ex) {
                try {
                    if(ex != null) {
                        byte[] rsp_buffer=Util.objectToByteBuffer(ex);
                        send(output, RequestType.rsp, req_id, rsp_buffer, 0, rsp_buffer.length);
                        return;
                    }
                    if(buf == null)
                        buf=BUF;
                    send(output, RequestType.rsp, req_id, buf, 0, buf.length);
                }
                catch(Throwable t) {
                    log.error("failed in sending response to client", t);
                }
                finally {
                    Util.close(output, input, s);
                }
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package com.github.rutledgepaulv.qbuilders.visitors;

import com.github.rutledgepaulv.qbuilders.conditions.Condition;
import com.github.rutledgepaulv.qbuilders.nodes.*;
import com.github.rutledgepaulv.qbuilders.operators.ComparisonOperator;

import java.util.Collection;

@SuppressWarnings("ConstantConditions")
public abstract class ContextualNodeVisitor<T,S> {

    protected abstract T visit(AndNode node, S context);

    protected abstract T visit(OrNode node, S context);

    protected abstract T visit(ComparisonNode node, S context);

    /**
     * Build a comparison node value into a visited value so that
     * it can be composed into the larger query being built.
     *
     * @param node The node with a condition argument to build into a visited value.
     *
     * @return The visited value.
     */
    protected T condition(ComparisonNode node,S context) {
        if(!node.getOperator().equals(ComparisonOperator.SUB_CONDITION_ANY)) {
            throw new IllegalArgumentException("You can only build a condition for sub-condition operator nodes.");
        }

        Object sub = node.getValues().iterator().next();

        // support either submitting a tree node in which case handle visiting it for
        // them, or submit a Condition representing a wrapper around that tree in which
        // case visit it with this visitor
        if(sub instanceof AbstractNode) {
            return visitAny((AbstractNode) sub, context);
        } else if (sub instanceof Condition<?>) {
            return ((Condition<?>) sub).query(this, context);
        } else {
            throw new IllegalArgumentException("Unknown node value type for subquery.");
        }

    }

    protected Object single(Collection<?> values) {
        if(!values.isEmpty()) {
            return values.iterator().next();
        } else {
            throw new IllegalArgumentException("You must provide a non-null query value for the condition.");
        }
    }

    public final T visitAny(AbstractNode node, S context) {

        // skip straight to the children if it's a logical node with one member
        if(node instanceof LogicalNode) {
            LogicalNode logical = (LogicalNode) node;
            if(logical.getChildren().size() == 1) {
                return visitAny(logical.getChildren().get(0), context);
            }
        }

        if(node instanceof AndNode){
            return visit((AndNode)node, context);
        } else if (node instanceof OrNode){
            return visit((OrNode)node, context);
        } else {
            return visit((ComparisonNode)node, context);
        }

    }

}


text:
Commit Snowflake
================

The idea behind the project is to generate a snowflake based on a given
hexadecimal input, such as a *Git Commit Number*.

Usage
-----

The standard interface gives you the **canvas** and knows how to build
the snowflake from the *hash* location.

Future
------

The intention is to also create a **chrome/chromium** extension activateable on
*github* or *bitbucket*.


text:
import {Component, OnDestroy, OnInit} from '@angular/core';
import {ActivatedRoute} from '@angular/router';
import {ClusterRoleDetail} from '@api/root.api';
import {Subject} from 'rxjs';
import {takeUntil} from 'rxjs/operators';

import {ActionbarService, ResourceMeta} from '@common/services/global/actionbar';
import {NotificationsService} from '@common/services/global/notifications';
import {EndpointManager, Resource} from '@common/services/resource/endpoint';
import {ResourceService} from '@common/services/resource/resource';

@Component({
  selector: 'kd-cluster-role-detail',
  templateUrl: './template.html',
})
export class ClusterRoleDetailComponent implements OnInit, OnDestroy {
  private readonly unsubscribe_ = new Subject<void>();
  private readonly endpoint_ = EndpointManager.resource(Resource.clusterRole);

  clusterRole: ClusterRoleDetail;
  isInitialized = false;

  constructor(
    private readonly clusterRole_: ResourceService<ClusterRoleDetail>,
    private readonly actionbar_: ActionbarService,
    private readonly route_: ActivatedRoute,
    private readonly notifications_: NotificationsService
  ) {}

  ngOnInit(): void {
    const resourceName = this.route_.snapshot.params.resourceName;

    this.clusterRole_
      .get(this.endpoint_.detail(), resourceName)
      .pipe(takeUntil(this.unsubscribe_))
      .subscribe((d: ClusterRoleDetail) => {
        this.clusterRole = d;
        this.notifications_.pushErrors(d.errors);
        this.actionbar_.onInit.emit(new ResourceMeta('Cluster Role', d.objectMeta, d.typeMeta));
        this.isInitialized = true;
      });
  }

  ngOnDestroy(): void {
    this.unsubscribe_.next();
    this.unsubscribe_.complete();
    this.actionbar_.onDetailsLeave.emit();
  }
}


text:
The DynamicPULSE Agent Framework enables the use of DynamicPULSE Agent with deployed applications.
Pushing any DynamicPULSE enabled application (containing `dynamicpulse-remote.xml`) will automatically download the DynamicPULSE Agent and set it up for use.

    Detection Criterion
    Presence of a <tt>/WEB-INF/dynamicpulse-remote.xml</tt> file inside the application archive. The detail of this file is shown in DynamicPULSE Getting Started Guide.

    Tags	<tt>DynamicPULSE-<version></tt>

Tags are printed to standard output by the buildpack detect script.

## User Provided Service
Users must provide DynamicPULSE Center service on the SoftLayer through purchasing DynamicPULSE on IBM Cloud marketplace.

## Configuration
This framework does not have any configuration files.
For more information about configuring the buildpack, see [Configuration and Extension][].

[Configuration and Extension]: ../README.md#Configuration-and-Extension


text:
<?php

// autoload.php @generated by Composer

require_once __DIR__ . '/composer' . '/autoload_real.php';

return ComposerAutoloaderInite603be002b0f61b40380178b88332f68::getLoader();


text:
NOTE: This project is not supported by Google in any way.

# Open Smart Button

Open Smart button is a project to create affordable Bluetooth Low Energy (BLE) buttons
that can be used to power actions on Smartphones.

Open Smart button is composed of:

 * Information/blueprints to 3D-print your own buttons and equipped them with the
   necessary hardware.

 * The uC SW reads pushes of the button and transmitt them to the smartphone via BLE.

 * An android app that receives info from the button via BLE and sends Android intents
   that triggers actions on other app(s) on the phone.


text:
var app=angular.module("feedbackApp",[]);
app.controller("feedbackController",["$scope","$http","$location",function($scope,$http,$location){

$scope.id=$location.search().id;
$scope.name=$location.search().name;

$scope.addFeedback=function(){
$scope.feedback.clientid=$scope.id;
$scope.feedback.clientname=$scope.name;
console.log($scope.feedback);
	$http.post("/feedbackList",$scope.feedback).success(function(response){
		console.log(response);
		if(response!=null){
			alert("Thank you for your valuable feedback");
			window.location="clientprofile.html#?id="+$scope.id;
		}
	})
}

}]);


text:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="zh_CN">
<context>
    <name>MainWidget</name>
    <message>
        <location filename="mainwidget.ui" line="15"/>
        <source>QBingWallpaper</source>
        <translation>必应壁纸 Q</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="27"/>
        <source>&Save wallpapers to:</source>
        <translation>保存壁纸到(&S):</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="44"/>
        <source>...</source>
        <translation></translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="53"/>
        <source>Show &copyright at top right corner</source>
        <oldsource>Show copyright at top right corner</oldsource>
        <translation>在右上角显示版权(&C)</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="62"/>
        <source>&Font family:</source>
        <translation>字体(&F):</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="75"/>
        <source>Font &size:</source>
        <translation>大小(&S):</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="85"/>
        <source>Auto</source>
        <translation>自动</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="88"/>
        <source> point</source>
        <translation> 点</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="101"/>
        <source>&Run at user logon</source>
        <oldsource>Run at user logon</oldsource>
        <translation>用户登录时自动运行(&R)</translation>
    </message>
    <message>
        <location filename="mainwidget.ui" line="128"/>
        <source>E&xit</source>
        <translation>退出(&X)</translation>
    </message>
    <message>
        <location filename="mainwidget.cpp" line="53"/>
        <source>Sans</source>
        <translation>微软雅黑</translation>
    </message>
    <message>
        <location filename="mainwidget.cpp" line="84"/>
        <source>Getting image URL...</source>
        <translation>正在获取图片地址...</translation>
    </message>
    <message>
        <location filename="mainwidget.cpp" line="143"/>
        <source>Failed to download</source>
        <translation>下载失败</translation>
    </message>
    <message>
        <location filename="mainwidget.cpp" line="167"/>
        <source>Downloading image...</source>
        <translation>正在下载图片...</translation>
    </message>
    <message>
        <location filename="mainwidget.cpp" line="193"/>
        <source>Failed to set the wallpaper.</source>
        <translation>设置桌面背景时失败。</translation>
    </message>
    <message>
        <location filename="mainwidget.cpp" line="198"/>
        <source>Failed to save the picture.</source>
        <translation>保存图片时失败。</translation>
    </message>
</context>
<context>
    <name>main</name>
    <message>
        <location filename="main.cpp" line="19"/>
        <source>Download and set today's Bing wallpaper.</source>
        <translation>下载并设置今日必应壁纸。</translation>
    </message>
    <message>
        <location filename="main.cpp" line="24"/>
        <source>Automatically download and set the wallpaper.</source>
        <translation>自动下载并设置壁纸。</translation>
    </message>
</context>
</TS>