常連

### 前提・実現したいこと
Apacheのリバースプロキシを経由したリクエストの元々の（書き換え前の）RequestURLやRequestURIを取得したい。

（例）ユーザーが「http://my-app.com/test/url」にアクセスしてきた際、下記コード等にて「http://my-app.com/test/url」の文字列を取得したい。
```Java
String requestURL = new String(request.getRequestURL());
```

### 発生している問題・エラーメッセージ
①Apache httpd.confにて以下のプロキシ設定を行う。
```
ProxyPass /test/url ajp://○○○.○○○.○○○.○○○:○○○○/TestApp/
ProxyPassReverseCookiePath /TestApp /test/url/
ProxyPassReverse /test/url ajp://○○○.○○○.○○○.○○○:○○○○/TestApp/
```
②Servlet内で以下の処理を行う。
```
String requestURL = new String(request.getRequestURL());
```
③「http://my-app.com/test/url」へアクセスする。
```
取得したい文字列：http://my-app.com/test/url
実際に取得されてしまう文字列：https://○○○.○○○.○○○.○○○/TestApp/
```

### 試したこと

①Apache httpd.confに以下のような記述を追加
```
#追記１
RequestHeader set TestHeader "TestHeaderValue"
#追記２
RewriteEngine On
#追記３
RewriteCond %{REQUEST_URL} (.*)
RewriteRule .* - [E=X_REQUEST_URL:%1]
RequestHeader Set X-Request-URL %{X_REQUEST_URL}e
#追記４
RewriteCond %{REQUEST_URI} (.*)
RewriteRule .* - [E=X_REQUEST_URI:%{REQUEST_URI}]
RequestHeader Set X-Request-URI "%{X_REQUEST_URI}e"
#追記５
ProxyPreserveHost On
```
②Servlet内で以下の処理を追加
```java
System.out.println("TestHeader :" + request.getHeader("TestHeader"));
System.out.println("X-REQUEST-URL :" + request.getHeader("X-REQUEST-URL"));
System.out.println("X-REQUEST-URI :" + request.getHeader("X-REQUEST-URI"));
```
③出力結果
```
// 正しくヘッダに追加され、値が取得できている。
TestHeader :TestHeaderValue
// 値が「(null)」となってしまう
X-REQUEST-URL :(null)
// 値が「(null)」となってしまう
X-REQUEST-URI :(null)
```

調べると、上記の方法でRequestURIやRequestURLが取得出来ているという記述が見つかるのですが、
望んでいる動作となりません。
アドバイス頂けると幸いです。
質問に不備等ありましたら修正致しますので、ご指摘お願い致します。


### 補足情報（FW/ツールのバージョンなど）
・CentOS 7.4.1708
・Apache Httpd 2.4.6
・Tomcat 9.0.5
・OpenJDK 1.8.0_151

Apacheのリバースプロキシを経由したリクエストの元々のRequestURLを取得したい

### 背景

C++において関数（関数オブジェクト）を渡して動作をカスタマイズするという設計はよくあると思います。
実際、標準ライブラリ<algorithm>の関数群はそうなっています。
例えば、次のようにソートの第3引数に関数オブジェクトを渡すことはよくあるかと思います。

```cpp
#include <vector>
#include <algorithm>
#include <functional>

int
main() {
  std::vector v{ 1, 2, 3, 5, 9, 4 };
  std::sort(begin(v), end(v), std::greater<int>{});
  // v = [ 9, 5, 4, 3, 2, 1 ]
}
```



### 問題提起

`greater<int>{}`のようにいちいちテンプレートの`<>`を書くのがかっこ悪いです。
なんなら`{}`も邪魔くさいです。
`greater`と書けると嬉しいです。

### 質問

何らかの`foo`という作用があるとします。
`foo`はジェネリックなものとします。
`foo`を関数としても関数オブジェクトとしても使いやすくするためにはどういう設計をすれば良いのでしょうか？
なにか良い方法が無いものでしょうか？
やはりプリプロセッサマクロなのでしょうか？？？

### yohhoyさんの回答を受けて（追記）

次のように関数オブジェクトを定義し、その中でオーバーロードを行う。
その上で、あらかじめinline変数として関数オブジェクトのインスタンスを作っておく。

オーバーロードが自然にできるし、関数としても関数オブジェクトとしても使い勝手がいい。

これは、[**range-v3**](https://github.com/ericniebler/range-v3/)というC++20に提案されているライブラリの実験的実装でも使われている方法であった。
例えば[このソース](https://github.com/ericniebler/range-v3/blob/a2bf5d0596dd2ffc75c2623b62d6226915609622/include/range/v3/view/transform.hpp#L529)にみることができる。
もしかしたらこれが現状（C++17）におけるベストプラクティスなのかもしれないですね。

```cpp
struct foo_t {
  // generic version
  template <class T>
  T operator()(T a) { return a + a; }
  // specialized version
  int operator()(int a) { return a * 10; }
};

inline constexpr auto foo = foo_t{};
```


### 試したこと

#### 関数テンプレート

この方法は関数テンプレートを渡す際にどの実態化なのかを示すためテンプレートパラメータが必須になります。

```cpp
template < class T >
T foo(T a) { return a + a; }

std::vector<int> v{ ... };
std::vector<int> result;
std::transform( begin(v), end(v), std::back_inserter(result), foo<int> ); // bad
```

#### 関数オブジェクト

transparentな関数オブジェクトを使う方法。
コンストラクトしないと使えないが、テンプレートじゃないだけ多少マシ。

```cpp
struct foo {
  template < class T >
  T operator()(T a) { return a + a; }
};
std::vector<int> v{ ... };
std::vector<int> result;
std::transform( begin(v), end(v), std::back_inserter(result), foo{} );
```

ただ、普通の関数としてはダメ。

```cpp
foo{}(42); // bad
// ^
```

#### ラムダ式のラッパー

よくある方法として、transparentなラムダ式で関数テンプレートの呼び出しをラップするというものです。
欠点は、記述量が多すぎることです。
これを書くのはとてもとても面倒なことです。
あと、`std::forward<decltype(a)>(a)`がわからないとよく言われるので地味に困ります。

```cpp
// シンプル
std::transform( begin(v), end(v), std::back_inserter(result), [](auto a){ return foo(a); } );

// 完全転送
std::transform( begin(v), end(v), std::back_inserter(result),
                [](auto&& a){ return foo(std::forward<decltype(a)>(a)); } );
```

#### Globalラムダ式

関数オブジェクトのインスタンスを予め作っておくというアイデアですが、クラスを書くのも面倒なのでラムダ式を書きます。
関数テンプレートを書く代わりにラムダ式を書くことにします。

```cpp
inline auto foo = [](auto a){ return a + a; };

std::transform( begin(v), end(v), std::back_inserter(result), foo ); // nice!
```

副次効果として、C++17からラムダ式のoperator()がconstexpr指定されるのでこれいいなぁと思ったのですが、
**ラムダ式にしてしまうとオーバーロードしたくなっても簡単にはできないのです。**

```cpp
inline auto foo = [](auto a){ return a + a; };
inline auto foo = [](int a){ return a + 1; }; // redefinition!
```

C++における関数の受け渡しについて

### ■背景

以下リンクのように、特定のサイトで使用されているテクノロジーを紹介する記事を見て、果たして外部の人間がどのようにアーキテクチャを調べているのか、疑問に思いました。

[10 Popular Sites Made With Django](https://djangostars.com/blog/10-popular-sites-made-on-django/)


### ■質問
曖昧になるのを防ぐために、実在するサイトを例にお尋ねしたいと思います。

[Scores and Stats](https://www.scoresandstats.com/teams/baseball/mlb/los-angeles-dodgers/)

上記のサイトで、
①どのようなテクノロジーやフレームワークが使用されているか
②どうやってそれら①が使用されていることを確認されたか

を教えていただけると誠にありがたいです。小さなヒントでも大歓迎です。

例えば、使用言語やデータベースの種類など、以下のようなイメージでわかることなら何でも構いません。
PHP、Python、MySQL、Django、Scrapyなどなど。

![・イメージ1](946e6dab15a82f03403e15e48e895534.png)
ソース: [slideshare.net](https://www.slideshare.net/cjhacker/spider-12966847)

・イメージ2
ソース: [twitter.com](https://pbs.twimg.com/media/DHWcou0VoAEYI1L.jpg)

### ■質問者のスキル

- ChromeデベロッパーツールでHTML,CSSの大まかな構成を確認できる程度
- スクレイピングについて独習しており、お手本になりそうなサイトの構成を分析する入り口のところでつまずいています。