[cm_v1.R:1:15:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L1) *style:* **Use two spaces to indent, never tabs.**
```r
require(rpart)
              ^
```
[cm_v1.R:1:43:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L1) *style:* **Use two spaces to indent, never tabs.**
```r
mydata$Industry=as.factor(mydata$Industry)
                                          ^
```
[cm_v1.R:2:7:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L2) *style:* **Put spaces around all infix operators.**
```r
mydata<-read.csv(file="mf850-finalproject-data.csv", header=TRUE, sep=",")
     ~^~~
```
[cm_v1.R:2:22:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L2) *style:* **Put spaces around all infix operators.**
```r
mydata<-read.csv(file="mf850-finalproject-data.csv", header=TRUE, sep=",")
                    ~^~
```
[cm_v1.R:2:60:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L2) *style:* **Put spaces around all infix operators.**
```r
mydata<-read.csv(file="mf850-finalproject-data.csv", header=TRUE, sep=",")
                                                          ~^~
```
[cm_v1.R:2:70:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L2) *style:* **Put spaces around all infix operators.**
```r
mydata<-read.csv(file="mf850-finalproject-data.csv", header=TRUE, sep=",")
                                                                    ~^~
```
[cm_v1.R:5:15:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L5) *style:* **Trailing whitespace is superfluous.**
```r
require(rpart)
              ^
```
[cm_v1.R:6:16:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L6) *style:* **Use <-, not =, for assignment.**
```r
mydata$Industry=as.factor(mydata$Industry)
               ^
```
[cm_v1.R:6:16:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L6) *style:* **Put spaces around all infix operators.**
```r
mydata$Industry=as.factor(mydata$Industry)
              ~^~
```
[cm_v1.R:6:43:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L6) *style:* **Trailing whitespace is superfluous.**
```r
mydata$Industry=as.factor(mydata$Industry)
                                          ^
```
[cm_v1.R:7:28:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/cm_v1.R#L7) *style:* **Use <-, not =, for assignment.**
```r
contrasts(mydata$Industry) = contr.treatment(213)
                           ^
```


[GPUAcceleratedClustering.R:4:18:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L4) *style:* **Only use double-quotes.**
```r
install.packages('rpud')
                 ^~~~~~
```
[GPUAcceleratedClustering.R:11:17:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L11) *style:* **Trailing whitespace is superfluous.**
```r
  set.seed(seed)
                ^
```
[GPUAcceleratedClustering.R:12:32:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L12) *style:* **Put spaces around all infix operators.**
```r
  matrix(rnorm(dim * num), nrow=num)
                              ~^~
```
[GPUAcceleratedClustering.R:21:11:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L21) *style:* **Variable and function names should be all lowercase.**
```r
  dgpu <- rpuDist(matrix)
          ^~~~~~~
```
[GPUAcceleratedClustering.R:21:11:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L21) *warning:* **no visible global function definition for ‘rpuDist’**
```r
  dgpu <- rpuDist(matrix)
          ^~~~~~~
```
[GPUAcceleratedClustering.R:22:3:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L22) *style:* **Variable and function names should be all lowercase.**
```r
  rpuHclust(dgpu)
  ^~~~~~~~~
```
[GPUAcceleratedClustering.R:22:3:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L22) *warning:* **no visible global function definition for ‘rpuHclust’**
```r
  rpuHclust(dgpu)
  ^~~~~~~~~
```
[GPUAcceleratedClustering.R:35:29:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L35) *style:* **Put spaces around all infix operators.**
```r
print(system.time(cpuhclust <-run_cpu(m)))
                            ^~~
```
[GPUAcceleratedClustering.R:43:16:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/GPUAcceleratedClustering.R#L43) *style:* **Commas should always have a space after.**
```r
plot(gpuhclust,hang = -1)
               ^
```


[NeuralNet.R:6:18:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L6) *style:* **Only use double-quotes.**
```r
install.packages('neuralnet')
                 ^~~~~~~~~~~
```
[NeuralNet.R:12:11:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L12) *style:* **Use <-, not =, for assignment.**
```r
stockdata = read.csv("mf850-finalproject-data.csv")
          ^
```
[NeuralNet.R:13:16:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L13) *style:* **Use <-, not =, for assignment.**
```r
stockdata$Date = NULL
               ^
```
[NeuralNet.R:14:20:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L14) *style:* **Use <-, not =, for assignment.**
```r
stockdata$Industry = NULL
                   ^
```
[NeuralNet.R:15:14:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L15) *style:* **Use <-, not =, for assignment.**
```r
scaled_Stock = scale(stockdata)
             ^
```
[NeuralNet.R:16:3:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L16) *style:* **Use <-, not =, for assignment.**
```r
y = stockdata$RETMONTH_SPX
  ^
```
[NeuralNet.R:17:3:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L17) *style:* **Use <-, not =, for assignment.**
```r
x = stockdata
  ^
```
[NeuralNet.R:18:16:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L18) *style:* **Use <-, not =, for assignment.**
```r
x$RETMONTH_SPX = NULL
               ^
```
[NeuralNet.R:24:37:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L24) *style:* **Commas should always have a space after.**
```r
trainingdata <- cbind(traininginput,trainingoutput)
                                    ^
```
[NeuralNet.R:25:37:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L25) *style:* **Commas should always have a space after.**
```r
colnames(trainingdata) <- c("Input","Output")
                                    ^
```
[NeuralNet.R:31:36:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L31) *style:* **Commas should always have a space after.**
```r
net.sqrt <- neuralnet(Output~Input,trainingdata, hidden=100, threshold=0.01)
                                   ^
```
[NeuralNet.R:31:56:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L31) *style:* **Put spaces around all infix operators.**
```r
net.sqrt <- neuralnet(Output~Input,trainingdata, hidden=100, threshold=0.01)
                                                      ~^~
```
[NeuralNet.R:31:71:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L31) *style:* **Put spaces around all infix operators.**
```r
net.sqrt <- neuralnet(Output~Input,trainingdata, hidden=100, threshold=0.01)
                                                                     ~^~
```
[NeuralNet.R:38:27:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L38) *style:* **Place a space before left parenthesis, except in a function call.**
```r
testdata <- as.data.frame((1:10)^2) #Generate some squared numbers
                          ^
```
[NeuralNet.R:38:33:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L38) *style:* **Put spaces around all infix operators.**
```r
testdata <- as.data.frame((1:10)^2) #Generate some squared numbers
                               ~^~
```
[NeuralNet.R:48:31:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L48) *style:* **Commas should always have a space after.**
```r
cleanoutput <- cbind(testdata,sqrt(testdata),
                              ^
```
[NeuralNet.R:50:36:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L50) *style:* **Commas should always have a space after.**
```r
colnames(cleanoutput) <- c("Input","Expected Output","Neural Net Output")
                                   ^
```
[NeuralNet.R:50:54:](https://github.com/myellen/MF850_Computational_Finance_Final/blob/3ac4d74111ff1b2ebf48d93ca3f3bc8b27d95b7c/NeuralNet.R#L50) *style:* **Commas should always have a space after.**
```r
colnames(cleanoutput) <- c("Input","Expected Output","Neural Net Output")
                                                     ^
```


Dạ, em cảm ơn Anh!
Em quên mất cái đó trên compute, controller thì có ạ.
Chúc Anh cuối tuần vui!!!

On Sun, Dec 18, 2016 at 8:36 PM, Tô Thành Công <notifications@github.com>
wrote:

> Em chưa enable chế độ VT khi tạo các máy ảo để cài OpenStack (máy CTL và
> COM)
>
> Tham khảo: http://3lemny.net/wp-content/uploads/2016/07/Intel-VT-x-
> and-AMD-V.png
>
> —
> You are receiving this because you commented.
> Reply to this email directly, view it on GitHub
> <https://github.com/vietstacker/OpenStack-Newton-Scripts/commit/287034f3e96708c157532f86719ada2aff1feda3#commitcomment-20226190>,
> or mute the thread
> <https://github.com/notifications/unsubscribe-auth/AO0EZLaYPpmO272rWUw-j_DlcH9fG9BFks5rJTbogaJpZM4LQDyE>
> .
>


that is COOL!


Leave the bar codes on the scanner


Shouldn't this be a `pop`?


![Uploading 3611110-164aa437ee3c0d4e.jpg…]()


![Uploading 3611110-164aa437ee3c0d4e.jpg…]()
<img width="1152" alt="chapter6_6 16_plucked_0" src="https://cloud.githubusercontent.com/assets/22126475/21293962/586e42cc-c56d-11e6-8000-631e6981cab7.png">
![Uploading chapter6_6.16_plucked_c.png…]()


@prasadc82 Please comment that line. even its not needed. Thanks for the review. I guess we can merge this to master.


May I also suggest changing the collector from `toList()` to either `toCollection(ArrayList::new)` or `collectingAndThen(toList(), Collections::unmodifiableList)`?

Currently, the spec of toList() makes no guarantees about the mutability of the returned list, so even though it may return a mutable list now, it may return an immutable one in future Java releases, and so if any internal JUnit code relies on the public annotated fields being mutable, then it may unexpectedly break in the future.


这里其实你定义了一种DSL来方便初始化测试数据。
优点是信息集中，简洁。
缺点：
- 字符串分割解析比较脆弱
- 表达意义不明确，必须阅读解析代码才能理解字符串的确切含义

另外考虑这个问题，是不是实现代码缺乏某些概念，所以测试代码中需要增加一个方法？


gfg


initten önce boşluğa gerek yok


ret yerine daha anlamlı bir değişken adı kullanılabilir


my fault :)


anyString不是用在这个场景的，不过看起来表达能力倒是不错 :smile:
思考一下：为什么所有的测试都不关心这个字符串，但是它确实创建对象时必须的信息？


burda boşluğu unutmuşsun virgülden sonra
```
pip install pep8
pep8 dosyaadi
```
diyerek bu tarz imla kurallarını kontrol ettirebilirsin


# hello jija
 @[
![steve-bikos-70th-birthday-5759174941081600-hp](https://cloud.githubusercontent.com/assets/22721008/21294012/5aeccd28-c4e8-11e6-957d-cee7835a7cf6.png)

](url)


Even after  doing this the second sim networks  to lte, still  it remains  on edge and  no signal for 4g #


object ten inherit edersen daha iyi olur, fark çok küçük ama yeni standartlar böyle


importları açık yaparsan daha iyi olur


A 到 A 和 A 到 B 的测试，看不出各自特别的目的。
如果把A B改为具体的值可能会更容易理解。


Thank you! I just started using this API and I was going crazy trying to figure out why my options weren't working. When do you expect a v2.2.2 release?


I haven't had any reports of this.  I think almost all kernels have merged those two patches.


sprawdzone


+1 for `\0` is missing


Allocated memory is not deleted.


@Glenn-1990 @Kwiboo This fixes the Hub power on issue without uboot changes: https://github.com/LibreELEC/linux-amlogic/pull/27


修改结构体参数的翻译，以及execOp中对于结构体参数的解释


这里有点模糊的地方，是起止相同所以0，还是setting中的0导致的？


`int* m=new int[l]();` value-initialize with 0s.
Note parentheses before semicolon.


buna gerek yok, pythonda eger cok ozel bir neden yoksa getter setter tanimlamiyoruz


/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Symfony\Component\HttpFoundation;
use Symfony\Component\HttpFoundation\Exception\ConflictingHeadersException;
use Symfony\Component\HttpFoundation\Exception\SuspiciousOperationException;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
/**
 * Request represents an HTTP request.
 *
 * The methods dealing with URL accept / return a raw path (% encoded):
 *   * getBasePath
 *   * getBaseUrl
 *   * getPathInfo
 *   * getRequestUri
 *   * getUri
 *   * getUriForPath
 *
 * @author Fabien Potencier <fabien@symfony.com>
 */
class Request
{
    const HEADER_FORWARDED = 'forwarded';
    const HEADER_CLIENT_IP = 'client_ip';
    const HEADER_CLIENT_HOST = 'client_host';
    const HEADER_CLIENT_PROTO = 'client_proto';
    const HEADER_CLIENT_PORT = 'client_port';
    const METHOD_HEAD = 'HEAD';
    const METHOD_GET = 'GET';
    const METHOD_POST = 'POST';
    const METHOD_PUT = 'PUT';
    const METHOD_PATCH = 'PATCH';
    const METHOD_DELETE = 'DELETE';
    const METHOD_PURGE = 'PURGE';
    const METHOD_OPTIONS = 'OPTIONS';
    const METHOD_TRACE = 'TRACE';
    const METHOD_CONNECT = 'CONNECT';
    /**
     * @var string[]
     */
    protected static $trustedProxies = array();
    /**
     * @var string[]
     */
    protected static $trustedHostPatterns = array();
    /**
     * @var string[]
     */
    protected static $trustedHosts = array();
    /**
     * Names for headers that can be trusted when
     * using trusted proxies.
     *
     * The FORWARDED header is the standard as of rfc7239.
     *
     * The other headers are non-standard, but widely used
     * by popular reverse proxies (like Apache mod_proxy or Amazon EC2).
     */
    protected static $trustedHeaders = array(
        self::HEADER_FORWARDED => 'FORWARDED',
        self::HEADER_CLIENT_IP => 'X_FORWARDED_FOR',
        self::HEADER_CLIENT_HOST => 'X_FORWARDED_HOST',
        self::HEADER_CLIENT_PROTO => 'X_FORWARDED_PROTO',
        self::HEADER_CLIENT_PORT => 'X_FORWARDED_PORT',
    );
    protected static $httpMethodParameterOverride = false;
    /**
     * Custom parameters.
     *
     * @var \Symfony\Component\HttpFoundation\ParameterBag
     */
    public $attributes;
    /**
     * Request body parameters ($_POST).
     *
     * @var \Symfony\Component\HttpFoundation\ParameterBag
     */
    public $request;
    /**
     * Query string parameters ($_GET).
     *
     * @var \Symfony\Component\HttpFoundation\ParameterBag
     */
    public $query;
    /**
     * Server and execution environment parameters ($_SERVER).
     *
     * @var \Symfony\Component\HttpFoundation\ServerBag
     */
    public $server;
    /**
     * Uploaded files ($_FILES).
     *
     * @var \Symfony\Component\HttpFoundation\FileBag
     */
    public $files;
    /**
     * Cookies ($_COOKIE).
     *
     * @var \Symfony\Component\HttpFoundation\ParameterBag
     */
    public $cookies;
    /**
     * Headers (taken from the $_SERVER).
     *
     * @var \Symfony\Component\HttpFoundation\HeaderBag
     */
    public $headers;
    /**
     * @var string
     */
    protected $content;
    /**
     * @var array
     */
    protected $languages;
    /**
     * @var array
     */
    protected $charsets;
    /**
     * @var array
     */
    protected $encodings;
    /**
     * @var array
     */
    protected $acceptableContentTypes;
    /**
     * @var string
     */
    protected $pathInfo;
    /**
     * @var string
     */
    protected $requestUri;
    /**
     * @var string
     */
    protected $baseUrl;
    /**
     * @var string
     */
    protected $basePath;
    /**
     * @var string
     */
    protected $method;
    /**
     * @var string
     */
    protected $format;
    /**
     * @var \Symfony\Component\HttpFoundation\Session\SessionInterface
     */
    protected $session;
    /**
     * @var string
     */
    protected $locale;
    /**
     * @var string
     */
    protected $defaultLocale = 'en';
    /**
     * @var array
     */
    protected static $formats;
    protected static $requestFactory;
    private $isHostValid = true;
    private $isClientIpsValid = true;
    /**
     * Constructor.
     *
     * @param array           $query      The GET parameters
     * @param array           $request    The POST parameters
     * @param array           $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
     * @param array           $cookies    The COOKIE parameters
     * @param array           $files      The FILES parameters
     * @param array           $server     The SERVER parameters
     * @param string|resource $content    The raw body data
     */
    public function __construct(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
    {
        $this->initialize($query, $request, $attributes, $cookies, $files, $server, $content);
    }
    /**
     * Sets the parameters for this request.
     *
     * This method also re-initializes all properties.
     *
     * @param array           $query      The GET parameters
     * @param array           $request    The POST parameters
     * @param array           $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
     * @param array           $cookies    The COOKIE parameters
     * @param array           $files      The FILES parameters
     * @param array           $server     The SERVER parameters
     * @param string|resource $content    The raw body data
     */
    public function initialize(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
    {
        $this->request = new ParameterBag($request);
        $this->query = new ParameterBag($query);
        $this->attributes = new ParameterBag($attributes);
        $this->cookies = new ParameterBag($cookies);
        $this->files = new FileBag($files);
        $this->server = new ServerBag($server);
        $this->headers = new HeaderBag($this->server->getHeaders());
        $this->content = $content;
        $this->languages = null;
        $this->charsets = null;
        $this->encodings = null;
        $this->acceptableContentTypes = null;
        $this->pathInfo = null;
        $this->requestUri = null;
        $this->baseUrl = null;
        $this->basePath = null;
        $this->method = null;
        $this->format = null;
    }
    /**
     * Creates a new request with values from PHP's super globals.
     *
     * @return Request A new request
     */
    public static function createFromGlobals()
    {
        // With the php's bug #66606, the php's built-in web server
        // stores the Content-Type and Content-Length header values in
        // HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH fields.
        $server = $_SERVER;
        if ('cli-server' === PHP_SAPI) {
            if (array_key_exists('HTTP_CONTENT_LENGTH', $_SERVER)) {
                $server['CONTENT_LENGTH'] = $_SERVER['HTTP_CONTENT_LENGTH'];
            }
            if (array_key_exists('HTTP_CONTENT_TYPE', $_SERVER)) {
                $server['CONTENT_TYPE'] = $_SERVER['HTTP_CONTENT_TYPE'];
            }
        }
        $request = self::createRequestFromFactory($_GET, $_POST, array(), $_COOKIE, $_FILES, $server);
        if (0 === strpos($request->headers->get('CONTENT_TYPE'), 'application/x-www-form-urlencoded')
            && in_array(strtoupper($request->server->get('REQUEST_METHOD', 'GET')), array('PUT', 'DELETE', 'PATCH'))
        ) {
            parse_str($request->getContent(), $data);
            $request->request = new ParameterBag($data);
        }
        return $request;
    }
    /**
     * Creates a Request based on a given URI and configuration.
     *
     * The information contained in the URI always take precedence
     * over the other information (server and parameters).
     *
     * @param string $uri        The URI
     * @param string $method     The HTTP method
     * @param array  $parameters The query (GET) or request (POST) parameters
     * @param array  $cookies    The request cookies ($_COOKIE)
     * @param array  $files      The request files ($_FILES)
     * @param array  $server     The server parameters ($_SERVER)
     * @param string $content    The raw body data
     *
     * @return Request A Request instance
     */
    public static function create($uri, $method = 'GET', $parameters = array(), $cookies = array(), $files = array(), $server = array(), $content = null)
    {
        $server = array_replace(array(
            'SERVER_NAME' => 'localhost',
            'SERVER_PORT' => 80,
            'HTTP_HOST' => 'localhost',
            'HTTP_USER_AGENT' => 'Symfony/3.X',
            'HTTP_ACCEPT' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'HTTP_ACCEPT_LANGUAGE' => 'en-us,en;q=0.5',
            'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
            'REMOTE_ADDR' => '127.0.0.1',
            'SCRIPT_NAME' => '',
            'SCRIPT_FILENAME' => '',
            'SERVER_PROTOCOL' => 'HTTP/1.1',
            'REQUEST_TIME' => time(),
        ), $server);
        $server['PATH_INFO'] = '';
        $server['REQUEST_METHOD'] = strtoupper($method);
        $components = parse_url($uri);
        if (isset($components['host'])) {
            $server['SERVER_NAME'] = $components['host'];
            $server['HTTP_HOST'] = $components['host'];
        }
        if (isset($components['scheme'])) {
            if ('https' === $components['scheme']) {
                $server['HTTPS'] = 'on';
                $server['SERVER_PORT'] = 443;
            } else {
                unset($server['HTTPS']);
                $server['SERVER_PORT'] = 80;
            }
        }
        if (isset($components['port'])) {
            $server['SERVER_PORT'] = $components['port'];
            $server['HTTP_HOST'] = $server['HTTP_HOST'].':'.$components['port'];
        }
        if (isset($components['user'])) {
            $server['PHP_AUTH_USER'] = $components['user'];
        }
        if (isset($components['pass'])) {
            $server['PHP_AUTH_PW'] = $components['pass'];
        }
        if (!isset($components['path'])) {
            $components['path'] = '/';
        }
        switch (strtoupper($method)) {
            case 'POST':
            case 'PUT':
            case 'DELETE':
                if (!isset($server['CONTENT_TYPE'])) {
                    $server['CONTENT_TYPE'] = 'application/x-www-form-urlencoded';
                }
                // no break
            case 'PATCH':
                $request = $parameters;
                $query = array();
                break;
            default:
                $request = array();
                $query = $parameters;
                break;
        }
        $queryString = '';
        if (isset($components['query'])) {
            parse_str(html_entity_decode($components['query']), $qs);
            if ($query) {
                $query = array_replace($qs, $query);
                $queryString = http_build_query($query, '', '&');
            } else {
                $query = $qs;
                $queryString = $components['query'];
            }
        } elseif ($query) {
            $queryString = http_build_query($query, '', '&');
        }
        $server['REQUEST_URI'] = $components['path'].('' !== $queryString ? '?'.$queryString : '');
        $server['QUERY_STRING'] = $queryString;
        return self::createRequestFromFactory($query, $request, array(), $cookies, $files, $server, $content);
    }
    /**
     * Sets a callable able to create a Request instance.
     *
     * This is mainly useful when you need to override the Request class
     * to keep BC with an existing system. It should not be used for any
     * other purpose.
     *
     * @param callable|null $callable A PHP callable
     */
    public static function setFactory($callable)
    {
        self::$requestFactory = $callable;
    }
    /**
     * Clones a request and overrides some of its parameters.
     *
     * @param array $query      The GET parameters
     * @param array $request    The POST parameters
     * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
     * @param array $cookies    The COOKIE parameters
     * @param array $files      The FILES parameters
     * @param array $server     The SERVER parameters
     *
     * @return Request The duplicated request
     */
    public function duplicate(array $query = null, array $request = null, array $attributes = null, array $cookies = null, array $files = null, array $server = null)
    {
        $dup = clone $this;
        if ($query !== null) {
            $dup->query = new ParameterBag($query);
        }
        if ($request !== null) {
            $dup->request = new ParameterBag($request);
        }
        if ($attributes !== null) {
            $dup->attributes = new ParameterBag($attributes);
        }
        if ($cookies !== null) {
            $dup->cookies = new ParameterBag($cookies);
        }
        if ($files !== null) {
            $dup->files = new FileBag($files);
        }
        if ($server !== null) {
            $dup->server = new ServerBag($server);
            $dup->headers = new HeaderBag($dup->server->getHeaders());
        }
        $dup->languages = null;
        $dup->charsets = null;
        $dup->encodings = null;
        $dup->acceptableContentTypes = null;
        $dup->pathInfo = null;
        $dup->requestUri = null;
        $dup->baseUrl = null;
        $dup->basePath = null;
        $dup->method = null;
        $dup->format = null;
        if (!$dup->get('_format') && $this->get('_format')) {
            $dup->attributes->set('_format', $this->get('_format'));
        }
        if (!$dup->getRequestFormat(null)) {
            $dup->setRequestFormat($this->getRequestFormat(null));
        }
        return $dup;
    }
    /**
     * Clones the current request.
     *
     * Note that the session is not cloned as duplicated requests
     * are most of the time sub-requests of the main one.
     */
    public function __clone()
    {
        $this->query = clone $this->query;
        $this->request = clone $this->request;
        $this->attributes = clone $this->attributes;
        $this->cookies = clone $this->cookies;
        $this->files = clone $this->files;
        $this->server = clone $this->server;
        $this->headers = clone $this->headers;
    }
    /**
     * Returns the request as a string.
     *
     * @return string The request
     */
    public function __toString()
    {
        try {
            $content = $this->getContent();
        } catch (\LogicException $e) {
            return trigger_error($e, E_USER_ERROR);
        }
        return
            sprintf('%s %s %s', $this->getMethod(), $this->getRequestUri(), $this->server->get('SERVER_PROTOCOL'))."\r\n".
            $this->headers."\r\n".
            $content;
    }
    /**
     * Overrides the PHP global variables according to this request instance.
     *
     * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
     * $_FILES is never overridden, see rfc1867
     */
    public function overrideGlobals()
    {
        $this->server->set('QUERY_STRING', static::normalizeQueryString(http_build_query($this->query->all(), null, '&')));
        $_GET = $this->query->all();
        $_POST = $this->request->all();
        $_SERVER = $this->server->all();
        $_COOKIE = $this->cookies->all();
        foreach ($this->headers->all() as $key => $value) {
            $key = strtoupper(str_replace('-', '_', $key));
            if (in_array($key, array('CONTENT_TYPE', 'CONTENT_LENGTH'))) {
                $_SERVER[$key] = implode(', ', $value);
            } else {
                $_SERVER['HTTP_'.$key] = implode(', ', $value);
            }
        }
        $request = array('g' => $_GET, 'p' => $_POST, 'c' => $_COOKIE);
        $requestOrder = ini_get('request_order') ?: ini_get('variables_order');
        $requestOrder = preg_replace('#[^cgp]#', '', strtolower($requestOrder)) ?: 'gp';
        $_REQUEST = array();
        foreach (str_split($requestOrder) as $order) {
            $_REQUEST = array_merge($_REQUEST, $request[$order]);
        }
    }
    /**
     * Sets a list of trusted proxies.
     *
     * You should only list the reverse proxies that you manage directly.
     *
     * @param array $proxies A list of trusted proxies
     */
    public static function setTrustedProxies(array $proxies)
    {
        self::$trustedProxies = $proxies;
    }
    /**
     * Gets the list of trusted proxies.
     *
     * @return array An array of trusted proxies
     */
    public static function getTrustedProxies()
    {
        return self::$trustedProxies;
    }
    /**
     * Sets a list of trusted host patterns.
     *
     * You should only list the hosts you manage using regexs.
     *
     * @param array $hostPatterns A list of trusted host patterns
     */
    public static function setTrustedHosts(array $hostPatterns)
    {
        self::$trustedHostPatterns = array_map(function ($hostPattern) {
            return sprintf('#%s#i', $hostPattern);
        }, $hostPatterns);
        // we need to reset trusted hosts on trusted host patterns change
        self::$trustedHosts = array();
    }
    /**
     * Gets the list of trusted host patterns.
     *
     * @return array An array of trusted host patterns
     */
    public static function getTrustedHosts()
    {
        return self::$trustedHostPatterns;
    }
    /**
     * Sets the name for trusted headers.
     *
     * The following header keys are supported:
     *
     *  * Request::HEADER_CLIENT_IP:    defaults to X-Forwarded-For   (see getClientIp())
     *  * Request::HEADER_CLIENT_HOST:  defaults to X-Forwarded-Host  (see getHost())
     *  * Request::HEADER_CLIENT_PORT:  defaults to X-Forwarded-Port  (see getPort())
     *  * Request::HEADER_CLIENT_PROTO: defaults to X-Forwarded-Proto (see getScheme() and isSecure())
     *
     * Setting an empty value allows to disable the trusted header for the given key.
     *
     * @param string $key   The header key
     * @param string $value The header name
     *
     * @throws \InvalidArgumentException
     */
    public static function setTrustedHeaderName($key, $value)
    {
        if (!array_key_exists($key, self::$trustedHeaders)) {
            throw new \InvalidArgumentException(sprintf('Unable to set the trusted header name for key "%s".', $key));
        }
        self::$trustedHeaders[$key] = $value;
    }
    /**
     * Gets the trusted proxy header name.
     *
     * @param string $key The header key
     *
     * @return string The header name
     *
     * @throws \InvalidArgumentException
     */
    public static function getTrustedHeaderName($key)
    {
        if (!array_key_exists($key, self::$trustedHeaders)) {
            throw new \InvalidArgumentException(sprintf('Unable to get the trusted header name for key "%s".', $key));
        }
        return self::$trustedHeaders[$key];
    }
    /**
     * Normalizes a query string.
     *
     * It builds a normalized query string, where keys/value pairs are alphabetized,
     * have consistent escaping and unneeded delimiters are removed.
     *
     * @param string $qs Query string
     *
     * @return string A normalized query string for the Request
     */
    public static function normalizeQueryString($qs)
    {
        if ('' == $qs) {
            return '';
        }
        $parts = array();
        $order = array();
        foreach (explode('&', $qs) as $param) {
            if ('' === $param || '=' === $param[0]) {
                // Ignore useless delimiters, e.g. "x=y&".
                // Also ignore pairs with empty key, even if there was a value, e.g. "=value", as such nameless values cannot be retrieved anyway.
                // PHP also does not include them when building _GET.
                continue;
            }
            $keyValuePair = explode('=', $param, 2);
            // GET parameters, that are submitted from a HTML form, encode spaces as "+" by default (as defined in enctype application/x-www-form-urlencoded).
            // PHP also converts "+" to spaces when filling the global _GET or when using the function parse_str. This is why we use urldecode and then normalize to
            // RFC 3986 with rawurlencode.
            $parts[] = isset($keyValuePair[1]) ?
                rawurlencode(urldecode($keyValuePair[0])).'='.rawurlencode(urldecode($keyValuePair[1])) :
                rawurlencode(urldecode($keyValuePair[0]));
            $order[] = urldecode($keyValuePair[0]);
        }
        array_multisort($order, SORT_ASC, $parts);
        return implode('&', $parts);
    }
    /**
     * Enables support for the _method request parameter to determine the intended HTTP method.
     *
     * Be warned that enabling this feature might lead to CSRF issues in your code.
     * Check that you are using CSRF tokens when required.
     * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
     * and used to send a "PUT" or "DELETE" request via the _method request parameter.
     * If these methods are not protected against CSRF, this presents a possible vulnerability.
     *
     * The HTTP method can only be overridden when the real HTTP method is POST.
     */
    public static function enableHttpMethodParameterOverride()
    {
        self::$httpMethodParameterOverride = true;
    }
    /**
     * Checks whether support for the _method request parameter is enabled.
     *
     * @return bool True when the _method request parameter is enabled, false otherwise
     */
    public static function getHttpMethodParameterOverride()
    {
        return self::$httpMethodParameterOverride;
    }
    /**
     * Gets a "parameter" value from any bag.
     *
     * This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
     * flexibility in controllers, it is better to explicitly get request parameters from the appropriate
     * public property instead (attributes, query, request).
     *
     * Order of precedence: PATH (routing placeholders or custom attributes), GET, BODY
     *
     * @param string $key     the key
     * @param mixed  $default the default value if the parameter key does not exist
     *
     * @return mixed
     */
    public function get($key, $default = null)
    {
        if ($this !== $result = $this->attributes->get($key, $this)) {
            return $result;
        }
        if ($this !== $result = $this->query->get($key, $this)) {
            return $result;
        }
        if ($this !== $result = $this->request->get($key, $this)) {
            return $result;
        }
        return $default;
    }
    /**
     * Gets the Session.
     *
     * @return SessionInterface|null The session
     */
    public function getSession()
    {
        return $this->session;
    }
    /**
     * Whether the request contains a Session which was started in one of the
     * previous requests.
     *
     * @return bool
     */
    public function hasPreviousSession()
    {
        // the check for $this->session avoids malicious users trying to fake a session cookie with proper name
        return $this->hasSession() && $this->cookies->has($this->session->getName());
    }
    /**
     * Whether the request contains a Session object.
     *
     * This method does not give any information about the state of the session object,
     * like whether the session is started or not. It is just a way to check if this Request
     * is associated with a Session instance.
     *
     * @return bool true when the Request contains a Session object, false otherwise
     */
    public function hasSession()
    {
        return null !== $this->session;
    }
    /**
     * Sets the Session.
     *
     * @param SessionInterface $session The Session
     */
    public function setSession(SessionInterface $session)
    {
        $this->session = $session;
    }
    /**
     * Returns the client IP addresses.
     *
     * In the returned array the most trusted IP address is first, and the
     * least trusted one last. The "real" client IP address is the last one,
     * but this is also the least trusted one. Trusted proxies are stripped.
     *
     * Use this method carefully; you should use getClientIp() instead.
     *
     * @return array The client IP addresses
     *
     * @see getClientIp()
     */
    public function getClientIps()
    {
        $clientIps = array();
        $ip = $this->server->get('REMOTE_ADDR');
        if (!$this->isFromTrustedProxy()) {
            return array($ip);
        }
        $hasTrustedForwardedHeader = self::$trustedHeaders[self::HEADER_FORWARDED] && $this->headers->has(self::$trustedHeaders[self::HEADER_FORWARDED]);
        $hasTrustedClientIpHeader = self::$trustedHeaders[self::HEADER_CLIENT_IP] && $this->headers->has(self::$trustedHeaders[self::HEADER_CLIENT_IP]);
        if ($hasTrustedForwardedHeader) {
            $forwardedHeader = $this->headers->get(self::$trustedHeaders[self::HEADER_FORWARDED]);
            preg_match_all('{(for)=("?\[?)([a-z0-9\.:_\-/]*)}', $forwardedHeader, $matches);
            $forwardedClientIps = $matches[3];
            $forwardedClientIps = $this->normalizeAndFilterClientIps($forwardedClientIps, $ip);
            $clientIps = $forwardedClientIps;
        }
        if ($hasTrustedClientIpHeader) {
            $xForwardedForClientIps = array_map('trim', explode(',', $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_IP])));
            $xForwardedForClientIps = $this->normalizeAndFilterClientIps($xForwardedForClientIps, $ip);
            $clientIps = $xForwardedForClientIps;
        }
        if ($hasTrustedForwardedHeader && $hasTrustedClientIpHeader && $forwardedClientIps !== $xForwardedForClientIps) {
            if (!$this->isClientIpsValid) {
                return array('0.0.0.0');
            }
            $this->isClientIpsValid = false;
            throw new ConflictingHeadersException('The request has both a trusted Forwarded header and a trusted Client IP header, conflicting with each other with regards to the originating IP addresses of the request. This is the result of a misconfiguration. You should either configure your proxy only to send one of these headers, or configure your project to distrust one of them.');
        }
        if (!$hasTrustedForwardedHeader && !$hasTrustedClientIpHeader) {
            return $this->normalizeAndFilterClientIps(array(), $ip);
        }
        return $clientIps;
    }
    /**
     * Returns the client IP address.
     *
     * This method can read the client IP address from the "X-Forwarded-For" header
     * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
     * header value is a comma+space separated list of IP addresses, the left-most
     * being the original client, and each successive proxy that passed the request
     * adding the IP address where it received the request from.
     *
     * If your reverse proxy uses a different header name than "X-Forwarded-For",
     * ("Client-Ip" for instance), configure it via "setTrustedHeaderName()" with
     * the "client-ip" key.
     *
     * @return string The client IP address
     *
     * @see getClientIps()
     * @see http://en.wikipedia.org/wiki/X-Forwarded-For
     */
    public function getClientIp()
    {
        $ipAddresses = $this->getClientIps();
        return $ipAddresses[0];
    }
    /**
     * Returns current script name.
     *
     * @return string
     */
    public function getScriptName()
    {
        return $this->server->get('SCRIPT_NAME', $this->server->get('ORIG_SCRIPT_NAME', ''));
    }
    /**
     * Returns the path being requested relative to the executed script.
     *
     * The path info always starts with a /.
     *
     * Suppose this request is instantiated from /mysite on localhost:
     *
     *  * http://localhost/mysite              returns an empty string
     *  * http://localhost/mysite/about        returns '/about'
     *  * http://localhost/mysite/enco%20ded   returns '/enco%20ded'
     *  * http://localhost/mysite/about?var=1  returns '/about'
     *
     * @return string The raw path (i.e. not urldecoded)
     */
    public function getPathInfo()
    {
        if (null === $this->pathInfo) {
            $this->pathInfo = $this->preparePathInfo();
        }
        return $this->pathInfo;
    }
    /**
     * Returns the root path from which this request is executed.
     *
     * Suppose that an index.php file instantiates this request object:
     *
     *  * http://localhost/index.php         returns an empty string
     *  * http://localhost/index.php/page    returns an empty string
     *  * http://localhost/web/index.php     returns '/web'
     *  * http://localhost/we%20b/index.php  returns '/we%20b'
     *
     * @return string The raw path (i.e. not urldecoded)
     */
    public function getBasePath()
    {
        if (null === $this->basePath) {
            $this->basePath = $this->prepareBasePath();
        }
        return $this->basePath;
    }
    /**
     * Returns the root URL from which this request is executed.
     *
     * The base URL never ends with a /.
     *
     * This is similar to getBasePath(), except that it also includes the
     * script filename (e.g. index.php) if one exists.
     *
     * @return string The raw URL (i.e. not urldecoded)
     */
    public function getBaseUrl()
    {
        if (null === $this->baseUrl) {
            $this->baseUrl = $this->prepareBaseUrl();
        }
        return $this->baseUrl;
    }
    /**
     * Gets the request's scheme.
     *
     * @return string
     */
    public function getScheme()
    {
        return $this->isSecure() ? 'https' : 'http';
    }
    /**
     * Returns the port on which the request is made.
     *
     * This method can read the client port from the "X-Forwarded-Port" header
     * when trusted proxies were set via "setTrustedProxies()".
     *
     * The "X-Forwarded-Port" header must contain the client port.
     *
     * If your reverse proxy uses a different header name than "X-Forwarded-Port",
     * configure it via "setTrustedHeaderName()" with the "client-port" key.
     *
     * @return string
     */
    public function getPort()
    {
        if ($this->isFromTrustedProxy()) {
            if (self::$trustedHeaders[self::HEADER_CLIENT_PORT] && $port = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PORT])) {
                return $port;
            }
            if (self::$trustedHeaders[self::HEADER_CLIENT_PROTO] && 'https' === $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PROTO], 'http')) {
                return 443;
            }
        }
        if ($host = $this->headers->get('HOST')) {
            if ($host[0] === '[') {
                $pos = strpos($host, ':', strrpos($host, ']'));
            } else {
                $pos = strrpos($host, ':');
            }
            if (false !== $pos) {
                return (int) substr($host, $pos + 1);
            }
            return 'https' === $this->getScheme() ? 443 : 80;
        }
        return $this->server->get('SERVER_PORT');
    }
    /**
     * Returns the user.
     *
     * @return string|null
     */
    public function getUser()
    {
        return $this->headers->get('PHP_AUTH_USER');
    }
    /**
     * Returns the password.
     *
     * @return string|null
     */
    public function getPassword()
    {
        return $this->headers->get('PHP_AUTH_PW');
    }
    /**
     * Gets the user info.
     *
     * @return string A user name and, optionally, scheme-specific information about how to gain authorization to access the server
     */
    public function getUserInfo()
    {
        $userinfo = $this->getUser();
        $pass = $this->getPassword();
        if ('' != $pass) {
            $userinfo .= ":$pass";
        }
        return $userinfo;
    }
    /**
     * Returns the HTTP host being requested.
     *
     * The port name will be appended to the host if it's non-standard.
     *
     * @return string
     */
    public function getHttpHost()
    {
        $scheme = $this->getScheme();
        $port = $this->getPort();
        if (('http' == $scheme && $port == 80) || ('https' == $scheme && $port == 443)) {
            return $this->getHost();
        }
        return $this->getHost().':'.$port;
    }
    /**
     * Returns the requested URI (path and query string).
     *
     * @return string The raw URI (i.e. not URI decoded)
     */
    public function getRequestUri()
    {
        if (null === $this->requestUri) {
            $this->requestUri = $this->prepareRequestUri();
        }
        return $this->requestUri;
    }
    /**
     * Gets the scheme and HTTP host.
     *
     * If the URL was called with basic authentication, the user
     * and the password are not added to the generated string.
     *
     * @return string The scheme and HTTP host
     */
    public function getSchemeAndHttpHost()
    {
        return $this->getScheme().'://'.$this->getHttpHost();
    }
    /**
     * Generates a normalized URI (URL) for the Request.
     *
     * @return string A normalized URI (URL) for the Request
     *
     * @see getQueryString()
     */
    public function getUri()
    {
        if (null !== $qs = $this->getQueryString()) {
            $qs = '?'.$qs;
        }
        return $this->getSchemeAndHttpHost().$this->getBaseUrl().$this->getPathInfo().$qs;
    }
    /**
     * Generates a normalized URI for the given path.
     *
     * @param string $path A path to use instead of the current one
     *
     * @return string The normalized URI for the path
     */
    public function getUriForPath($path)
    {
        return $this->getSchemeAndHttpHost().$this->getBaseUrl().$path;
    }
    /**
     * Returns the path as relative reference from the current Request path.
     *
     * Only the URIs path component (no schema, host etc.) is relevant and must be given.
     * Both paths must be absolute and not contain relative parts.
     * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
     * Furthermore, they can be used to reduce the link size in documents.
     *
     * Example target paths, given a base path of "/a/b/c/d":
     * - "/a/b/c/d"     -> ""
     * - "/a/b/c/"      -> "./"
     * - "/a/b/"        -> "../"
     * - "/a/b/c/other" -> "other"
     * - "/a/x/y"       -> "../../x/y"
     *
     * @param string $path The target path
     *
     * @return string The relative target path
     */
    public function getRelativeUriForPath($path)
    {
        // be sure that we are dealing with an absolute path
        if (!isset($path[0]) || '/' !== $path[0]) {
            return $path;
        }
        if ($path === $basePath = $this->getPathInfo()) {
            return '';
        }
        $sourceDirs = explode('/', isset($basePath[0]) && '/' === $basePath[0] ? substr($basePath, 1) : $basePath);
        $targetDirs = explode('/', isset($path[0]) && '/' === $path[0] ? substr($path, 1) : $path);
        array_pop($sourceDirs);
        $targetFile = array_pop($targetDirs);
        foreach ($sourceDirs as $i => $dir) {
            if (isset($targetDirs[$i]) && $dir === $targetDirs[$i]) {
                unset($sourceDirs[$i], $targetDirs[$i]);
            } else {
                break;
            }
        }
        $targetDirs[] = $targetFile;
        $path = str_repeat('../', count($sourceDirs)).implode('/', $targetDirs);
        // A reference to the same base directory or an empty subdirectory must be prefixed with "./".
        // This also applies to a segment with a colon character (e.g., "file:colon") that cannot be used
        // as the first segment of a relative-path reference, as it would be mistaken for a scheme name
        // (see http://tools.ietf.org/html/rfc3986#section-4.2).
        return !isset($path[0]) || '/' === $path[0]
            || false !== ($colonPos = strpos($path, ':')) && ($colonPos < ($slashPos = strpos($path, '/')) || false === $slashPos)
            ? "./$path" : $path;
    }
    /**
     * Generates the normalized query string for the Request.
     *
     * It builds a normalized query string, where keys/value pairs are alphabetized
     * and have consistent escaping.
     *
     * @return string|null A normalized query string for the Request
     */
    public function getQueryString()
    {
        $qs = static::normalizeQueryString($this->server->get('QUERY_STRING'));
        return '' === $qs ? null : $qs;
    }
    /**
     * Checks whether the request is secure or not.
     *
     * This method can read the client protocol from the "X-Forwarded-Proto" header
     * when trusted proxies were set via "setTrustedProxies()".
     *
     * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
     *
     * If your reverse proxy uses a different header name than "X-Forwarded-Proto"
     * ("SSL_HTTPS" for instance), configure it via "setTrustedHeaderName()" with
     * the "client-proto" key.
     *
     * @return bool
     */
    public function isSecure()
    {
        if ($this->isFromTrustedProxy() && self::$trustedHeaders[self::HEADER_CLIENT_PROTO] && $proto = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_PROTO])) {
            return in_array(strtolower(current(explode(',', $proto))), array('https', 'on', 'ssl', '1'));
        }
        $https = $this->server->get('HTTPS');
        return !empty($https) && 'off' !== strtolower($https);
    }
    /**
     * Returns the host name.
     *
     * This method can read the client host name from the "X-Forwarded-Host" header
     * when trusted proxies were set via "setTrustedProxies()".
     *
     * The "X-Forwarded-Host" header must contain the client host name.
     *
     * If your reverse proxy uses a different header name than "X-Forwarded-Host",
     * configure it via "setTrustedHeaderName()" with the "client-host" key.
     *
     * @return string
     *
     * @throws SuspiciousOperationException when the host name is invalid or not trusted
     */
    public function getHost()
    {
        if ($this->isFromTrustedProxy() && self::$trustedHeaders[self::HEADER_CLIENT_HOST] && $host = $this->headers->get(self::$trustedHeaders[self::HEADER_CLIENT_HOST])) {
            $elements = explode(',', $host);
            $host = $elements[count($elements) - 1];
        } elseif (!$host = $this->headers->get('HOST')) {
            if (!$host = $this->server->get('SERVER_NAME')) {
                $host = $this->server->get('SERVER_ADDR', '');
            }
        }
        // trim and remove port number from host
        // host is lowercase as per RFC 952/2181
        $host = strtolower(preg_replace('/:\d+$/', '', trim($host)));
        // as the host can come from the user (HTTP_HOST and depending on the configuration, SERVER_NAME too can come from the user)
        // check that it does not contain forbidden characters (see RFC 952 and RFC 2181)
        // use preg_replace() instead of preg_match() to prevent DoS attacks with long host names
        if ($host && '' !== preg_replace('/(?:^\[)?[a-zA-Z0-9-:\]_]+\.?/', '', $host)) {
            if (!$this->isHostValid) {
                return '';
            }
            $this->isHostValid = false;
            throw new SuspiciousOperationException(sprintf('Invalid Host "%s".', $host));
        }
        if (count(self::$trustedHostPatterns) > 0) {
            // to avoid host header injection attacks, you should provide a list of trusted host patterns
            if (in_array($host, self::$trustedHosts)) {
                return $host;
            }
            foreach (self::$trustedHostPatterns as $pattern) {
                if (preg_match($pattern, $host)) {
                    self::$trustedHosts[] = $host;
                    return $host;
                }
            }
            if (!$this->isHostValid) {
                return '';
            }
            $this->isHostValid = false;
            throw new SuspiciousOperationException(sprintf('Untrusted Host "%s".', $host));
        }
        return $host;
    }
    /**
     * Sets the request method.
     *
     * @param string $method
     */
    public function setMethod($method)
    {
        $this->method = null;
        $this->server->set('REQUEST_METHOD', $method);
    }
    /**
     * Gets the request "intended" method.
     *
     * If the X-HTTP-Method-Override header is set, and if the method is a POST,
     * then it is used to determine the "real" intended HTTP method.
     *
     * The _method request parameter can also be used to determine the HTTP method,
     * but only if enableHttpMethodParameterOverride() has been called.
     *
     * The method is always an uppercased string.
     *
     * @return string The request method
     *
     * @see getRealMethod()
     */
    public function getMethod()
    {
        if (null === $this->method) {
            $this->method = strtoupper($this->server->get('REQUEST_METHOD', 'GET'));
            if ('POST' === $this->method) {
                if ($method = $this->headers->get('X-HTTP-METHOD-OVERRIDE')) {
                    $this->method = strtoupper($method);
                } elseif (self::$httpMethodParameterOverride) {
                    $this->method = strtoupper($this->request->get('_method', $this->query->get('_method', 'POST')));
                }
            }
        }
        return $this->method;
    }
    /**
     * Gets the "real" request method.
     *
     * @return string The request method
     *
     * @see getMethod()
     */
    public function getRealMethod()
    {
        return strtoupper($this->server->get('REQUEST_METHOD', 'GET'));
    }
    /**
     * Gets the mime type associated with the format.
     *
     * @param string $format The format
     *
     * @return string The associated mime type (null if not found)
     */
    public function getMimeType($format)
    {
        if (null === static::$formats) {
            static::initializeFormats();
        }
        return isset(static::$formats[$format]) ? static::$formats[$format][0] : null;
    }
    /**
     * Gets the mime types associated with the format.
     *
     * @param string $format The format
     *
     * @return array The associated mime types
     */
    public static function getMimeTypes($format)
    {
        if (null === static::$formats) {
            static::initializeFormats();
        }
        return isset(static::$formats[$format]) ? static::$formats[$format] : array();
    }
    /**
     * Gets the format associated with the mime type.
     *
     * @param string $mimeType The associated mime type
     *
     * @return string|null The format (null if not found)
     */
    public function getFormat($mimeType)
    {
        $canonicalMimeType = null;
        if (false !== $pos = strpos($mimeType, ';')) {
            $canonicalMimeType = substr($mimeType, 0, $pos);
        }
        if (null === static::$formats) {
            static::initializeFormats();
        }
        foreach (static::$formats as $format => $mimeTypes) {
            if (in_array($mimeType, (array) $mimeTypes)) {
                return $format;
            }
            if (null !== $canonicalMimeType && in_array($canonicalMimeType, (array) $mimeTypes)) {
                return $format;
            }
        }
    }
    /**
     * Associates a format with mime types.
     *
     * @param string       $format    The format
     * @param string|array $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
     */
    public function setFormat($format, $mimeTypes)
    {
        if (null === static::$formats) {
            static::initializeFormats();
        }
        static::$formats[$format] = is_array($mimeTypes) ? $mimeTypes : array($mimeTypes);
    }
    /**
     * Gets the request format.
     *
     * Here is the process to determine the format:
     *
     *  * format defined by the user (with setRequestFormat())
     *  * _format request attribute
     *  * $default
     *
     * @param string $default The default format
     *
     * @return string The request format
     */
    public function getRequestFormat($default = 'html')
    {
        if (null === $this->format) {
            $this->format = $this->attributes->get('_format', $default);
        }
        return $this->format;
    }
    /**
     * Sets the request format.
     *
     * @param string $format The request format
     */
    public function setRequestFormat($format)
    {
        $this->format = $format;
    }
    /**
     * Gets the format associated with the request.
     *
     * @return string|null The format (null if no content type is present)
     */
    public function getContentType()
    {
        return $this->getFormat($this->headers->get('CONTENT_TYPE'));
    }
    /**
     * Sets the default locale.
     *
     * @param string $locale
     */
    public function setDefaultLocale($locale)
    {
        $this->defaultLocale = $locale;
        if (null === $this->locale) {
            $this->setPhpDefaultLocale($locale);
        }
    }
    /**
     * Get the default locale.
     *
     * @return string
     */
    public function getDefaultLocale()
    {
        return $this->defaultLocale;
    }
    /**
     * Sets the locale.
     *
     * @param string $locale
     */
    public function setLocale($locale)
    {
        $this->setPhpDefaultLocale($this->locale = $locale);
    }
    /**
     * Get the locale.
     *
     * @return string
     */
    public function getLocale()
    {
        return null === $this->locale ? $this->defaultLocale : $this->locale;
    }
    /**
     * Checks if the request method is of specified type.
     *
     * @param string $method Uppercase request method (GET, POST etc)
     *
     * @return bool
     */
    public function isMethod($method)
    {
        return $this->getMethod() === strtoupper($method);
    }
    /**
     * Checks whether or not the method is safe.
     *
     * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
     *
     * @param bool $andCacheable Adds the additional condition that the method should be cacheable. True by default.
     *
     * @return bool
     */
    public function isMethodSafe(/* $andCacheable = true */)
    {
        if (!func_num_args() || func_get_arg(0)) {
            // This deprecation should be turned into a BadMethodCallException in 4.0 (without adding the argument in the signature)
            // then setting $andCacheable to false should be deprecated in 4.1
            @trigger_error('Checking only for cacheable HTTP methods with Symfony\Component\HttpFoundation\Request::isMethodSafe() is deprecated since version 3.2 and will throw an exception in 4.0. Disable checking only for cacheable methods by calling the method with `false` as first argument or use the Request::isMethodCacheable() instead.', E_USER_DEPRECATED);
            return in_array($this->getMethod(), array('GET', 'HEAD'));
        }
        return in_array($this->getMethod(), array('GET', 'HEAD', 'OPTIONS', 'TRACE'));
    }
    /**
     * Checks whether or not the method is idempotent.
     *
     * @return bool
     */
    public function isMethodIdempotent()
    {
        return in_array($this->getMethod(), array('HEAD', 'GET', 'PUT', 'DELETE', 'TRACE', 'OPTIONS', 'PURGE'));
    }
    /**
     * Checks whether the method is cacheable or not.
     *
     * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
     *
     * @return bool
     */
    public function isMethodCacheable()
    {
        return in_array($this->getMethod(), array('GET', 'HEAD'));
    }
    /**
     * Returns the request body content.
     *
     * @param bool $asResource If true, a resource will be returned
     *
     * @return string|resource The request body content or a resource to read the body stream
     *
     * @throws \LogicException
     */
    public function getContent($asResource = false)
    {
        $currentContentIsResource = is_resource($this->content);
        if (PHP_VERSION_ID < 50600 && false === $this->content) {
            throw new \LogicException('getContent() can only be called once when using the resource return type and PHP below 5.6.');
        }
        if (true === $asResource) {
            if ($currentContentIsResource) {
                rewind($this->content);
                return $this->content;
            }
            // Content passed in parameter (test)
            if (is_string($this->content)) {
                $resource = fopen('php://temp', 'r+');
                fwrite($resource, $this->content);
                rewind($resource);
                return $resource;
            }
            $this->content = false;
            return fopen('php://input', 'rb');
        }
        if ($currentContentIsResource) {
            rewind($this->content);
            return stream_get_contents($this->content);
        }
        if (null === $this->content || false === $this->content) {
            $this->content = file_get_contents('php://input');
        }
        return $this->content;
    }
    /**
     * Gets the Etags.
     *
     * @return array The entity tags
     */
    public function getETags()
    {
        return preg_split('/\s*,\s*/', $this->headers->get('if_none_match'), null, PREG_SPLIT_NO_EMPTY);
    }
    /**
     * @return bool
     */
    public function isNoCache()
    {
        return $this->headers->hasCacheControlDirective('no-cache') || 'no-cache' == $this->headers->get('Pragma');
    }
    /**
     * Returns the preferred language.
     *
     * @param array $locales An array of ordered available locales
     *
     * @return string|null The preferred locale
     */
    public function getPreferredLanguage(array $locales = null)
    {
        $preferredLanguages = $this->getLanguages();
        if (empty($locales)) {
            return isset($preferredLanguages[0]) ? $preferredLanguages[0] : null;
        }
        if (!$preferredLanguages) {
            return $locales[0];
        }
        $extendedPreferredLanguages = array();
        foreach ($preferredLanguages as $language) {
            $extendedPreferredLanguages[] = $language;
            if (false !== $position = strpos($language, '_')) {
                $superLanguage = substr($language, 0, $position);
                if (!in_array($superLanguage, $preferredLanguages)) {
                    $extendedPreferredLanguages[] = $superLanguage;
                }
            }
        }
        $preferredLanguages = array_values(array_intersect($extendedPreferredLanguages, $locales));
        return isset($preferredLanguages[0]) ? $preferredLanguages[0] : $locales[0];
    }
    /**
     * Gets a list of languages acceptable by the client browser.
     *
     * @return array Languages ordered in the user browser preferences
     */
    public function getLanguages()
    {
        if (null !== $this->languages) {
            return $this->languages;
        }
        $languages = AcceptHeader::fromString($this->headers->get('Accept-Language'))->all();
        $this->languages = array();
        foreach ($languages as $lang => $acceptHeaderItem) {
            if (false !== strpos($lang, '-')) {
                $codes = explode('-', $lang);
                if ('i' === $codes[0]) {
                    // Language not listed in ISO 639 that are not variants
                    // of any listed language, which can be registered with the
                    // i-prefix, such as i-cherokee
                    if (count($codes) > 1) {
                        $lang = $codes[1];
                    }
                } else {
                    for ($i = 0, $max = count($codes); $i < $max; ++$i) {
                        if ($i === 0) {
                            $lang = strtolower($codes[0]);
                        } else {
                            $lang .= '_'.strtoupper($codes[$i]);
                        }
                    }
                }
            }
            $this->languages[] = $lang;
        }
        return $this->languages;
    }
    /**
     * Gets a list of charsets acceptable by the client browser.
     *
     * @return array List of charsets in preferable order
     */
    public function getCharsets()
    {
        if (null !== $this->charsets) {
            return $this->charsets;
        }
        return $this->charsets = array_keys(AcceptHeader::fromString($this->headers->get('Accept-Charset'))->all());
    }
    /**
     * Gets a list of encodings acceptable by the client browser.
     *
     * @return array List of encodings in preferable order
     */
    public function getEncodings()
    {
        if (null !== $this->encodings) {
            return $this->encodings;
        }
        return $this->encodings = array_keys(AcceptHeader::fromString($this->headers->get('Accept-Encoding'))->all());
    }
    /**
     * Gets a list of content types acceptable by the client browser.
     *
     * @return array List of content types in preferable order
     */
    public function getAcceptableContentTypes()
    {
        if (null !== $this->acceptableContentTypes) {
            return $this->acceptableContentTypes;
        }
        return $this->acceptableContentTypes = array_keys(AcceptHeader::fromString($this->headers->get('Accept'))->all());
    }
    /**
     * Returns true if the request is a XMLHttpRequest.
     *
     * It works if your JavaScript library sets an X-Requested-With HTTP header.
     * It is known to work with common JavaScript frameworks:
     *
     * @see http://en.wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
     *
     * @return bool true if the request is an XMLHttpRequest, false otherwise
     */
    public function isXmlHttpRequest()
    {
        return 'XMLHttpRequest' == $this->headers->get('X-Requested-With');
    }
    /*
     * The following methods are derived from code of the Zend Framework (1.10dev - 2010-01-24)
     *
     * Code subject to the new BSD license (http://framework.zend.com/license/new-bsd).
     *
     * Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
     */
    protected function prepareRequestUri()
    {
        $requestUri = '';
        if ($this->headers->has('X_ORIGINAL_URL')) {
            // IIS with Microsoft Rewrite Module
            $requestUri = $this->headers->get('X_ORIGINAL_URL');
            $this->headers->remove('X_ORIGINAL_URL');
            $this->server->remove('HTTP_X_ORIGINAL_URL');
            $this->server->remove('UNENCODED_URL');
            $this->server->remove('IIS_WasUrlRewritten');
        } elseif ($this->headers->has('X_REWRITE_URL')) {
            // IIS with ISAPI_Rewrite
            $requestUri = $this->headers->get('X_REWRITE_URL');
            $this->headers->remove('X_REWRITE_URL');
        } elseif ($this->server->get('IIS_WasUrlRewritten') == '1' && $this->server->get('UNENCODED_URL') != '') {
            // IIS7 with URL Rewrite: make sure we get the unencoded URL (double slash problem)
            $requestUri = $this->server->get('UNENCODED_URL');
            $this->server->remove('UNENCODED_URL');
            $this->server->remove('IIS_WasUrlRewritten');
        } elseif ($this->server->has('REQUEST_URI')) {
            $requestUri = $this->server->get('REQUEST_URI');
            // HTTP proxy reqs setup request URI with scheme and host [and port] + the URL path, only use URL path
            $schemeAndHttpHost = $this->getSchemeAndHttpHost();
            if (strpos($requestUri, $schemeAndHttpHost) === 0) {
                $requestUri = substr($requestUri, strlen($schemeAndHttpHost));
            }
        } elseif ($this->server->has('ORIG_PATH_INFO')) {
            // IIS 5.0, PHP as CGI
            $requestUri = $this->server->get('ORIG_PATH_INFO');
            if ('' != $this->server->get('QUERY_STRING')) {
                $requestUri .= '?'.$this->server->get('QUERY_STRING');
            }
            $this->server->remove('ORIG_PATH_INFO');
        }
        // normalize the request URI to ease creating sub-requests from this request
        $this->server->set('REQUEST_URI', $requestUri);
        return $requestUri;
    }
    /**
     * Prepares the base URL.
     *
     * @return string
     */
    protected function prepareBaseUrl()
    {
        $filename = basename($this->server->get('SCRIPT_FILENAME'));
        if (basename($this->server->get('SCRIPT_NAME')) === $filename) {
            $baseUrl = $this->server->get('SCRIPT_NAME');
        } elseif (basename($this->server->get('PHP_SELF')) === $filename) {
            $baseUrl = $this->server->get('PHP_SELF');
        } elseif (basename($this->server->get('ORIG_SCRIPT_NAME')) === $filename) {
            $baseUrl = $this->server->get('ORIG_SCRIPT_NAME'); // 1and1 shared hosting compatibility
        } else {
            // Backtrack up the script_filename to find the portion matching
            // php_self
            $path = $this->server->get('PHP_SELF', '');
            $file = $this->server->get('SCRIPT_FILENAME', '');
            $segs = explode('/', trim($file, '/'));
            $segs = array_reverse($segs);
            $index = 0;
            $last = count($segs);
            $baseUrl = '';
            do {
                $seg = $segs[$index];
                $baseUrl = '/'.$seg.$baseUrl;
                ++$index;
            } while ($last > $index && (false !== $pos = strpos($path, $baseUrl)) && 0 != $pos);
        }
        // Does the baseUrl have anything in common with the request_uri?
        $requestUri = $this->getRequestUri();
        if ($baseUrl && false !== $prefix = $this->getUrlencodedPrefix($requestUri, $baseUrl)) {
            // full $baseUrl matches
            return $prefix;
        }
        if ($baseUrl && false !== $prefix = $this->getUrlencodedPrefix($requestUri, rtrim(dirname($baseUrl), '/'.DIRECTORY_SEPARATOR).'/')) {
            // directory portion of $baseUrl matches
            return rtrim($prefix, '/'.DIRECTORY_SEPARATOR);
        }
        $truncatedRequestUri = $requestUri;
        if (false !== $pos = strpos($requestUri, '?')) {
            $truncatedRequestUri = substr($requestUri, 0, $pos);
        }
        $basename = basename($baseUrl);
        if (empty($basename) || !strpos(rawurldecode($truncatedRequestUri), $basename)) {
            // no match whatsoever; set it blank
            return '';
        }
        // If using mod_rewrite or ISAPI_Rewrite strip the script filename
        // out of baseUrl. $pos !== 0 makes sure it is not matching a value
        // from PATH_INFO or QUERY_STRING
        if (strlen($requestUri) >= strlen($baseUrl) && (false !== $pos = strpos($requestUri, $baseUrl)) && $pos !== 0) {
            $baseUrl = substr($requestUri, 0, $pos + strlen($baseUrl));
        }
        return rtrim($baseUrl, '/'.DIRECTORY_SEPARATOR);
    }
    /**
     * Prepares the base path.
     *
     * @return string base path
     */
    protected function prepareBasePath()
    {
        $filename = basename($this->server->get('SCRIPT_FILENAME'));
        $baseUrl = $this->getBaseUrl();
        if (empty($baseUrl)) {
            return '';
        }
        if (basename($baseUrl) === $filename) {
            $basePath = dirname($baseUrl);
        } else {
            $basePath = $baseUrl;
        }
        if ('\\' === DIRECTORY_SEPARATOR) {
            $basePath = str_replace('\\', '/', $basePath);
        }
        return rtrim($basePath, '/');
    }
    /**
     * Prepares the path info.
     *
     * @return string path info
     */
    protected function preparePathInfo()
    {
        $baseUrl = $this->getBaseUrl();
        if (null === ($requestUri = $this->getRequestUri())) {
            return '/';
        }
        // Remove the query string from REQUEST_URI
        if ($pos = strpos($requestUri, '?')) {
            $requestUri = substr($requestUri, 0, $pos);
        }
        $pathInfo = substr($requestUri, strlen($baseUrl));
        if (null !== $baseUrl && (false === $pathInfo || '' === $pathInfo)) {
            // If substr() returns false then PATH_INFO is set to an empty string
            return '/';
        } elseif (null === $baseUrl) {
            return $requestUri;
        }
        return (string) $pathInfo;
    }
    /**
     * Initializes HTTP request formats.
     */
    protected static function initializeFormats()
    {
        static::$formats = array(
            'html' => array('text/html', 'application/xhtml+xml'),
            'txt' => array('text/plain'),
            'js' => array('application/javascript', 'application/x-javascript', 'text/javascript'),
            'css' => array('text/css'),
            'json' => array('application/json', 'application/x-json'),
            'xml' => array('text/xml', 'application/xml', 'application/x-xml'),
            'rdf' => array('application/rdf+xml'),
            'atom' => array('application/atom+xml'),
            'rss' => array('application/rss+xml'),
            'form' => array('application/x-www-form-urlencoded'),
        );
    }
    /**
     * Sets the default PHP locale.
     *
     * @param string $locale
     */
    private function setPhpDefaultLocale($locale)
    {
        // if either the class Locale doesn't exist, or an exception is thrown when
        // setting the default locale, the intl module is not installed, and
        // the call can be ignored:
        try {
            if (class_exists('Locale', false)) {
                \Locale::setDefault($locale);
            }
        } catch (\Exception $e) {
        }
    }
    /*
     * Returns the prefix as encoded in the string when the string starts with
     * the given prefix, false otherwise.
     *
     * @param string $string The urlencoded string
     * @param string $prefix The prefix not encoded
     *
     * @return string|false The prefix as it is encoded in $string, or false
     */
    private function getUrlencodedPrefix($string, $prefix)
    {
        if (0 !== strpos(rawurldecode($string), $prefix)) {
            return false;
        }
        $len = strlen($prefix);
        if (preg_match(sprintf('#^(%%[[:xdigit:]]{2}|.){%d}#', $len), $string, $match)) {
            return $match[0];
        }
        return false;
    }
    private static function createRequestFromFactory(array $query = array(), array $request = array(), array $attributes = array(), array $cookies = array(), array $files = array(), array $server = array(), $content = null)
    {
        if (self::$requestFactory) {
            $request = call_user_func(self::$requestFactory, $query, $request, $attributes, $cookies, $files, $server, $content);
            if (!$request instanceof self) {
                throw new \LogicException('The Request factory must return an instance of Symfony\Component\HttpFoundation\Request.');
            }
            return $request;
        }
        return new static($query, $request, $attributes, $cookies, $files, $server, $content);
    }
    /**
     * Indicates whether this request originated from a trusted proxy.
     *
     * This can be useful to determine whether or not to trust the
     * contents of a proxy-specific header.
     *
     * @return bool true if the request came from a trusted proxy, false otherwise
     */
    public function isFromTrustedProxy()
    {
        return self::$trustedProxies && IpUtils::checkIp($this->server->get('REMOTE_ADDR'), self::$trustedProxies);
    }
    private function normalizeAndFilterClientIps(array $clientIps, $ip)
    {
        $clientIps[] = $ip; // Complete the IP chain with the IP the request actually came from
        $firstTrustedIp = null;
        foreach ($clientIps as $key => $clientIp) {
            // Remove port (unfortunately, it does happen)
            if (preg_match('{((?:\d+\.){3}\d+)\:\d+}', $clientIp, $match)) {
                $clientIps[$key] = $clientIp = $match[1];
            }
            if (!filter_var($clientIp, FILTER_VALIDATE_IP)) {
                unset($clientIps[$key]);
                continue;
            }
            if (IpUtils::checkIp($clientIp, self::$trustedProxies)) {
                unset($clientIps[$key]);
                // Fallback to this when the client IP falls into the range of trusted proxies
                if (null === $firstTrustedIp) {
                    $firstTrustedIp = $clientIp;
                }
            }
        }
        // Now the IP chain contains only untrusted proxies and the client IP
        return $clientIps ? array_reverse($clientIps) : array($firstTrustedIp);
    }
}

-


@snicolet : why did you approve this test ?
We could have used  1652 directly into master and 1371 (or any other value) in this test.


<img width="1152" alt="chapter6_6 16_guass_0" src="https://cloud.githubusercontent.com/assets/22126475/21294090/88ad331e-c570-11e6-8b54-88d287756c6c.png">
![Uploading chapter6_6.16_plucked_0.png…]()
![Uploading chapter6_6.16_sine_0.png…]()


why /has ?


Why do we need this? Please remove. Thanks


I used not to like maven, but that was more because I thought i culdn't understand it. after I started using it it was like heaven. :D

________________________________
Van: James <notifications@github.com>
Verzonden: zaterdag 17 december 2016 20:38
Aan: 10becja/ChessCraft
CC: zweeffan; Comment
Onderwerp: Re: [10becja/ChessCraft] bad maven, bad! (7b6a6a1)

The commit message was meant to be humorous. I don't actually think Maven is bad, I just don't like using it. Besides, those steps wouldn't have worked anyway for my code changes.

When I build my code I just use Eclipse to export a jar. For convenience I then put that in a different github repo.

-
You are receiving this because you commented.
Reply to this email directly, view it on GitHub<https://github.com/10becja/ChessCraft/commit/7b6a6a161fe1a7b5597c67856884235fc0366ad2#commitcomment-20224560>, or mute the thread<https://github.com/notifications/unsubscribe-auth/ABQb_wSJeEDHH3smTceICVegK68WcCvfks5rJEg_gaJpZM4LP3Qz>.


Not sure... o_O
I grabbed latest master, ran all the tests and this one failed


<img width="1152" alt="chapter6_6 16_sine_0" src="https://cloud.githubusercontent.com/assets/22126475/21294103/b697d93c-c570-11e6-8e3a-fc13f075161e.png">


同上面的疑问，这里的0从何而来？


Yes


Как-то много скобочек и плюсов в 52-й строке. Вначале подумал про новые возможности js в плане фукционального программирования — `reduce`. А потом вспомнил, что есть стандартная функция в прототипе массива — `join`:
`WORLD.toString = function(){
return WORLD.plan.join('<br>")
}`


hi


<img width="1152" alt="chapter6_6 16_sine_0" src="https://cloud.githubusercontent.com/assets/22126475/21294138/2a28523c-c571-11e6-9e63-41465555641c.png">


Anh Công ơi,
Cho em hỏi mấy kỹ thuật một tí Anh nghe.

   1. Mô hình cài đặt OpenStack Newton (
   https://github.com/vietstacker/OpenStack-Newton-Scripts/blob/master/README.md)
   thì mình cần tạo 3 NIC phải không Anh!
   2. Em tạo 3 NIC, bao gồm:
      - VMNet8 (NAT): 172.16.69.0/24       => 172.16.69.30
      - VMNet1 (HostOnly): 10.10.10.0/24 => 10.10.10.30
      - VNNet2 (HostOnly): 10.10.20.0/24 => 10.10.20.30
      - fdsf\

Nhưng lúc truy cập ở máy Windows vào http://172.16.69.30/horizon và chạy
Instances (cirros) thì nó trỏ về 10.10.10.30.

Lỗi chỗ nào em không thể ping từ Windows vào 10.10.10.30 hay 10.10.20.30
được đó Anh! Mặc dù em đã đổi IP ở card ảo trong Windows.

- Em muốn nó cùng chạy trên 1 IP (172.16.69.30) thì phải làm sao vậy Anh!

*Em cảm ơn Anh!!!*

[image: Inline image 1][image: Inline image 2]
[image: Inline image 3]

2016-12-18 20:54 GMT+07:00 Homework <itsourcevn@gmail.com>:

> Dạ, em cảm ơn Anh!
> Em quên mất cái đó trên compute, controller thì có ạ.
> Chúc Anh cuối tuần vui!!!
>
> On Sun, Dec 18, 2016 at 8:36 PM, Tô Thành Công <notifications@github.com>
> wrote:
>
>> Em chưa enable chế độ VT khi tạo các máy ảo để cài OpenStack (máy CTL và
>> COM)
>>
>> Tham khảo: http://3lemny.net/wp-content/uploads/2016/07/Intel-VT-x-and-
>> AMD-V.png
>>
>> —
>> You are receiving this because you commented.
>> Reply to this email directly, view it on GitHub
>> <https://github.com/vietstacker/OpenStack-Newton-Scripts/commit/287034f3e96708c157532f86719ada2aff1feda3#commitcomment-20226190>,
>> or mute the thread
>> <https://github.com/notifications/unsubscribe-auth/AO0EZLaYPpmO272rWUw-j_DlcH9fG9BFks5rJTbogaJpZM4LQDyE>
>> .
>>
>
>


pythonda nesne alanları init içerisinde assign edilerek tanımlanır. burada tanımlanan değişkenler javadaki static variable gibi oluyor. arada şöyle bir fark var yalnız
mesela
p = Point()
p.x = 3
dersen Point e ait olan x e atama yapmaz, instance a ait olana yapar
dynamic type dillerde atama ve erişme şu şekilde gerçekleşir
atama:
a.field1 = 1
a instance ının field1 alanına atama yapar, miras aldığı kimseye dokunmaz
b = a.field1
a da field1 var mı bakar yoksa inherit ettiği class a bakar yoksa onun üstündekine, bulduğunu getirir
dolayısıyla mesela
a = Point()
b = Point()
a.x = 2
dediğin zaman b.x hala None gösterecektir


pythonda tab kullanılmaz, 4 boşluk kullanman lazım


前两个测试里已经有这个问题，在这个里特别明显，这里引入result1,2,3并没有增加可读性。建议去掉。
一个assert涉及的输入和输出应该越集中越好，你可以想象一下读的人眼球需要扫过多大范围才能理解这句话来评估是否足够清楚了。

另外这个测试中的结果与前面discount值之间的关系我还是没有完全理解。


yine bunlar init içerisinde tanımlanmalı, ki tanımlanmış zaten sil gitsin


s/interna/internal/


You forgot to change 2bwm.c line 1903 to:

```
bool inv = conf.inverted_colors;
```


bunun yerine
```
@property
def points(self):
    return [self.l_top, self.r_top, self.r_bot, self.l_bot]
```
daha iyi olabilir, adam rectangular uzerinde iterate edince ne geldigini straightforward olarak anlayamayacak okumasi gerekecek class i


Added GitPages


```
return any(
 			(c1==self.l_top and c2==self.r_top) or
 			(c1==self.r_top and c2==self.l_top) or
 			(c1==self.r_top and c2==self.r_bot) or
 			(c1==self.r_bot and c2==self.r_top) or
 			(c1==self.r_bot and c2==self.l_bot) or
 			(c1==self.l_bot and c2==self.r_bot) or
 			(c1==self.l_bot and c2==self.l_top) or
 			(c1==self.l_top and c2==self.l_bot) )
```


guzel


This is unsafe: you create array with 3 elements length, but enter 10 elements into it.


最末尾的三个测试引起我的一个疑问：
如果已经有处理hot season的类了，为什么base setting仍然暴露这3个接口？
是base setting仅仅作为二传手把真正实现类的结果转手提供一遍？
还是hot season是个贫血类，仅仅有数据，要靠base setting操控它才能提供服务？


<img width="576" alt="chapter6_6 16_highsine_c" src="https://cloud.githubusercontent.com/assets/22126475/21294192/50941680-c572-11e6-92f1-7886b68aa1e1.png">
![chapter6_6 16_plucked_c](https://cloud.githubusercontent.com/assets/22126475/21294193/50e2435a-c572-11e6-8bc1-3bd681fb0391.png)


üçüncü edge2 olmalı


else e gerek yok


![Uploading chapter6_6.16_plucked_c.png…]()


"Credits: @ParanoidAndroid for the idea of submenus for battery styles" not just the idea, this whole implementation is a straight kang from https://github.com/AOSPA/android_packages_apps_Settings/commit/99c13a7c3b4e9cb96aa22c79f4b93295c55d3edc


硬编码的测试数据与它影响到的输出距离太远。
另一个倾向是所有测试共用一套数据，随着代码变动会越来越难以维护。


Spoko :) Możeby jeszcze przeciążyć setRGB aby updatował także tablicę hsv oraz stworzyć setHSV , który updatował by obydwie tablice ???


You're right, it should be


aslına bakarsan ben şöyle yazardım bunu
```
if divis <= 0:
    return 0
result = float(divid)/divis
if -1.0 <= result <= 1.0:
    return acos(result)
return 0
```


bu tarz early returnler depth of decision i azalttigi icin okumada kolaylik saglar


The following doc(s) have been deployed to the [slashzerop](https://slashzerop-static-docs.pantheonsite.io/docs) Multidev environment:
- [docs/redirects](https://slashzerop-static-docs.pantheonsite.io/docs/redirects)


@denishoornaert je me suis permis de delete :stuck_out_tongue:


Should the `/v1` be listed in here?  I'm getting a 405 Method Not Allowed when trying to use this endpoint


![chapter6_6 16_plucked_c](https://cloud.githubusercontent.com/assets/22126475/21294236/27ca19ba-c573-11e6-955b-42a607677049.png)


oups, faut que je remette a `false` c'était pour mes tests xD


Maintenant dans "Scanner" :wink:


Actually no, it is setting up the arguments for EmuX86_Write, which reads the parameters from the stack. The callee function will automatically pop the mem_base value itself after execution.

The corresponding pop for the first push statement is at line 233, after EmuX86_Write is called


Nice idea!
Can you figure out a solution without nested loop?
Hint: you might want to rely on int<->char relation to use char as index in an array that will accumulate number of a char repetitions.


opencv2.framework.zip can not unzip : https://github.com/kylefleming/opencv/releases/download/3.1.0-ios-fix/opencv2.framework.zip


ok


All spellmgr.cpp is "a hack" xd


![6power spectrum](https://cloud.githubusercontent.com/assets/22026568/21294254/80699000-c573-11e6-9d6d-928b1c2a16f7.png)
![6string signal versus time](https://cloud.githubusercontent.com/assets/22026568/21294255/80c6289c-c573-11e6-82c3-6958da2b4639.png)
![6waves on a string fixed ends](https://cloud.githubusercontent.com/assets/22026568/21294257/81b5c6f4-c573-11e6-86a4-a990476d10ad.png)
![61power spectrum](https://cloud.githubusercontent.com/assets/22026568/21294256/810cc216-c573-11e6-9295-f31baee06481.png)


Freeing memory is missing.


La aussi c'était pour du test, faut que je remette comme c'était :confused:


Memory freeing.


I think this is `{{ getModVar(...) }}`, see https://github.com/zikula/core/blob/1.4/src/docs/Core-2.0/Twig/Functions.md#useful


Szuper!


> As long a add-on header is not changed is also not needed to change add-on version.

 Again, don't mix API version and addon version, please. API is for technical changes, to ensure compatibility. Addon version is (also) for functional changes. If I add a new feature to an addon, without changing the Kodi addon API, I will ofc, not bump the API version, but I will bump the addon version (for instance to announce to users, "hey new addon version x.y.z supports PVR backend feature foo". Seems, we are not talking the same language?!


no problem ;)


Gotcha. Makes sense now.


Why don't you readme, readme?


The dude keeps on digging himself a hole. All he had to do yesterday was come clean, apologize and clean up his source. Instead he went on the attack and fixed NOTHING.

Even his own users were calling him out on his bullshit hahaha What a joke!


Ok, I've read you! Now what?


Nothing more to say.


je vois que ma méthode plait :D


As it looked straightforward enough I've updated this myself here: 05a294ddb48cb7b36da6e4ee6c97b41c8ae958e7

I'm going to push a new release soon with a few minor bug fixes so this Flask documentation will go live at the same time. If anyone has any comments on it, now is the time!


it really working good, and i will really say bro that you have made that most powerfull tool this time :D

means integrating morpheus+venom=Everything <3


lll


Not only did he "attack" like @Mazda-- said, he claimed that the DU updater was kanged. Pretty funny to claim that something that has well documented commit history showing the progress and how it was developed is kanged. Also pretty funny seeing as how I developed it, pushed everything to my personal GitHub and merged in pull requests from other DU developers.

Check the history: https://github.com/DirtyUnicorns/android_packages_apps_DU-Updater/commits/n7x


He isn't going to ,he wants to use the excuse I didn't know so it dont count rather than just fix..I'm surprised by now he hasn't gone closed source..Github should not allow such violations..


OK if that fix for you let me know so I can find something else for my case...

the original commit is not safe?
https://github.com/myfluxi/android_kernel_lge_hammerhead/commit/dd778c06ef5e85b693377684cbaef8759693ee33

because that works at least I don't see it anymore and I don't see any other problem but tested very shortly...


or it's a fix for bad dbc data :P


consider replacing loop with simple inclusion check:
```
(c >= 'a' && c <= 'z')
```


0db1f2b, db means database; 0 means 0, so there is 0 database
... f2b means free 2 burp.
1 means one.
0 + 1 + 2 =3
a triangle has 3 faces.
illuminati confirmed


`community` can be reinstated


It's up to you, but you can move visible to the other side of this if statement that way it checks the flag first before wasting CPU time running through the whole visible function.


Consider `'A' - 'a'` to explicitly express your intention.
However, there is even better solution: `int toupper ( int c );`


Freeing memory.


Thy.


@Override где да?


ok great, the auto commit is working!


How about passwords with `'`, `\` or `%`
(Apparently this note was forgotten when LoginWrapper was merged)

Also, use [`void` (parenthesis are not needed in linked example)](https://developer.mozilla.org/pl/docs/Web/JavaScript/Referencje/Operatory/Operator_void) instead of `var x = `


Untam már, hogy mindig fals eredményt ad vissza a kpackage miatt (az most 5.29.1-es, a többi 5.29.0-s, és minden framework csomagra 5.29.1-es verziót ad).
Ehhez persze majd az új, 1.0.19-es uhubuild kell.


@gerardcl  m'agrada més la solució anterior... és més llegible. Aquesta peca una mica de DRY...


Is there a similar function for the user datas like usergetvar? It seems not.


+It is now possible to watch movie trailers within details page
+Added year info on search results
+Fixed an issue where cover didn't go under header properly
+Fixed box office numbering


I think no. You probably need to fetch the UserEntity and assign it to the template. cc @craigh


[tests/testthat/test-sumstat-mcmf.R:137:31:](https://github.com/statgenlmu/coala/blob/9cd8af221fd112ccc906cd3989e6e9132a5bf7c7/tests/testthat/test-sumstat-mcmf.R#L137) *style:* **Put spaces around all infix operators.**
```r
                    matrix(c(1/3, 0.25, 0.004), 1))
                             ~^~
```


Comme ça c'est plus simple :smile:


But the generator already created something like that.


See https://github.com/zikula-modules/Eternizer/blob/1.4.x/Resources/views/Helper/includeStandardFieldsDisplay.html.twig#L16


it is good !


It's space. There's a lot of *space* to get back.


I am aware, this check isn't perfect. If you can figure out a check that works, open an issue or pull request. Thanks.


@Sirhc95 That's cute. Start shit in one of our app repos. Because causing drama is something that you hate, but here you are. How about you take your own advice, Idiot!


The `language_id` for "SourcePawn" and "OpenSCAD" were accidentally changed in a previous commit. This commit changes them back to their original values.

The `language_id` values need to be immutable moving forward.


Thanks! Good contribution.


Before


[tests/testthat/test-sumstat-mcmf.R:137:31:](https://github.com/statgenlmu/coala/blob/c862d0d0b7a32c3adf7b3c2ea65f9768d4ab68d7/tests/testthat/test-sumstat-mcmf.R#L137) *style:* **Put spaces around all infix operators.**
```r
                    matrix(c(1/3, 0.25, 0.004), 1))
                             ~^~
```


Go for it. I know that I was being aggressive when I did some of this work.

Although instead of just reverting it you might want to consider
reimplementing it to make sure it only happens at the very end, as a
formatting pass.

On Sun, Dec 18, 2016, 2:13 AM Henric Trotzig <notifications@github.com>
wrote:

> I'm considering reverting this commit in an effort to release 2.0. Having
> to rely on moduleNameFormatter in order to replicate the old non-relative
> behavior ends up being complicated for our current setup (the Brigade
> codebase).
>
> I know there's plenty of discussion around this in #329
> <https://github.com/Galooshi/import-js/pull/329> and I okayed removing
> it. I still think it's a good idea, but I don't think we're quite ready for
> it yet.
>
> Any objections @lencioni <https://github.com/lencioni>? 😄
>
> —
> You are receiving this because you were mentioned.
> Reply to this email directly, view it on GitHub
> <https://github.com/Galooshi/import-js/commit/46910afe737fbd4b38d8bd3f6b2291c7114104ae#commitcomment-20225835>,
> or mute the thread
> <https://github.com/notifications/unsubscribe-auth/AAL7zoBcw-Rz7xcimhxd1btJSb18fZwJks5rJQdCgaJpZM4LQF-2>
> .
>


I will be happy to merge the fix from you.


@Keital , hi, man! JadeDB from old jadecore548-patched our source, we can use it for fixes.main DB is mopDB


Nested loops. Can you come up with one loop solution?


Freeing memory.


+value


I found this:
https://github.com/zikula/core/blob/1.4/src/docs/Core-2.0/Twig/GlobalVariables.md
That helps in my case.


maxAllowedPayIn = value > 0 ? +value : value;


out of index: you can enter more elements than the array `m` can fit.


Hmmhmm...  Í think I'm wrong...I need the user created the entry....


hello


If user data is for current user then you can use the currentUser global var


@Counter-pain think like a robot it make more time to change hero many condition make more time would you like that? and it need more time to dev can you help me?


Em học cách dùng vmware workstation rồi hãy làm về OpenStack thì sẽ rõ câu trả lời nhé.


Quadratic complexity.
Can you do better?


Freeing memory is missing.


Personally I'd prefer a leading backslash for class names in the paragraphs. Opinions?


Ouais pas mal... :cactus:


Thanks fixed now in commit 111f3c1fde1ee


Just a quick note in case you run into the same thing, when I tried stuff out on Thursday, I only got it to work with `node:argon` rather than `node:alpine` (and ideally we want to use the latter since it's much smaller). I think the issue was when it tried to install `node-sass` since I believe that's not pure JS (Ruby or something somewhere?). I didn't really investigate much, but if the issue persists, we could always switch that one style sheet to Stylus, which is virtually the same (better even) and pure JS.


Ok, so I will have a look in template for standard fields.
Thx to all.


package-private поля


@dreammed nah, just forget it.


Cool, I'll look into simplifying it at least.

On Sun, 18 Dec 2016 at 16:25, Joe Lencioni <notifications@github.com> wrote:

> Go for it. I know that I was being aggressive when I did some of this work.
>
>
>
>
>
> Although instead of just reverting it you might want to consider
>
>
> reimplementing it to make sure it only happens at the very end, as a
>
>
> formatting pass.
>
>
>
>
>
> On Sun, Dec 18, 2016, 2:13 AM Henric Trotzig <notifications@github.com>
>
>
> wrote:
>
>
>
>
>
> > I'm considering reverting this commit in an effort to release 2.0. Having
>
>
> > to rely on moduleNameFormatter in order to replicate the old non-relative
>
>
> > behavior ends up being complicated for our current setup (the Brigade
>
>
> > codebase).
>
>
> >
>
>
> > I know there's plenty of discussion around this in #329
>
>
> > <https://github.com/Galooshi/import-js/pull/329> and I okayed removing
>
>
> > it. I still think it's a good idea, but I don't think we're quite ready
> for
>
>
> > it yet.
>
>
> >
>
>
> > Any objections @lencioni <https://github.com/lencioni>? 😄
>
>
> >
>
>
> > —
>
>
> > You are receiving this because you were mentioned.
>
>
> > Reply to this email directly, view it on GitHub
>
>
> > <
> https://github.com/Galooshi/import-js/commit/46910afe737fbd4b38d8bd3f6b2291c7114104ae#commitcomment-20225835
> >,
>
>
> > or mute the thread
>
>
> > <
> https://github.com/notifications/unsubscribe-auth/AAL7zoBcw-Rz7xcimhxd1btJSb18fZwJks5rJQdCgaJpZM4LQF-2
> >
>
>
> > .
>
>
> >
>
>
>
>
>
>
> —
> You are receiving this because you commented.
> Reply to this email directly, view it on GitHub
> <https://github.com/Galooshi/import-js/commit/46910afe737fbd4b38d8bd3f6b2291c7114104ae#commitcomment-20226477>,
> or mute the thread
> <https://github.com/notifications/unsubscribe-auth/AAjS5YpH8NUfzJyY69DCufxtVEWzf3pIks5rJVBtgaJpZM4LQF-2>
> .
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>


did this fix bt deepsleep?


`--debug.level 2`?


Hello There !

This is Joel

I am passionate about programing


Looks goot to me


I can't look on your Connection((( Where is it?


I still personally think it's weird; you are In space & they mean "go back to space"


I'll change this for the shearing of the sheep.


Okay 👍


Well, after copying newer ajax3.js and delete assets folder, we got the same issue, after disabled and enabled dropdowmlist the value is null in server side. here is my code :

```
<com:TActiveDropDownList ID="cmbStatus" OnCallBack="changeStatus">
<prop:ClientSide.OnPreDispatch>
       Pace.stop();
       Pace.start();
       $('#<%=$this->cmbStatus->ClientId%>').prop('disabled',true);
</prop:ClientSide.OnPreDispatch>
<prop:ClientSide.OnLoading>
       $('#<%=$this->cmbStatus->ClientId%>').prop('disabled',true);
</prop:ClientSide.OnLoading>
<prop:ClientSide.OnComplete>
         $('#<%=$this->cmbStatus->ClientId%>').prop('disabled',false);
</prop:ClientSide.OnComplete>
</com:TActiveDropDownList>
```
php code
```
public function changeStatus ($sender,$param) {
sleep(5);
echo $sender->Text;
}
```