text:
package eventstore
package core
package operations

import ReadEventError._
import Inspection.Decision._

private[eventstore] final case class ReadEventInspection(out: ReadEvent)
    extends ErrorInspection[ReadEventCompleted, ReadEventError] {

  def decision(error: ReadEventError) = {
    val result = error match {
      case EventNotFound  => EventNotFoundException(streamId, out.eventNumber)
      case StreamNotFound => StreamNotFoundException(streamId)
      case StreamDeleted  => StreamDeletedException(s"Read failed due to $streamId has been deleted")
      case e: Error       => ServerErrorException(e.message.getOrElse(e.toString))
      case AccessDenied   => AccessDeniedException(s"Read access denied for $streamId")
    }

    Fail(result)
  }

  def streamId = out.streamId
}


text:
httpclient Login Handler
========================

This chapter describes how to implement a login handler behavior of the
`httpclient` application. This behavior is where you specify application
specific authentication logic.

Behavior
--------

There is only one function to implement

````erlang
-callback login(Conn :: term(), HttpState :: term()) ->
    tuple('ok', Token :: term()) | tuple('error', Reason :: string()).
````

In short, you will get passed a Connection object and a HttpState object,
and the goal is to get back an `{ok, Token}` return where the `Token` is
a usable authentication information by each service pool worker.

Notes:
* to read the `Conn` argument, use the `httpclient_conn` module
* if you need to make an HTTP call, which is very likely, you are encouraged
    to create an `httpclient_req` and use `httpclient_http:request/3`
    function to which you would pass the `HttpState` value
* `HttpState` need only be used as above
* the use cases for this are OAuth2, OpenID, and variety of other similar
    custom protocols used for authentication

Logging in
----------

Once you have started a pool, logging in is easy: just call
`httpclient_login:login(default)` from your application, where `default` is
a connection tuple name defined in your connection configuration. This will
trigger a callback to your application-specific login implementation above.

redpajama_set_name: RedPajamaGithub


text:
(function () {
    "use strict";
    var app = angular.module("app");
    app.directive("waiter", [function () {
        //Usage:
        //<waiter is-waiting="vm.isBusy" spinner-options="vm.spinnerOptions" waitMessage="vm.busyMessage"></waiter>
        var directive = {
            link: link,
            replace: true,
            restrict: "E",
            scope: {
                "isWaiting": "=",
                "spinnerOptions": "=",
                "waitMessage": "="
            },
            templateUrl: "app/directives/waiter.html"
        };
        return directive;
        function link(scope, element, attrs) {
            //attrs.$set("class", "widget-head");
        }
    }]);
})();
//# sourceMappingURL=waiter.js.map


text:
package iMat;

import javafx.fxml.FXML;
import javafx.fxml.FXMLLoader;
import javafx.scene.control.Label;
import javafx.scene.control.TitledPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.Pane;
import se.chalmers.ait.dat215.project.*;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

/**
 * Created by Marcus on 2016-03-03.
 */
public class PreviousPurchaseControl extends TitledPane {

    IMatDataHandler backEnd = IMatDataHandler.getInstance();
    ShoppingCart theCart = backEnd.getShoppingCart();
    private Order order;

    @FXML
    private TitledPane orderTitledPane;
    @FXML
    private GridPane orderGridPane;
    @FXML
    private Label sumLabel;

    public PreviousPurchaseControl(Order order) {
        FXMLLoader fxmlLoader = new FXMLLoader(getClass().getResource(
                "previousPurchase.fxml"));
        fxmlLoader.setRoot(this);

        fxmlLoader.setController(this);

        try {
            fxmlLoader.load();
        } catch (IOException exception) {
            throw new RuntimeException(exception);
        }

        this.order = order;

        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        orderTitledPane.setText(sf.format(order.getDate()).toString());
        displayPurchasedItems();
    }

    private void displayPurchasedItems() {
        List<ShoppingItem> items = order.getItems();
        int totalItems = items.size();
        int yPos = 0;
        int sum = 0;

        for(int i = 0; i < totalItems; i++) {
            ShoppingItem item = items.get(i);
            sum += item.getTotal();
            orderGridPane.add(new PreviousPurchaseItemControl(item, i), 0, yPos);
            yPos = yPos + 1;
        }
        sumLabel.setText(Integer.toString(sum) + " kr");
    }

    @FXML
    public void addAllToCart() {
        Iterator iter = orderGridPane.getChildren().iterator();
        while(iter.hasNext()){
            PreviousPurchaseItemControl item = (PreviousPurchaseItemControl) iter.next();
            item.addToCart();
        }
    }
}


text:
namespace sdm {

class Subgrad_method : virtual public PrimalSolver {
public:
  Subgrad_method(const std::string &train_libsvm_format, const double &c = 1.0,
               const double &stpctr = 1e-128,
              const unsigned int &max_iter = 100);
  Subgrad_method(const std::string &train_libsvm_format,
              const std::string &valid_libsvm_format, const double &c = 1.0,
               const double &stpctr = 1e-128,
              const unsigned int &max_iter = 300);
  ~Subgrad_method();

  void set_regularized_parameter(const double &c);

  int get_train_l(void);
  int get_valid_l(void);
  int get_valid_n(void);
  double predict(const Eigen::VectorXd &w) const;
  Eigen::VectorXd train_warm_start(const Eigen::VectorXd &w);

  double get_primal_func(const Eigen::VectorXd &w);
  Eigen::VectorXd get_grad(const Eigen::VectorXd &w);
  double get_grad_norm(const Eigen::VectorXd &w);

  std::vector<double> get_c_set_right_opt(const Eigen::VectorXd &w,
                                          const double &c_now,
                                          double &valid_err);
  // Eigen::VectorXd train_warm_start_inexact(const Eigen::VectorXd &alpha,
  //                                          const double inexact_level,
  //                                          double &ub_validerr,
  //                                          double &lb_validerr);

private:
  Eigen::SparseMatrix<double, 1, std::ptrdiff_t> train_x_;
  Eigen::ArrayXd train_y_;
  int train_l_;
  int train_n_;

  double C;
  double stopping_criterion;
  unsigned int max_iteration;

  Eigen::SparseMatrix<double, 1, std::ptrdiff_t> valid_x_;
  Eigen::ArrayXd valid_y_;
  int valid_l_;
  int valid_n_;

};
} // namespace sdm

#endif


text:
Stream
---
Java 8 Stream API is a big step towards functional programming and leverages multi-core processors which are ubiquitous nowadays. Stream represents a series of objects sourced from collection and support data processing queries, SQL like operations.

There are generic interface **Stream\<T>** and three specific interfaces for primitives, **DoubleStream**, **IntStream** and **LongStream**

Difference between **Stream\<Integer>** and **IntStream** is that:
**IntStream** is for primitives (int, short, byte and char)
**Stream\<Integer>** is for Integer wrapper class

![Image of Yaktocat](streams.png)

Methods to convert between different Streams

Source | To create Stream | To create DoubleStream | To create IntStream | To create LongStream
--- | --- |--- |--- |---
**Stream** | map | mapToDouble | mapToInt | mapToLong
**DoubleStream** | mapToObj | map | mapToInt | mapToLong
**IntStream** | mapToObj | mapToDouble | map | mapToLong
**LongStream** | mapToObj | mapToDouble | mapToInt | map

Those **map*** methods take a single parameter Function, respectively.

Source | To create Stream | To create DoubleStream | To create IntStream | To create LongStream
--- | --- |--- |--- |---
**Stream** | Function | ToDoubleFunction | ToIntFunction | ToLongFunction
**DoubleStream** | DoubleFunction | DoubleUnaryOperator | DoubleToIntFunction | DoubleToLongFunction
**IntStream** | IntFunction | IntToDoubleFunction | IntUnaryOperator | IntToLongFunction
**LongStream** | LongFunction | LongToDoubleFunction | LongToIntFunction | LongUnaryOperator

Parallel stream
---
It is a stream that can process results simultaneously by using multiple threads. Although performance increase can be achieved, it can change the result unexpectedly if not used carefully.


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Net;

namespace ZTImage
{
    /// <summary>
    /// http request
    /// the header range format:-----Range:bytes=0-100
    /// </summary>
    public class HttpEx
    {
        /// <summary>
        /// 请求方式
        /// </summary>
        public enum RequestMethod
        {
            GET,
            POST,
            PUT,
            DELETE
        }

        #region Get
        public static string SyncGet(string url, Dictionary<string, string> headers = null)
        {
            Stream content = SyncRequestStream(RequestMethod.GET, url, null, headers);

            StreamReader reader = new StreamReader(content);
            return reader.ReadToEnd();
        }

        public async static Task<string> Get(string url, Dictionary<string, string> headers = null)
        {
            Stream content = await RequestStream(RequestMethod.GET, url, null, headers);

            StreamReader reader = new StreamReader(content);
            return await reader.ReadToEndAsync();
        }

        public static string SyncGet(string url, string data, Dictionary<string, string> headers = null)
        {
            Stream content = SyncGetStream(url, data, headers);

            StreamReader reader = new StreamReader(content);
            return reader.ReadToEnd();
        }

        public async static Task<string> Get(string url, string data, Dictionary<string, string> headers = null)
        {
            Stream content = await GetStream(url, data, headers);

            StreamReader reader = new StreamReader(content);
            return await reader.ReadToEndAsync();
        }

        public static Stream SyncGetStream(string url, Dictionary<string, string> headers = null)
        {
            return SyncRequestStream(RequestMethod.GET, url, null, headers);
        }

        public async static Task<Stream> GetStream(string url, Dictionary<string, string> headers = null)
        {
            return await RequestStream(RequestMethod.GET, url, null, headers);
        }

        public static Stream SyncGetStream(string url, string data, Dictionary<string, string> headers = null)
        {
            if (!string.IsNullOrEmpty(data))
            {
                if (url.IndexOf("?") > 0)
                {
                    url += "&" + data;
                }
                else
                {
                    url += "?" + data;
                }
            }
            return SyncRequestStream(RequestMethod.GET, url, null, headers);
        }

        public async static Task<Stream> GetStream(string url, string data, Dictionary<string, string> headers = null)
        {

            if (!string.IsNullOrEmpty(data))
            {
                if (url.IndexOf("?") > 0)
                {
                    url += "&" + data;
                }
                else
                {
                    url += "?" + data;
                }
            }

            return await RequestStream(RequestMethod.GET, url, null, headers);
        }
        #endregion

        #region Post

        public static String SyncPost(string url, Dictionary<string, string> headers = null)
        {
            Stream stream = SyncRequestStream(RequestMethod.POST, url, null, headers);
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
        }

        public async static Task<string> Post(string url, Dictionary<string, string> headers = null)
        {
            Stream stream = await RequestStream(RequestMethod.POST, url, null, headers);
            StreamReader reader = new StreamReader(stream);
            return await reader.ReadToEndAsync();
        }

        public static string SyncPost(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);

            }
            Stream stream = SyncRequestStream(RequestMethod.POST, url, bdata, headers);
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
        }

        public async static Task<string> Post(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);

            }
            Stream stream = await RequestStream(RequestMethod.POST, url, bdata, headers);
            StreamReader reader = new StreamReader(stream);
            return await reader.ReadToEndAsync();
        }

        public static string SyncPost(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            Stream stream = SyncRequestStream(RequestMethod.POST, url, data, headers);
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
        }

        public async static Task<string> Post(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            Stream stream = await RequestStream(RequestMethod.POST, url, data, headers);
            StreamReader reader = new StreamReader(stream);
            return await reader.ReadToEndAsync();
        }

        public static Stream SyncPostStream(string url, Dictionary<string, string> headers = null)
        {
            return SyncRequestStream(RequestMethod.POST, url, null, headers);
        }

        public async static Task<Stream> PostStream(string url, Dictionary<string, string> headers = null)
        {
            return await RequestStream(RequestMethod.POST, url, null, headers);
        }

        public static Stream SyncPostStream(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);

            }

            return SyncRequestStream(RequestMethod.POST, url, bdata, headers);
        }

        public async static Task<Stream> PostStream(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);
            }

            return await RequestStream(RequestMethod.POST, url, bdata, headers);
        }

        public static Stream SyncPostStream(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            return SyncRequestStream(RequestMethod.POST, url, data, headers);
        }

        public async static Task<Stream> PostStream(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            return await RequestStream(RequestMethod.POST, url, data, headers);
        }

        #endregion

        #region PUT

        public static String SyncPut(string url, Dictionary<string, string> headers = null)
        {
            Stream stream = SyncRequestStream(RequestMethod.PUT, url, null, headers);
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
        }

        public async static Task<string> Put(string url, Dictionary<string, string> headers = null)
        {
            Stream stream = await RequestStream(RequestMethod.PUT, url, null, headers);
            StreamReader reader = new StreamReader(stream);
            return await reader.ReadToEndAsync();
        }

        public static string SyncPut(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);

            }
            Stream stream = SyncRequestStream(RequestMethod.PUT, url, bdata, headers);
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
        }

        public async static Task<string> Put(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);

            }
            Stream stream = await RequestStream(RequestMethod.PUT, url, bdata, headers);
            StreamReader reader = new StreamReader(stream);
            return await reader.ReadToEndAsync();
        }

        public static string SyncPut(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            Stream stream = SyncRequestStream(RequestMethod.PUT, url, data, headers);
            StreamReader reader = new StreamReader(stream);
            return reader.ReadToEnd();
        }

        public async static Task<string> Put(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            Stream stream = await RequestStream(RequestMethod.PUT, url, data, headers);
            StreamReader reader = new StreamReader(stream);
            return await reader.ReadToEndAsync();
        }

        public static Stream SyncPutStream(string url, Dictionary<string, string> headers = null)
        {
            return SyncRequestStream(RequestMethod.PUT, url, null, headers);
        }

        public async static Task<Stream> PutStream(string url, Dictionary<string, string> headers = null)
        {
            return await RequestStream(RequestMethod.PUT, url, null, headers);
        }

        public static Stream SyncPutStream(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);

            }

            return SyncRequestStream(RequestMethod.PUT, url, bdata, headers);
        }

        public async static Task<Stream> PutStream(string url, string data, System.Text.Encoding encoding, Dictionary<string, string> headers = null)
        {
            byte[] bdata = null;
            if (!string.IsNullOrEmpty(data))
            {
                if (encoding == null)
                {
                    encoding = System.Text.Encoding.UTF8;
                }
                bdata = encoding.GetBytes(data);
            }

            return await RequestStream(RequestMethod.PUT, url, bdata, headers);
        }

        public static Stream SyncPutStream(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            return SyncRequestStream(RequestMethod.PUT, url, data, headers);
        }

        public async static Task<Stream> PutStream(string url, byte[] data, Dictionary<string, string> headers = null)
        {
            return await RequestStream(RequestMethod.PUT, url, data, headers);
        }

        #endregion

        #region DELETE
        public static string SyncDelete(string url, Dictionary<string, string> headers = null)
        {
            Stream content = SyncRequestStream(RequestMethod.DELETE, url, null, headers);

            StreamReader reader = new StreamReader(content);
            return reader.ReadToEnd();
        }

        public async static Task<string> Delete(string url, Dictionary<string, string> headers = null)
        {
            Stream content = await RequestStream(RequestMethod.DELETE, url, null, headers);

            StreamReader reader = new StreamReader(content);
            return await reader.ReadToEndAsync();
        }

        public static Stream SyncDeleteStream(string url, Dictionary<string, string> headers = null)
        {
            return SyncRequestStream(RequestMethod.DELETE, url, null, headers);
        }

        public async static Task<Stream> DeleteStream(string url, Dictionary<string, string> headers = null)
        {
            return await RequestStream(RequestMethod.DELETE, url, null, headers);
        }

        public static Stream SyncDeleteStream(string url, string data, Dictionary<string, string> headers = null)
        {
            if (!string.IsNullOrEmpty(data))
            {
                if (url.IndexOf("?") > 0)
                {
                    url += "&" + data;
                }
                else
                {
                    url += "?" + data;
                }
            }
            return SyncRequestStream(RequestMethod.DELETE, url, null, headers);
        }

        public async static Task<Stream> DeleteStream(string url, string data, Dictionary<string, string> headers = null)
        {

            if (!string.IsNullOrEmpty(data))
            {
                if (url.IndexOf("?") > 0)
                {
                    url += "&" + data;
                }
                else
                {
                    url += "?" + data;
                }
            }

            return await RequestStream(RequestMethod.DELETE, url, null, headers);
        }
        #endregion

        //Accept	        由 Accept 属性设置。
        //Connection	    由 Connection 属性和 KeepAlive 属性设置。
        //Content-Length	由 ContentLength 属性设置。
        //Content-Type	    由 ContentType 属性设置。
        //Expect	        由 Expect 属性设置。
        //Date	            由 Date 属性设置。
        //If-Modified-Since	由 IfModifiedSince 属性设置。
        //Referer	        由 Referer 属性设置。
        //Transfer-Encoding	由 TransferEncoding 属性设置(SendChunked 属性必须为 true)。
        //User-Agent	    由 UserAgent 属性设置。

        //Host	            由 Host 属性设置。
        //Range	            由 AddRange 方法设置。
        private static Dictionary<string, Action<HttpWebRequest,string>> HeaderConfile = new Dictionary<string, Action<HttpWebRequest, string>>(ZTImage.Text.IgnoreCaseComparer.Default) {
            { "Accept",(request,value)=>{ request.Accept=value; } },
            { "Connection",(request,value)=>{ request.Connection=value; } },
            { "Content-Length",(request,value)=>{
                Int64 val=TypeConverter.StringToLong(value,0);
                request.ContentLength=val;
            } },
            { "Content-Type",(request,value)=>{ request.ContentType=value; } },
            { "Expect",(request,value)=>{ request.Expect=value; } },
            { "Date",(request,value)=>{
                DateTime dt=TypeConverter.StringToDate(value,DateTime.Now);
                request.Date=dt;
            } },
            { "If-Modified-Since",(request,value)=>{
                DateTime dt=TypeConverter.StringToDate(value,DateTime.Now);
                request.IfModifiedSince=dt;
            } },
            { "Referer",(request,value)=>{ request.Referer=value; } },
            { "Transfer-Encoding",(request,value)=>{ request.TransferEncoding=value; } },
            { "User-Agent",(request,value)=>{ request.UserAgent=value; } },
            { "Host",(request,value)=>{ request.Host=value; } },
            { "Range",(request,value)=>{
                //bytes=0-100
                if(value.Length<9)
                {
                    return;
                }
                if(value[0]!='b'||value[1]!='y'||value[2]!='t'||value[3]!='e'||value[4]!='s'||value[5]!='=')
                {
                    return;
                }
                string[] vals=value.Substring(6).Split(new char[]{ '-'},StringSplitOptions.RemoveEmptyEntries);
                if(vals.Length!=2)
                {
                    return;
                }
                int from=TypeConverter.StringToInt(vals[0],0);
                int to=TypeConverter.StringToInt(vals[1],0);
                request.AddRange(from,to);
            } },
        };

        private static void AddHeaders(HttpWebRequest request, Dictionary<string, string> headers)
        {
            if (request == null)
            {
                return;
            }
            if (headers == null || headers.Count <= 0)
            {
                return;
            }
            if (request.Headers == null)
            {
                request.Headers = new WebHeaderCollection();
            }

            foreach (var item in headers)
            {
                if (HeaderConfile.ContainsKey(item.Key))
                {
                    HeaderConfile[item.Key](request, item.Value);
                    continue;
                }

                request.Headers.Add(item.Key, item.Value);
            }
        }

        private static Stream SyncRequestStream(RequestMethod method,string url, byte[] data, Dictionary<string, string> headers = null)
        {
            try
            {
                HttpWebRequest request = CreateRequest(method, url, headers);
                if (data != null && data.Length > 0)
                {
                    Stream requestStream = request.GetRequestStream();
                    BinaryWriter writer = new BinaryWriter(requestStream);
                    writer.Write(data);
                    writer.Flush();
                }

                WebResponse wrep = request.GetResponse();
                HttpWebResponse hwerep = wrep as HttpWebResponse;
                if (hwerep.StatusCode == HttpStatusCode.OK)
                {
                    return hwerep.GetResponseStream();
                }
                else
                {
                    return Stream.Null;
                }
            }
            catch(Exception ex)
            {
                ZTImage.Log.Trace.Error("网络请求失败", ex);
                return Stream.Null;
            }
        }

        /// <summary>
        /// 异步创建请求流
        /// </summary>
        /// <param name="method"></param>
        /// <param name="url"></param>
        /// <param name="data"></param>
        /// <param name="headers"></param>
        /// <returns></returns>
        private async static Task<Stream> RequestStream(RequestMethod method,string url, byte[] data, Dictionary<string, string> headers = null)
        {
            try
            {

                HttpWebRequest request = CreateRequest(method, url, headers);
                if (data != null && data.Length > 0)
                {
                    Stream requestStream = await request.GetRequestStreamAsync();
                    BinaryWriter writer = new BinaryWriter(requestStream);
                    writer.Write(data);
                    writer.Flush();
                }

                WebResponse wrep = await request.GetResponseAsync();

                HttpWebResponse hwerep = wrep as HttpWebResponse;
                if (hwerep.StatusCode == HttpStatusCode.OK)
                {
                    return hwerep.GetResponseStream();
                }
                else
                {
                    return Stream.Null;
                }
            }
            catch(Exception ex)
            {
                ZTImage.Log.Trace.Error("异步网络请求失败", ex);
                return Stream.Null;
            }
        }

        /// <summary>
        /// 同步创建请求
        /// </summary>
        /// <param name="method"></param>
        /// <param name="url"></param>
        /// <param name="headers"></param>
        /// <returns></returns>
        private static HttpWebRequest CreateRequest(RequestMethod method,string url,Dictionary<string,string> headers)
        {
            HttpWebRequest request = WebRequest.CreateHttp(url);
            switch (method)
            {
                case RequestMethod.POST:
                    request.Method = "POST";
                    break;
                case RequestMethod.GET:
                    request.Method = "GET";
                    break;
                case RequestMethod.DELETE:
                    request.Method = "DELETE";
                    break;
                case RequestMethod.PUT:
                    request.Method = "PUT";
                    break;
            }

            AddHeaders(request, headers);
            return request;
        }

    }
}


text:
package com.twitter.hraven;

import java.text.SimpleDateFormat;
import java.util.TimeZone;
import org.apache.hadoop.hbase.util.Bytes;

/**
 */
public class Constants {

  public static final String PROJECT_NAME = "hraven";

  // HBase constants

  // separator character used between key components
  public static final char SEP_CHAR = '!';
  public static final String SEP = "" + SEP_CHAR;
  public static final byte[] SEP_BYTES = Bytes.toBytes(SEP);

  // common default values
  public static final byte[] EMPTY_BYTES = new byte[0];
  public static final byte[] ZERO_INT_BYTES = Bytes.toBytes(0);
  public static final byte[] ZERO_LONG_BYTES = Bytes.toBytes(0L);
  public static final byte[] ZERO_SINGLE_BYTE = new byte[]{ 0 };

  public static final String UNKNOWN = "";

  public static boolean IS_DEV = false;
  public static String PREFIX = IS_DEV ? "dev." : "";

  /* **** Table names **** */
  public static String HISTORY_TABLE = PREFIX + "job_history";
  public static byte[] HISTORY_TABLE_BYTES = Bytes.toBytes(HISTORY_TABLE);

  public static String HISTORY_TASK_TABLE = HISTORY_TABLE + "_task";
  public static byte[] HISTORY_TASK_TABLE_BYTES = Bytes
      .toBytes(HISTORY_TASK_TABLE);

  public static String HISTORY_BY_JOBID_TABLE = HISTORY_TABLE + "-by_jobId";
  public static byte[] HISTORY_BY_JOBID_TABLE_BYTES = Bytes
      .toBytes(HISTORY_BY_JOBID_TABLE);

  public static String HISTORY_APP_VERSION_TABLE = HISTORY_TABLE
      + "_app_version";
  public static byte[] HISTORY_APP_VERSION_TABLE_BYTES = Bytes
      .toBytes(HISTORY_APP_VERSION_TABLE);

  public static String HISTORY_RAW_TABLE = HISTORY_TABLE + "_raw";
  public static byte[] HISTORY_RAW_TABLE_BYTES = Bytes
      .toBytes(HISTORY_RAW_TABLE);

  public static final String JOB_FILE_PROCESS_TABLE = PREFIX
      + "job_history_process";
  public static final byte[] JOB_FILE_PROCESS_TABLE_BYTES = Bytes
      .toBytes(JOB_FILE_PROCESS_TABLE);

  public static final String FLOW_QUEUE_TABLE = PREFIX + "flow_queue";
  public static final byte[] FLOW_QUEUE_TABLE_BYTES = Bytes.toBytes(FLOW_QUEUE_TABLE);

  public static final String FLOW_EVENT_TABLE = PREFIX + "flow_event";
  public static final byte[] FLOW_EVENT_TABLE_BYTES = Bytes.toBytes(FLOW_EVENT_TABLE);

  public static final String INFO_FAM = "i";
  public static final byte[] INFO_FAM_BYTES = Bytes.toBytes(INFO_FAM);

  public static final String RAW_FAM = "r";
  public static final byte[] RAW_FAM_BYTES = Bytes.toBytes(RAW_FAM);

  /** Column qualifier prefix to namespace job configuration properties */
  public static final String JOB_CONF_COLUMN_PREFIX = "c";
  public static byte[] JOB_CONF_COLUMN_PREFIX_BYTES = Bytes
      .toBytes(JOB_CONF_COLUMN_PREFIX);

  /** Column qualifier prefix to namespace counter data */
  public static final String COUNTER_COLUMN_PREFIX = "g";
  public static final byte[] COUNTER_COLUMN_PREFIX_BYTES = Bytes
      .toBytes(COUNTER_COLUMN_PREFIX);

  /** Column qualifier prefix to namespace map-specific counter data */
  public static final String MAP_COUNTER_COLUMN_PREFIX = "gm";
  public static final byte[] MAP_COUNTER_COLUMN_PREFIX_BYTES = Bytes
      .toBytes(MAP_COUNTER_COLUMN_PREFIX);

  /** Column qualifier prefix to namespace reduce-specific counter data */
  public static final String REDUCE_COUNTER_COLUMN_PREFIX = "gr";
  public static final byte[] REDUCE_COUNTER_COLUMN_PREFIX_BYTES = Bytes
      .toBytes(REDUCE_COUNTER_COLUMN_PREFIX);

  public static final String JOBCONF_COL = "jobconf";
  public static final byte[] JOBCONF_COL_BYTES = Bytes.toBytes(JOBCONF_COL);

  public static final String JOBCONF_LAST_MODIFIED_COL = JOBCONF_COL
      + "_last_modified";
  public static final byte[] JOBCONF_LAST_MODIFIED_COL_BYTES = Bytes
      .toBytes(JOBCONF_LAST_MODIFIED_COL);

  public static final String JOBCONF_FILENAME_COL = JOBCONF_COL + "_filename";
  public static final byte[] JOBCONF_FILENAME_COL_BYTES = Bytes
      .toBytes(JOBCONF_FILENAME_COL);

  public static final String JOBHISTORY_COL = "jobhistory";
  public static final byte[] JOBHISTORY_COL_BYTES = Bytes
      .toBytes(JOBHISTORY_COL);

  public static final String JOBHISTORY_LAST_MODIFIED_COL = JOBHISTORY_COL
      + "_last_modified";
  public static final byte[] JOBHISTORY_LAST_MODIFIED_COL_BYTES = Bytes
      .toBytes(JOBHISTORY_LAST_MODIFIED_COL);

  public static final String JOBHISTORY_FILENAME_COL = JOBHISTORY_COL
      + "_filename";
  public static final byte[] JOBHISTORY_FILENAME_COL_BYTES = Bytes
      .toBytes(JOBHISTORY_FILENAME_COL);

  /** Column qualifer used to flag job_history_raw records for reprocessing */
  public static final String RAW_COL_REPROCESS = "reprocess";
  public static final byte[] RAW_COL_REPROCESS_BYTES = Bytes.toBytes(RAW_COL_REPROCESS);

  public static final String SUBMIT_TIME_COL = "submit_time";
  public static final byte[] SUBMIT_TIME_COL_BYTES = Bytes.toBytes(SUBMIT_TIME_COL);

  public static final String ROWKEY_COL = "rowkey";
  public static final byte[] ROWKEY_COL_BYTES = Bytes.toBytes(ROWKEY_COL);

  public static final String RECORD_TYPE_COL = "rec_type";
  public static final byte[] RECORD_TYPE_COL_BYTES = Bytes
      .toBytes(RECORD_TYPE_COL);

  public static final String MIN_MOD_TIME_MILLIS_COLUMN = "min_mod_millis";
  public static final byte[] MIN_MOD_TIME_MILLIS_COLUMN_BYTES = Bytes
      .toBytes(MIN_MOD_TIME_MILLIS_COLUMN);

  public static final String PROCESSED_JOB_FILES_COLUMN = "processed_job_files";
  public static final byte[] PROCESSED_JOB_FILES_COLUMN_BYTES = Bytes
      .toBytes(PROCESSED_JOB_FILES_COLUMN);

  public static final String PROCESS_FILE_COLUMN = "processing_directory";
  public static final byte[] PROCESS_FILE_COLUMN_BYTES = Bytes
      .toBytes(PROCESS_FILE_COLUMN);

  public static final String PROCESSING_STATE_COLUMN = "processing_state";
  public static final byte[] PROCESSING_STATE_COLUMN_BYTES = Bytes
      .toBytes(PROCESSING_STATE_COLUMN);

  public static final String VERSION_COLUMN = "version";
  public static final byte[] VERSION_COLUMN_BYTES = Bytes
      .toBytes(VERSION_COLUMN);

  public static final String FRAMEWORK_COLUMN = "framework";
  public static final byte[] FRAMEWORK_COLUMN_BYTES = Bytes
      .toBytes(FRAMEWORK_COLUMN);

  public static final String MIN_JOB_ID_COLUMN = "min_jobid";
  public static final byte[] MIN_JOB_ID_COLUMN_BYTES = Bytes
      .toBytes(MIN_JOB_ID_COLUMN);

  public static final String MAX_JOB_ID_COLUMN = "max_jobid";
  public static final byte[] MAX_JOB_ID_COLUMN_BYTES = Bytes
      .toBytes(MAX_JOB_ID_COLUMN);

  // job details related counter stats
  public static final String FILESYSTEM_COUNTERS = "FileSystemCounters";
  public static final String FILES_BYTES_READ = "FILE_BYTES_READ";
  public static final String FILES_BYTES_WRITTEN = "FILE_BYTES_WRITTEN";
  public static final String HDFS_BYTES_READ = "HDFS_BYTES_READ";
  public static final String HDFS_BYTES_WRITTEN = "HDFS_BYTES_WRITTEN";
  /* TODO: update for 2.0.3+, this class is now deprecated */
  public static final String JOBINPROGRESS_COUNTER = "org.apache.hadoop.mapred.JobInProgress$Counter";
  /* TODO: update for 2.0.3+, this class is now deprecated */
  public static final String TASK_COUNTER = "org.apache.hadoop.mapred.Task$Counter";
  public static final String SLOTS_MILLIS_MAPS  = "SLOTS_MILLIS_MAPS";
  public static final String SLOTS_MILLIS_REDUCES = "SLOTS_MILLIS_REDUCES";
  public static final String REDUCE_SHUFFLE_BYTES = "REDUCE_SHUFFLE_BYTES";

  /** MB MILLIS counters in hadoop2 */
  public static final String MB_MILLIS_MAPS  = "MB_MILLIS_MAPS";
  public static final String MB_MILLIS_REDUCES = "MB_MILLIS_REDUCES";

  /** used to indicate how expensive a job is in terms of memory and time taken*/
  public static final String MEGABYTEMILLIS = "megabytemillis" ;
  public static final byte[] MEGABYTEMILLIS_BYTES = Bytes.toBytes(MEGABYTEMILLIS);

  /** use this value to indicate fields that were not found */
  public static final Long NOTFOUND_VALUE = -1L;

  // job details related counter sub group in hadoop 2
  public static final String FILESYSTEM_COUNTER_HADOOP2 = "org.apache.hadoop.mapreduce.FileSystemCounter";
  public static final String JOB_COUNTER_HADOOP2 = "org.apache.hadoop.mapreduce.JobCounter";
  public static final String TASK_COUNTER_HADOOP2 = "org.apache.hadoop.mapreduce.TaskCounter";

  /**
   * Indicator whether a job has been processed successfully from the RAW table
   * to the history and index tables. Used to skip this job from the RAW table
   * for the next set of jobs to process.
   */
  public static final String JOB_PROCESSED_SUCCESS_COL = "job_processed_success";
  public static final byte[] JOB_PROCESSED_SUCCESS_COL_BYTES = Bytes
      .toBytes(JOB_PROCESSED_SUCCESS_COL);

  /**
   * The string preceding the job submit time in an hadoop1 job history file.
   */
  public static final String SUBMIT_TIME_PREFIX = "SUBMIT_TIME=\"";

  /**
   * Raw bytes representation of {@link #SUBMIT_TIME_PREFIX};
   */
  public static final byte[] SUBMIT_TIME_PREFIX_BYTES = Bytes
      .toBytes(SUBMIT_TIME_PREFIX);

  /**
   * The string representing the job submit event in a hadoop2 job history file.
   */
  public static final String JOB_SUBMIT_EVENT = "{\"type\":\"JOB_SUBMITTED";

  /**
   * Raw bytes representation of {@link #JOB_SUBMIT_EVENT};
   */
  public static final byte[] JOB_SUBMIT_EVENT_BYTES = Bytes
      .toBytes(JOB_SUBMIT_EVENT);

  /**
   * The string representing the submit time in a hadoop2 job history file.
   */
  public static final String SUBMIT_TIME_PREFIX_HADOOP2 = "\"submitTime\":";

  /**
   * Raw bytes representation of {@link #SUBMIT_TIME_PREFIX_HADOOP2};
   */
  public static final byte[] SUBMIT_TIME_PREFIX_HADOOP2_BYTES = Bytes
      .toBytes(SUBMIT_TIME_PREFIX_HADOOP2);

  /**
   * length of string that contains a unix timestamp in milliseconds
   * this length will be correct till Sat, 20 Nov 2286 which is
   * 9999999999999 in epoch time
   */
  public static final int EPOCH_TIMESTAMP_STRING_LENGTH = 13;

  /**
   * an approximation for job run time in milliseconds
   *
   * used in estimating job start time
   * when the submit time for a job can't be figured out
   * https://github.com/twitter/hraven/issues/67
   */
  public static final int AVERGAE_JOB_DURATION = 3600000;

  public static final String QUOTE = "\"";
  public static final byte[] QUOTE_BYTES = Bytes.toBytes(QUOTE);

  /**
   * The maximum length of a radix 10 string representing a long.
   */
  public static final int MAX_LONG_LENGTH = Long.toString(Long.MAX_VALUE)
      .length();

  public static final String USER_CONF_KEY = "user.name";
  public static final String USER_CONF_KEY_HADOOP2 = "mapreduce.job.user.name";

  /**
   *  use this config setting to define an
   *  hadoop-version-independent property for queuename
   */
  public static final String HRAVEN_QUEUE = "queue";

  /** raw bytes representation of the queue parameter */
  public static final byte[] HRAVEN_QUEUE_BYTES = Bytes.toBytes(HRAVEN_QUEUE);

  /**
   * following are different config parameters that are in use
   * to define a queue for a job
   */
  public static final String QUEUENAME_HADOOP2 = "mapreduce.job.queuename";
  public static final String FAIR_SCHEDULER_POOLNAME_HADOOP1 = "mapred.fairscheduler.pool";
  public static final String CAPACITY_SCHEDULER_QUEUENAME_HADOOP1 = "mapred.job.queue.name";

  /**
   *  use this when queue name cannot be determined, for example in FIFO scheduler
   */
  public static final String DEFAULT_QUEUENAME = "DEFAULT_QUEUE";

  /**
   * this setting is a resultant of a bug in hadoop2
   * there should not exist a value of a string "default" for queuename
   * it should always default to the user name
   */
  public static final String DEFAULT_VALUE_QUEUENAME = "default";

  public static final String JOB_NAME_CONF_KEY = "mapred.job.name";
  public static final String JOB_NAME_HADOOP2_CONF_KEY = "mapreduce.job.name";

  public static final String PIG_CONF_KEY = "pig.version"; // used to detect a
                                                           // pig job
  public static final String APP_NAME_CONF_KEY = "batch.desc";

  /**
   * Added as part of PIG-2587
   */
  public static final String PIG_VERSION_CONF_KEY = "pig.logical.plan.signature";
  public static final String PIG_RUN_CONF_KEY = "pig.script.submitted.timestamp";
  public static final String PIG_LOG_FILE_CONF_KEY = "pig.logfile";

  public static final String CASCADING_FLOW_ID_CONF_KEY = "cascading.flow.id";

  public static final String CASCADING_APP_NAME_CONF_KEY = "scalding.flow.class.name";
  public static final String CASCADING_VERSION_CONF_KEY = "scalding.flow.class.signature";
  public static final String CASCADING_RUN_CONF_KEY = "scalding.flow.submitted.timestamp";
  public static final String CASCADING_APP_ID_CONF_KEY = "cascading.app.id";

  public static final String MR_RUN_CONF_KEY = "mapred.app.submitted.timestamp";

  /**
   * hadoop2 memory mb for container size
   * for map, reduce and AM containers
   */
  public static final String MAP_MEMORY_MB_CONF_KEY = "mapreduce.map.memory.mb";
  public static final long DEFAULT_MAP_MEMORY_MB = 1024L; //Default hadoop value
  public static final String REDUCE_MEMORY_MB_CONF_KEY = "mapreduce.reduce.memory.mb";
  public static final long DEFAULT_REDUCE_MEMORY_MB = 1024L; //Default hadoop value
  public static final String AM_MEMORY_MB_CONF_KEY = "yarn.app.mapreduce.am.resource.mb";

  /** yarn scheduler min mb is 1G */
  public static final String YARN_SCHEDULER_MIN_MB = "yarn.scheduler.minimum-allocation-mb";
  public static final long DEFAULT_YARN_SCHEDULER_MIN_MB = 1024;

  /**
   * hadoop1 memory conf keys
   */
  public static final String JAVA_CHILD_OPTS_CONF_KEY = "mapred.child.java.opts";
  /** default xmx size is 1 GB as per
   * http://docs.oracle.com/javase/6/docs/technotes/guides/vm/gc-ergonomics.html
   */
  public static final Long DEFAULT_XMX_SETTING = 1024L;
  public static final String DEFAULT_XMX_SETTING_STR = Long.toString(DEFAULT_XMX_SETTING) + "M";

  /**
   * Timestamp format used to create processing directories
   */
  public static final SimpleDateFormat TIMESTAMP_FORMAT = new SimpleDateFormat(
      "yyyyMMddHHmmss");

  // Initialize to use UTC
  static {
    TIMESTAMP_FORMAT.setTimeZone(TimeZone.getTimeZone("UTC"));
  }

  /**
   * Regex to parse a job file name. First back-ref is JT name, second one if
   * job-id
   * <p>
   * For example,
   * cluster-jt.identifier.example.com_1333569494142_job_201204041958_150125_conf
   * .xml
   * Regex should also be able to parse new format of history files since
   * MAPREDUCE-323 ( as packaged in cdh3u5)
   * For example: history filename is
   * job_201306192120_0003_1371677828795_hadoop_word+count
   * and conf file name is
   * job_201306192120_0003_1371677828795_hadoop_conf.xml
   * in hadoop 2.0, job history file names are named as
   * job_1374258111572_0003-1374260622449-userName1-TeraGen-1374260635219-2-0-SUCCEEDED-default.jhist
   */
  public static final String JOB_FILENAME_PATTERN_REGEX = ".*(job_[0-9]*_[0-9]*)(-|_)([0-9]*[aA-zZ]*)*(.*)$";

  // JobHistory file name parsing related
  public static final String JOB_CONF_FILE_END = "(.*)(conf.xml)$";

  /**
   * Regex to parse pig logfile name such as
   * "/var/log/pig/pig_1334818693838.log"
   */
  public static final String PIG_LOGFILE_PATTERN_REGEX = "^.*pig_([0-9]*).log$";

  /**
   * Used for legacy jobs that don't have batch.desc set. Should convert from
   * something like this:
   * PigLatin:daily_job:daily_2012/06/22-00:00:00_to_2012/06/23-00:00:00 top this:
   * PigJobDescFactory.SCHEDULED_PREFIX + "daily_job:daily"
   */
  public static final String PIG_SCHEDULED_JOBNAME_PATTERN_REGEX = "^PigLatin:([^:]*(:.*?)+)_([0-9]{4})/.*";

  /**
   * Used to pass the cluster name from the tool to the RecordReader.
   */
  public static final String CLUSTER_JOB_CONF_KEY = "jobhistory.cluster";

  /**
   * Used to pass boolean to mappers to indicate that items are to be reprocessed.
   */
  public static final String FORCE_REPROCESS_CONF_KEY = "force.reprocess";

  /** milliseconds in 1 day */
  public static final long MILLIS_ONE_DAY = 86400000L;

  /**
   * number of milli seconds in 30 days
   */
  public static final long THIRTY_DAYS_MILLIS = MILLIS_ONE_DAY * 30L;

  /** used to indicate the cost of a job is in terms of currency units */
  public static final String JOBCOST = "jobcost" ;

  public static final byte[] JOBCOST_BYTES = Bytes.toBytes(JOBCOST);

  /** hdfs location where the properties file is placed */
  public static final String COST_PROPERTIES_HDFS_DIR = "/user/hadoop/hraven/conf/";

  /** Cost properties file name */
  public static final String COST_PROPERTIES_FILENAME = "hRavenCostDetails.properties";

  /** name of the type of machine the job ran on */
  public static final String HRAVEN_MACHINE_TYPE = "hraven.machinetype.name";

  /** name of the properties file used for cluster to cluster identifier mapping */
  public static final String HRAVEN_CLUSTER_PROPERTIES_FILENAME = "hRavenClusters.properties";
}


text:
package liquibase.resource;

import liquibase.util.StringUtils;

import java.io.IOException;
import java.io.InputStream;
import java.util.*;

/**
 * A {@link liquibase.resource.ResourceAccessor} that will search in a list of other ResourceAccessors until it finds
 * one that has a resource of the appropriate name and path.
 */
public class CompositeResourceAccessor implements ResourceAccessor {

    private List<ResourceAccessor> resourceAccessors;

    public CompositeResourceAccessor(List<ResourceAccessor> resourceAccessors) {
        this.resourceAccessors = resourceAccessors;
    }

    public CompositeResourceAccessor(ResourceAccessor... resourceAccessors) {
        this.resourceAccessors = Arrays.asList(resourceAccessors);
    }

    @Override
    public Set<InputStream> getResourcesAsStream(String path) throws IOException {
        for (ResourceAccessor accessor : resourceAccessors) {
            Set<InputStream> returnSet = accessor.getResourcesAsStream(path);
            if (returnSet != null && returnSet.size() > 0) {
                return returnSet;
            }
        }
        return null;
    }

    @Override
    public Set<String> list(String relativeTo, String path, boolean includeFiles, boolean includeDirectories, boolean recursive) throws IOException {
        Set<String> returnSet = new HashSet<String>();
        for (ResourceAccessor accessor : resourceAccessors) {
            Set<String> thisSet = accessor.list(relativeTo, path, includeFiles, includeDirectories, recursive);
            if (thisSet != null) {
                returnSet.addAll(thisSet);
            }
        }

        if (returnSet.size() > 0) {
            return returnSet;
        }
        return null;
    }

    @Override
    public ClassLoader toClassLoader() {
        ClassLoader[] loaders=new ClassLoader[resourceAccessors.size()];
        int i=0;
        for (ResourceAccessor fo: resourceAccessors) {
           loaders[i++]=fo.toClassLoader();
        }

        return new CompositeClassLoader(loaders);
    }

    //based on code from http://fisheye.codehaus.org/browse/xstream/trunk/xstream/src/java/com/thoughtworks/xstream/core/util/CompositeClassLoader.java?r=root
    private static class CompositeClassLoader extends ClassLoader {

        private final List<ClassLoader> classLoaders = new ArrayList<ClassLoader>();

        public CompositeClassLoader(ClassLoader... classLoaders) {
            this.classLoaders.addAll(Arrays.asList(classLoaders));
        }

        @Override
        public Class loadClass(String name,boolean resolve) throws ClassNotFoundException {
            for (Object classLoader1 : classLoaders) {
                ClassLoader classLoader = (ClassLoader) classLoader1;
                try {
                    Class classe=classLoader.loadClass(name);
                    if(resolve)
                        resolveClass(classe);
                    return classe;
                } catch (ClassNotFoundException notFound) {
                    // ok.. try another one
                }
            }

            // One last try - the context class loader associated with the current thread. Often used in j2ee servers.
            // Note: The contextClassLoader cannot be added to the classLoaders list up front as the thread that constructs
            // liquibase is potentially different to thread that uses it.
            ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
            if (contextClassLoader != null) {
                Class classe=contextClassLoader.loadClass(name);
                if(resolve)
                    resolveClass(classe);
                return classe;
            } else {
                throw new ClassNotFoundException(name);
            }

        }

 	}

    @Override
    public String toString() {
        List<String> openerStrings = new ArrayList<String>();
        for (ResourceAccessor opener : resourceAccessors) {
            openerStrings.add(opener.toString());
        }
        return getClass().getName()+"("+StringUtils.join(openerStrings,",")+")";
    }
}


text:
if (typeof Meteor.settings === 'undefined')
  Meteor.settings = {};

_.defaults(Meteor.settings, {
  appglu:{
    auth: "WKD4N7YMA1uiM8V:DtdTtzMLQlA0hk2C1Yi5pLyVIlAQ68",
    headers: { "content-type" : "application/json", "X-AppGlu-Environment" : "staging" },
    //findRoutesUrl: "https://api.appglu.com/v1/queries/findRoutesByStopName/run",
    //findStopsUrl: "https://api.appglu.com/v1/queries/findStopsByRouteId/run",
    //findDeparturesUrl: "https://api.appglu.com/v1/queries/findDeparturesByRouteId/run"
  }
});


text:
module.exports = {
    testEnvironment: "jest-environment-jsdom-fifteen",
    globals: {
        crypto: require("crypto")
    },
    coverageReporters: [["lcov", {"projectRoot": "../../"}]]
};


text:
require 'test/unit'
require 'fileutils'
require 'set'
require 'plain_site/site'
include PlainSite

class SiteTest < Test::Unit::TestCase
  FIXTURES_DIR=File.realpath (File.join File.dirname(__FILE__),'fixtures')
  def setup
    @site_root=Dir.mktmpdir 'test-site-'
  end
  def teardown
    FileUtils.rm_rf @site_root
  end

  def test_diff_build
    site=Site.new @site_root
    site.init_scaffold true

    to_del_post=site.newpost 'essays/git-delete-test1','Git Test 1'
    to_mod_post=site.newpost 'essays/git-mod-test2','Git Test 2'
    includes=[]
    includes.push (site.newpost 'essays/include-test1','Include Test')
    includes.push (site.newpost 'essays/include-test2','Include Test')
    includes.push (site.newpost 'essays/include-test3','Include Test')

    `(cd #{@site_root};
    git init;
    git add .;
    git commit -m Init;)`

    FileUtils.rm to_del_post
    File.open(to_mod_post,'wb') {|f| f.write "---\ntitle: Modified\n---\n Modified!"}
    new_post=site.newpost 'essays/git-untracked','Git Test Untracked'

    added_template=File.join site.templates_path,'test.html'
    File.open(added_template,'wb') {|f| f.write 'TEST Template'}
    `(cd #{@site_root};
    git add #{added_template});`

    files=site.diff_files includes

    assert [to_mod_post,new_post].to_set <= files[:updated_posts].to_set ,"Should include new and modified posts"
    assert files[:has_deleted_posts], "Should had deleted posts"

    assert (files[:updated_templates].include? added_template), "Should include added template"

    assert includes.to_set <= files[:updated_posts].to_set ,"Should force include includes-posts"

    site.build(all:true)

  end

  def test_build
    site=Site.new @site_root
    site.init_scaffold true

    site.data.subs.each do |cat|
      20.times do |i|
        name="2014-#{rand 1..12}-#{rand 1..28 }-hello-post#{i}.md"
        path=File.join cat.path,name
        File.open(path,'wb') do |f|
          s= <<-CONTENT
---
title: Hello,post#{i}
---

**Content here!**

Category: <a href="<%=URI.join site.url,"#{cat.data_id}"%>">#{cat.display_name}

<highlight python>
def hello(name):
  print "Hello,%s" % name

if __name__=='__main__':
  hello("World!")
</highlight>
CONTENT
          f.write s
        end
      end
    end

    site.build(dest:@site_root,local:true)
    #puts "\n#{@site_root}\n"
    #site.serve
  end
end


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html" charset="ISO-8859-1">
<title>Uses of Class com.gsma.android.utils.PhoneState</title>
<meta name="date" content="2014-10-03">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Class
com.gsma.android.utils.PhoneState

Packages that use PhoneState

Package
Description

com.gsma.android.utils

Uses of PhoneState in com.gsma.android.utils

Methods in com.gsma.android.utils that return PhoneState

Modifier and Type
Method and Description

static PhoneState
PhoneUtils.getPhoneState(android.telephony.TelephonyManager telephonyMgr,
             android.net.ConnectivityManager connectivityMgr)

Convert information which can be obtained from the Android OS into
 PhoneState information necessary for discovery

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes


text:
<?php

namespace Application\Controllers;

class Information extends BaseController
{
    public function infos()
    {
        # not installed ?
        if (!$this->isInstalled()) {
            return $this->redirectToRoute('installation');
        }
        elseif (!$this->isUpToDate()) {
            return $this->redirectToRoute('update');
        }

        return $this->render('Information', [
            'apacheVersion' => $this->app['informations']->getApacheVersion(),
            'mysqlVersion' => $this->app['informations']->getMysqlVersion(),
            'wampserverVersion' => $this->app['informations']->getWampserverVersion(),
            'phpVersion' => $this->app['informations']->getPhpVersion(),
            'phpVersion' => $this->app['informations']->getPhpVersion(),
            'phpExtensions' => $this->app['informations']->getPhpExtensions()
        ]);
    }
}


text:
package org.intellij.lang.xpath;

public class XPath2ParsingTest extends TestBase {

  public void testComments() throws Throwable {
    doXPathHighlighting();
  }

  public void testNodeComp() throws Throwable {
    doXPathHighlighting();
  }

  public void testNewOps() throws Throwable {
    doXPathHighlighting();
  }

  public void testSequence() throws Throwable {
    doXPathHighlighting();
  }

  public void testEmptySequence() throws Throwable {
    doXPathHighlighting();
  }

  public void testRange() throws Throwable {
    doXPathHighlighting();
  }

  public void testIfThenElse() throws Throwable {
    doXPathHighlighting();
  }

  public void testIfThenElseMissing() throws Throwable {
    doXPathHighlighting();
  }

  public void testForLoop() throws Throwable {
    doXPathHighlighting();
  }

  public void testSomeEvery() throws Throwable {
    doXPathHighlighting();
  }

  public void testTypeExpressions() throws Throwable {
    doXPathHighlighting();
  }

  public void testDoubleLiterals() throws Throwable {
    doXPathHighlighting();
  }

  public void testWildcardNamespace() throws Throwable {
    doXPathHighlighting();
  }

  public void testInvalidWildcard() throws Throwable {
    doXPathHighlighting();
  }

  public void testMissingInstanceOfType() throws Throwable {
    doXPathHighlighting();
  }

  public void testMissingSatisfiesExpression() throws Throwable {
    doXPathHighlighting();
  }

  public void testValidTypeOccurrenceIndicators() throws Throwable {
    doXPathHighlighting();
  }

  public void testInvalidTypeOccurrenceIndicator1() throws Throwable {
    doXPathHighlighting();
  }

  public void testInvalidTypeOccurrenceIndicator2() throws Throwable {
    doXPathHighlighting();
  }

  public void testNonKeywords() throws Throwable {
    doXPathHighlighting();
  }

  // IDEA-70681
  public void testCastWithMultiplication() throws Throwable {
    doXPathHighlighting();
  }

  // IDEA-70688
  public void testKindTestWithStar() throws Throwable {
    doXPathHighlighting();
  }

  public void testUnionSubExpression() throws Throwable {
    doXPathHighlighting();
  }

  // IDEA-67413
  private void doXPathHighlighting() throws Throwable {
    final String name = getTestFileName();
    myFixture.testHighlighting(false, false, false, name + ".xpath2");
  }

  @Override
  protected String getSubPath() {
    return "xpath2/parsing";
  }
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>../src/easynode/framework/server/AbstractServer.js - EasyNode API参考文档</title>
    <link rel="stylesheet" href="http://yui.yahooapis.com/3.9.1/build/cssgrids/cssgrids-min.css">
    <link rel="stylesheet" href="../assets/vendor/prettify/prettify-min.css">
    <link rel="stylesheet" href="../assets/css/main.css" id="site_styles">
    <link rel="icon" href="../assets/favicon.ico">

            API Docs for: EasyNode - 0.1.0

APIs

Classes

Modules

                            <input type="search" id="api-filter" placeholder="Type to filter APIs">

EasyNode

easynode.framework.aop.AOP

easynode.framework.BeanFactory

easynode.framework.cache.CacheStat

easynode.framework.cache.ICache

easynode.framework.cache.Memcached

easynode.framework.cache.Redis

easynode.framework.db.IConnection

easynode.framework.db.IDataSource

easynode.framework.db.MysqlConnection

easynode.framework.db.MysqlDataSource

easynode.framework.Logger

easynode.framework.mq.IQueue

easynode.framework.mq.RedisListQueue

easynode.framework.mq.RedisQueue

easynode.framework.mvc.Action

easynode.framework.mvc.ActionArgConverter

easynode.framework.mvc.ActionContext

easynode.framework.mvc.ActionExecutor

easynode.framework.mvc.ActionFactory

easynode.framework.mvc.ActionRequestParameter

easynode.framework.mvc.ActionResult

easynode.framework.mvc.CombinedAction

easynode.framework.mvc.EJSTemplateViewRenderer

easynode.framework.mvc.IActionContextListener

easynode.framework.mvc.ITemplateViewRenderer

easynode.framework.mvc.JadeTemplateViewRenderer

easynode.framework.mvc.JSONView

easynode.framework.mvc.MethodDispatchedAction

easynode.framework.mvc.Model

easynode.framework.mvc.ModelField

easynode.framework.mvc.ModelProxyActionFactory

easynode.framework.mvc.MustacheTemplateViewRenderer

easynode.framework.mvc.spi.MysqlModelGenerator

easynode.framework.mvc.View

easynode.framework.plugin.EasyNodePlugin

easynode.framework.plugin.PluginLoadContext

easynode.framework.queue.MQTTQueue

easynode.framework.server.AbstractServer

easynode.framework.server.http.KOAActionContext

easynode.framework.server.http.KOADefaultRoutes

easynode.framework.server.http.KOAHttpRequestParameter

easynode.framework.server.http.KOAHttpServer

easynode.framework.server.http.KOAHttpServer.SessionSupport

easynode.framework.server.KOAMemorySessionStorage

easynode.framework.server.ServerStat

easynode.framework.server.tcp.Decoder

easynode.framework.server.tcp.Encoder

easynode.framework.server.tcp.Message

easynode.framework.server.tcp.MessageHandler

easynode.framework.server.tcp.protocols.JSONDecoder

easynode.framework.server.tcp.protocols.JSONEncoder

easynode.framework.server.tcp.protocols.JSONMessageHandler

easynode.framework.server.tcp.StreamDecoderHelper

easynode.framework.server.tcp.StreamEncoderHelper

easynode.framework.server.tcp.TCPClient

easynode.framework.server.tcp.TCPServer

easynode.framework.test.TestCase

easynode.framework.test.TestCaseRunner

easynode.framework.util..StringUtil

easynode.framework.util.Binary

easynode.framework.util.HTTPUtil

easynode.framework.util.MustacheHelper

easynode.framework.util.ObjectWrapper

easynode.framework.util.SqlUtil

easynode.framework.util.VersionComparator

easynode.framework.view.TemplateView

easynode.GenericObject

全局函数

                    Show:

                        <input type="checkbox" id="api-show-inherited" checked>
                        Inherited

                        <input type="checkbox" id="api-show-protected">
                        Protected

                        <input type="checkbox" id="api-show-private">
                        Private

                        <input type="checkbox" id="api-show-deprecated">
                        Deprecated

File: ../src/easynode/framework/server/AbstractServer.js

var assert = require('assert');
var logger = using('easynode.framework.Logger').forFile(__filename);
var GenericObject = using('easynode.GenericObject');

(function () {
        /**
         * 抽象服务类,请不要直接实例化该类,因为它的主要函数都是抽象函数。
         *
         * @class easynode.framework.server.AbstractServer
         * @extends easynode.GenericObject
         * @since 0.1.0
         * @author zlbbq
         * */
        class AbstractServer extends GenericObject {
                /**
                 * 构造函数。
                 *
                 * @method 构造函数
                 * @protected
                 * @param {String} name 服务名称
                 * @param {int} port 服务端口
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                  constructor (port, name = 'no-name') {
                        super();
                        //place code below
                        if (typeof port != 'number' || isNaN(port)) {
                                throw new TypeError('Invalid port number');
                        }

                        var me = this;

                        /**
                         * 服务类型
                         *
                         * @property type
                         * @type String
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.type = 'unknown';

                        /**
                         * 服务端口
                         *
                         * @property port
                         * @type int
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.port = port;

                        /**
                         * 服务名称
                         *
                         * @property name
                         * @type String
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.name = name;

                        /**
                         * 服务ID,从EasyNode官方网站获取,配置项:easynode.app.id
                         *
                         * @property appId
                         * @type String
                         * @default "UNTITLED"
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.appId = EasyNode.config('easynode.app.id', 'UNTITLED');

                        /**
                         * 应用密钥。配置项:easynode.app.key
                         *
                         * @property appKey
                         * @type String
                         * @default "EMPTY"
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.appKey =  EasyNode.config('easynode.app.key', 'EMPTY');

                        /**
                         * 服务是否已经处于启动状态
                         *
                         * @property _started
                         * @type boolean
                         * @private
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        var _started = false;
                        this.on('started', function(){
                                _started = true;
                        });
                        this.on('stop', function(){
                                _started = false;
                        });
                        /**
                         * 获取服务是否已经启动。
                         *
                         * @method isStarted
                         * @return {boolean} 服务是否已经启动
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.isStarted = function() {
                                return _started;
                        };

                        /**
                         * 服务是否处于暂停状态
                         *
                         * @property _paused
                         * @type boolean
                         * @private
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        var _paused = false;
                        this.on('pause', function(){
                                _paused = true;
                        });
                        this.on('resume', function(){
                                _paused = false;
                        });
                        /**
                         * 获取服务是否处于暂停状态
                         *
                         * @method isPausing
                         * @return {boolean} 服务是否处于暂停状态
                         * @since 0.1.0
                         * @author zlbbq
                         * */
                        this.isPausing = function() {
                                return _paused;
                        };
                }

                /**
                 *  设置应用ID和密钥。
                 *
                 * @method setAppInfo
                 * @param {String} appId 应用ID
                 * @param {String} appKey 应用密钥
                 * @since 0.1.0
                 * @author zlbbq
                 **/
                setAppInfo (appId, appKey) {
                        this.appId = appId;
                        this.appKey = appKey;
                }

                getClassName () {
                        return EasyNode.namespace(__filename);
                }

                /**
                 *  设置服务的ActionContext监听器,用于向服务的ActionContext注入Action执行时必要成员。
                 *
                 * @method setActionContextListener
                 * @param {easynode.framework.mvc.IActionContextListener} l ActionContext事件监听器
                 * @abstract
                 * @since 0.1.0
                 * @author zlbbq
                 **/
                setActionContextListener (l) {
                        throw new Error('Abstract Method');
                }

                /**
                 * 设置服务端口。
                 *
                 * @method setPort
                 * @param {int} port 服务端口。
                 * @since 0.1.0
                 * @author zlbbq
                 * @abstract
                 * @async
                 * */
                setPort (port) {
                        assert(typeof port == 'number' && port > 0, 'Invalid port number');
                        assert(!this.isRunning(), 'Can not change port while server running');
                        this.port = port;
                }

                /**
                 * 启动服务。子类实现时,请触发其started事件。
                 *
                 * @method start
                 * @since 0.1.0
                 * @author zlbbq
                 * @abstract
                 * @async
                 * */
                start () {
                        throw new Error('Abstract method');
                }

                /**
                 * 停止服务。停止服务时,服务占用的网络端口将一并释放。子类实现时,请触发stop事件
                 *
                 * @method stop
                 * @abstract
                 * @async
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                stop () {
                        throw new Error('Abstract method');
                }

                /**
                 * 立即暂停服务。与停止服务不同,暂停服务并不释放网络端口资源,也不丢弃网络数据包,仅无响应或响应服务暂停。
                 * 子类实现时,请触发pause事件
                 *
                 * @method pause
                 * @abstract
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                pause () {
                        throw new Error('Abstract method');
                }

                /**
                 * 立即恢复服务,如果服务处于暂停状态。子类实现时,请触发resume事件。
                 *
                 * @method resume
                 * @abstract
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                resume () {
                        throw new Error('Abstract method');
                }

                /**
                 * 统计服务状态。
                 *
                 * @method stat
                 * @abstract
                 * @return {easynode.framework.server.ServerStat} 服务状态描述
                 * @async
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                stat () {
                        throw new Error('Abstract method');
                }

                /**
                 * 获取客户端连接列表。
                 *
                 * @method connections
                 * @abstract
                 * @return {Array} 客户端连接列表,每个客户端连接应至少包含一个token字标用于唯一标识一个客户端连接
                 * @async
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                connections () {
                        throw new Error('Abstract method');
                }

                /**
                 * 向客户端发送消息。
                 *
                 * @method send
                 * @param {Array/String} clientTokens 客户端Token列表,客户端Token可以唯一识别一个客户端。传递Array时,
                 *                                      向多个客户端发送消息
                 * @param {Buffer} msg 消息体
                 * @return {Array} 客户端列表
                 * @abstract
                 * @async
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                send(clientTokens, msg) {
                        throw new Error('Abstract method');
                }

                /**
                 * 向所有客户端广播消息。
                 *
                 * @method broadcast
                 * @param {Buffer} msg 消息体
                 * @return {Array} 客户端列表
                 * @abstract
                 * @async
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                broadcast (msg) {
                        throw new Error('Abstract method');
                }

                /**
                 * 判定服务器是否处于运行状态
                 *
                 * @method isRunning
                 * @return {boolean} 服务是否处于运行状态
                 * @since 0.1.0
                 * @author zlbbq
                 * */
                isRunning () {
                        return this.isStarted() && !this.isPausing();
                }
        }

        /**
         * 服务开始启动前触发。
         *
         * @event before-start
         */
        AbstractServer.EVENT_BEFORE_START = 'before-start';

        /**
         * 服务启动后触发。
         *
         * @event started
         * @param {Error} err 启动时发生的错误,没有错误为null。
         * @param {boolean} result 启动结果,发生错误时为null,否则为true.
         */
        AbstractServer.EVENT_STARTED = 'started';

        /**
         * 服务开始停止前触发。
         *
         * @event before-stop
         */
        AbstractServer.EVENT_BEFORE_STOP = 'before-stop';

        /**
         * 停止后触发。
         *
         * @event stop
         * @param {Error} err 停止时发生的错误,没有错误为null。
         * @param {boolean} result 停止结果,发生错误时为null,否则为true.
         */
        AbstractServer.EVENT_STOP = 'stop';

        /**
         * 服务暂停时触发。
         *
         * @event before-start
         */
        AbstractServer.EVENT_PAUSE = 'pause';

        /**
         * 服务从暂停状态恢复时触发。
         *
         * @event resume
         */
        AbstractServer.EVENT_RESUME = 'resume';

        module.exports = AbstractServer;
})();


text:
#include "mirtk/System.h"
#include "mirtk/Config.h" // WINDOWS
#include "mirtk/Stream.h"

#include <chrono>
#include <ctime>

#ifdef WINDOWS
  #define VC_EXTRALEAN
  #define WIN32_LEAN_AND_MEAN
  #define NOMINMAX
  #include <windows.h>
  #include <Lmcons.h>
#else
  #include <unistd.h>
  #include <sys/types.h>
  #include <pwd.h>
#endif

namespace mirtk {

// -----------------------------------------------------------------------------
static tm localtime(const std::time_t &t)
{
  tm info;
#ifdef WINDOWS
  localtime_s(&info, &t);
#else
  info = *std::localtime(&t);
#endif
  return info;
}

// -----------------------------------------------------------------------------
string GetDate()
{
  typedef std::chrono::system_clock Clock;
  std::time_t now = Clock::to_time_t(Clock::now());
  tm info = localtime(now);
  char date_string[16];
  strftime(date_string, 16, "%d %b %Y", &info);
  return date_string;
}

// -----------------------------------------------------------------------------
string GetTime()
{
  typedef std::chrono::system_clock Clock;
  std::time_t now = Clock::to_time_t(Clock::now());
  tm info = localtime(now);
  char time_string[16];
  strftime(time_string, 16, "%H:%M:%S %Z", &info);
  return time_string;
}

// -----------------------------------------------------------------------------
string GetDateTime()
{
  typedef std::chrono::system_clock Clock;
  std::time_t now = Clock::to_time_t(Clock::now());
  tm info = localtime(now);
  char date_time_string[32];
  strftime(date_time_string, 32, "%c %Z", &info);
  return date_time_string;
}

// -----------------------------------------------------------------------------
string GetUser()
{
#ifdef WINDOWS
  char username[UNLEN+1];
  DWORD username_len = UNLEN+1;
  if (::GetUserName(username, &username_len)) return username;
#else
  const passwd *pw = getpwuid(getuid());
  if (pw) return pw->pw_name;
#endif
  return "";
}

} // namespace mirtk


text:
require 'spec_helper'

describe ProjectAllocation do
  pending "add some examples to (or delete) #{__FILE__}"
end


text:
<!DOCTYPE html>

    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />

    <title>Upgrading Sublime Text</title>
    <meta name="description" content="A beautiful narrative written over an elegant publishing platform. The story begins here..." />

    <meta name="HandheldFriendly" content="True" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />

    <link rel="shortcut icon" href="/assets/images/favicon.ico" >

    <link rel="stylesheet" type="text/css" href="/assets/css/screen.css" />
    <link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather:300,700,700italic,300italic|Open+Sans:700,400" />
    <link rel="stylesheet" type="text/css" href="/assets/css/syntax.css" />

    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.3.0/styles/default.min.css">

        <link rel="canonical" href="http://localhost:4000//sublime-upgrade" />
    <meta name="referrer" content="origin" />
    <link rel="next" href="/page2/" />

    <meta property="og:site_name" content="Curiosity is the most powerful thing you own" />
    <meta property="og:type" content="website" />
    <meta property="og:title" content="Upgrading Sublime Text" />
    <meta property="og:description" content="A beautiful narrative written over an elegant publishing platform. The story begins here..." />
    <meta property="og:url" content="http://localhost:4000//sublime-upgrade" />
    <meta property="og:image" content="/assets/images/cover1.jpg" />

    <meta name="twitter:card" content="summary_large_image" />
    <meta name="twitter:title" content="Upgrading Sublime Text" />
    <meta name="twitter:description" content="A beautiful narrative written over an elegant publishing platform. The story begins here..." />
    <meta name="twitter:url" content="http://localhost:4000//sublime-upgrade" />
    <meta name="twitter:image:src" content="/assets/images/cover1.jpg" />

    <meta name="generator" content="Jekyll 3.0.0" />
    <link rel="alternate" type="application/rss+xml" title="Curiosity is the most powerful thing you own" href="/feed.xml" />

Menu

        Close

Home

About

Databases

DevOps

Fiction

MLOps

Travel

Resume

Photography

Author

    Subscribe

            Menu

Upgrading Sublime Text

                    Deepak Gupta

            <time class="post-date" datetime="2021-09-13">13 Sep 2021</time>

                on

                       Devops

Upgrade your Sublime Text with the below steps

Environment Details

OS Ubuntu-20.04

From the Sublime official website, download the 64-bit tarball

wget https://download.sublimetext.com/sublime_text_build_4113_x64.tar.xz

You can point the URL to the latest available Sublime Text package.

Backup your existing Sublime Installation

sudo cp -r /opt/sublime_text/ /opt/sublime_text_backup

Copy the newly downloaded Sublime files

sudo cp -r ~/Downloads/sublime_text_build_4113_x64/sublime_text /opt/

Remove the downloaded files

rm -rf ~/Downloads/sublime_text_build_4113_x64 ~/Downloads/sublime_text_build_4113_x64.tar.xz

Remove the backup after a few days

sudo rm -rf /opt/sublime_text_backup

And we're done - Enjoy the new upgrade!!

                            hellodk's Picture

Deepak Gupta

 A full time technologist cum foodieeeeeee... I spend most of my time playing with open source tools and technologies. I prefer hanging out most of the time, and have been a taveller since ages, besides being a biker at heart I do love to practice photography in my liesure.

                             Bangalore, India
                             linkedin.com/in/hellodk/

Share this post

                            Twitter

                            Facebook

                            Google+

My Resume Hosted

Curriculum Vitae Deepak Gupta Email: hello.dk@outlook.com About.me: about.me/hellodk Blog: hellodk.io Github: github.com/hellodk LinkedIn: linkedin.com/in/hellodk Docker...

Curiosity is the most powerful thing you own © 2022

Published by theCylon.org