From 99072def67e54d664edd96b9c0f124c4f09cedee Mon Sep 17 00:00:00 2001
From: Oleg Morozenkov <omorozenkov@gmail.com>
Date: Wed, 29 Jul 2015 14:45:45 +0300
Subject: Fix includes + fix some minor bugs

---
 CMakeLists.txt                    |  18 +-
 include/tgbot/tools/StringTools.h |   3 +-
 samples/echobot/src/main.cpp      |   6 +-
 src/Api.cpp                       | 279 ++++++++++++++++++++++
 src/TgException.cpp               |  30 +++
 src/TgTypeParser.cpp              | 490 ++++++++++++++++++++++++++++++++++++++
 src/net/HttpClient.cpp            |  67 ++++++
 src/net/HttpParser.cpp            | 204 ++++++++++++++++
 src/net/TgLongPoll.cpp            |  43 ++++
 src/net/Url.cpp                   |  85 +++++++
 src/tgbot/Api.cpp                 | 275 ---------------------
 src/tgbot/TgException.cpp         |  30 ---
 src/tgbot/TgTypeParser.cpp        | 490 --------------------------------------
 src/tgbot/net/HttpClient.cpp      |  71 ------
 src/tgbot/net/HttpParser.cpp      | 204 ----------------
 src/tgbot/net/TgLongPoll.cpp      |  43 ----
 src/tgbot/net/Url.cpp             |  78 ------
 src/tgbot/tools/StringTools.cpp   | 113 ---------
 src/tools/StringTools.cpp         | 113 +++++++++
 19 files changed, 1323 insertions(+), 1319 deletions(-)
 create mode 100644 src/Api.cpp
 create mode 100644 src/TgException.cpp
 create mode 100644 src/TgTypeParser.cpp
 create mode 100644 src/net/HttpClient.cpp
 create mode 100644 src/net/HttpParser.cpp
 create mode 100644 src/net/TgLongPoll.cpp
 create mode 100644 src/net/Url.cpp
 delete mode 100644 src/tgbot/Api.cpp
 delete mode 100644 src/tgbot/TgException.cpp
 delete mode 100644 src/tgbot/TgTypeParser.cpp
 delete mode 100644 src/tgbot/net/HttpClient.cpp
 delete mode 100644 src/tgbot/net/HttpParser.cpp
 delete mode 100644 src/tgbot/net/TgLongPoll.cpp
 delete mode 100644 src/tgbot/net/Url.cpp
 delete mode 100644 src/tgbot/tools/StringTools.cpp
 create mode 100644 src/tools/StringTools.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ba9ae76..8fd3321 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,16 +7,16 @@ option(ENABLE_SAMPLES "Set to ON to enable building of samples" OFF)
 
 ### sources
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-include_directories("${PROJECT_SOURCE_DIR}/include")
+include_directories(include)
 set(SRC_LIST
-    src/tgbot/Api.cpp
-    src/tgbot/TgTypeParser.cpp
-    src/tgbot/TgException.cpp
-    src/tgbot/net/Url.cpp
-    src/tgbot/net/HttpClient.cpp
-    src/tgbot/net/HttpParser.cpp
-    src/tgbot/net/TgLongPoll.cpp
-    src/tgbot/tools/StringTools.cpp
+    src/Api.cpp
+    src/TgTypeParser.cpp
+    src/TgException.cpp
+    src/net/Url.cpp
+    src/net/HttpClient.cpp
+    src/net/HttpParser.cpp
+    src/net/TgLongPoll.cpp
+    src/tools/StringTools.cpp
 )
 
 ### libs
diff --git a/include/tgbot/tools/StringTools.h b/include/tgbot/tools/StringTools.h
index 0a01b0d..a8b4af1 100644
--- a/include/tgbot/tools/StringTools.h
+++ b/include/tgbot/tools/StringTools.h
@@ -63,9 +63,10 @@ std::string generateRandomString(size_t length);
 /**
  * Performs url encode.
  * @param value Source url string
+ * @param additionalLegitChars Optional. String of chars which will be not encoded in source url string.
  * @return Encoded url string
  */
-std::string urlEncode(const std::string& value);
+std::string urlEncode(const std::string& value, const std::string additionalLegitChars = "");
 
 /**
  * Performs url decode.
diff --git a/samples/echobot/src/main.cpp b/samples/echobot/src/main.cpp
index 7b8d880..61f4019 100644
--- a/samples/echobot/src/main.cpp
+++ b/samples/echobot/src/main.cpp
@@ -26,8 +26,6 @@
 
 #include <tgbot/Bot.h>
 #include <tgbot/net/TgLongPoll.h>
-#include <tgbot/TgException.h>
-#include <tgbot/tools/StringTools.h>
 
 using namespace std;
 using namespace TgBot;
@@ -52,7 +50,6 @@ int main() {
         bot.getApi().sendMessage(message->chat->id, "Your message is: " + message->text);
     });
 
-    printf("try {\n");
     try {
         printf("Bot username: %s\n", bot.getApi().getMe()->username.c_str());
 
@@ -61,10 +58,9 @@ int main() {
             printf("Long poll started\n");
             longPoll.start();
         }
-    } catch (TgException& e) {
+    } catch (exception& e) {
         printf("error: %s\n", e.what());
     }
-    printf("}\n");
 
     return 0;
 }
diff --git a/src/Api.cpp b/src/Api.cpp
new file mode 100644
index 0000000..0c04081
--- /dev/null
+++ b/src/Api.cpp
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/Api.h"
+
+#include "tgbot/TgTypeParser.h"
+#include "tgbot/TgException.h"
+#include "tgbot/net/HttpClient.h"
+
+using namespace std;
+using namespace boost::property_tree;
+
+namespace TgBot {
+
+Api::Api(const std::string& token) : _token(token) {
+}
+
+User::Ptr Api::getMe() const {
+    return TgTypeParser::getInstance().parseUser(sendRequest("getMe").find("result")->second);
+}
+
+Message::Ptr Api::sendMessage(int32_t chatId, const string& text, bool disableWebPagePreview, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("text", text));
+    if (disableWebPagePreview) {
+        args.push_back(HttpReqArg("disable_web_page_preview", disableWebPagePreview));
+    }
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendMessage", args).find("result")->second);
+}
+
+Message::Ptr Api::forwardMessage(int32_t chatId, int32_t fromChatId, int32_t messageId) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("from_chat_id", fromChatId));
+    args.push_back(HttpReqArg("message_id", messageId));
+    return TgTypeParser::getInstance().parseMessage(sendRequest("forwardMessage", args).find("result")->second);
+}
+
+Message::Ptr Api::sendPhoto(int32_t chatId, const InputFile::Ptr& photo, const string& caption, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("photo", photo->data, true, photo->mimeType));
+    if (!caption.empty()) {
+        args.push_back(HttpReqArg("caption", caption));
+    }
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendPhoto", args).find("result")->second);
+}
+
+Message::Ptr Api::sendPhoto(int32_t chatId, const string& photo, const string& caption, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("photo", photo));
+    if (!caption.empty()) {
+        args.push_back(HttpReqArg("caption", caption));
+    }
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendPhoto", args).find("result")->second);
+}
+
+Message::Ptr Api::sendAudio(int32_t chatId, const InputFile::Ptr& audio, int32_t duration, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("audio", audio->data, true, audio->mimeType));
+    if (duration) {
+        args.push_back(HttpReqArg("duration", duration));
+    }
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendAudio", args).find("result")->second);
+}
+
+Message::Ptr Api::sendAudio(int32_t chatId, const string& audio, int32_t duration, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("audio", audio));
+    if (duration) {
+        args.push_back(HttpReqArg("duration", duration));
+    }
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendAudio", args).find("result")->second);
+}
+
+Message::Ptr Api::sendDocument(int32_t chatId, const InputFile::Ptr& document, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("document", document->data, true, document->mimeType));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendDocument", args).find("result")->second);
+}
+
+Message::Ptr Api::sendDocument(int32_t chatId, const string& document, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("document", document));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendDocument", args).find("result")->second);
+}
+
+Message::Ptr Api::sendSticker(int32_t chatId, const InputFile::Ptr& sticker, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("sticker", sticker->data, true, sticker->mimeType));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendSticker", args).find("result")->second);
+}
+
+Message::Ptr Api::sendSticker(int32_t chatId, const string& sticker, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("sticker", sticker));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendSticker", args).find("result")->second);
+}
+
+Message::Ptr Api::sendVideo(int32_t chatId, const InputFile::Ptr& video, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("video", video->data, true, video->mimeType));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendVideo", args).find("result")->second);
+}
+
+Message::Ptr Api::sendVideo(int32_t chatId, const string& video, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("video", video));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendVideo", args).find("result")->second);
+}
+
+Message::Ptr Api::sendLocation(int32_t chatId, float latitude, float longitude, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("latitude", latitude));
+    args.push_back(HttpReqArg("longitude", longitude));
+    if (replyToMessageId) {
+        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
+    }
+    if (replyMarkup) {
+        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
+    }
+    return TgTypeParser::getInstance().parseMessage(sendRequest("sendLocation", args).find("result")->second);
+}
+
+void Api::sendChatAction(int32_t chatId, const string& action) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("chat_id", chatId));
+    args.push_back(HttpReqArg("action", action));
+    sendRequest("sendChatAction", args);
+}
+
+UserProfilePhotos::Ptr Api::getUserProfilePhotos(int32_t userId, int32_t offset, int32_t limit) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("user_id", userId));
+    if (offset) {
+        args.push_back(HttpReqArg("offset", offset));
+    }
+    limit = max(1, min(100, limit));
+    args.push_back(HttpReqArg("limit", limit));
+    return TgTypeParser::getInstance().parseUserProfilePhotos(sendRequest("getUserProfilePhotos", args).find("result")->second);
+}
+
+vector<Update::Ptr> Api::getUpdates(int32_t offset, int32_t limit, int32_t timeout) const {
+    vector<HttpReqArg> args;
+    if (offset) {
+        args.push_back(HttpReqArg("offset", offset));
+    }
+    limit = max(1, min(100, limit));
+    args.push_back(HttpReqArg("limit", limit));
+    if (timeout) {
+        args.push_back(HttpReqArg("timeout", timeout));
+    }
+    return TgTypeParser::getInstance().parseArray<Update>(TgTypeParser::getInstance().parseUpdate, sendRequest("getUpdates", args), "result");
+}
+
+void Api::setWebhook(const string& url) const {
+    vector<HttpReqArg> args;
+    args.push_back(HttpReqArg("url", url));
+    sendRequest("setWebhook", args);
+}
+
+boost::property_tree::ptree Api::sendRequest(const std::string& method, const std::vector<HttpReqArg>& args) const {
+    std::string url = "https://api.telegram.org/bot";
+    url += _token;
+    url += "/";
+	url += method;
+	string serverResponse = HttpClient::getInstance().makeRequest(url, args);
+	if (serverResponse.find("<html>") != serverResponse.npos) {
+		throw TgException("Bad request");
+	}
+	ptree result = TgTypeParser::getInstance().parseJson(serverResponse);
+	try {
+		if (result.get<bool>("ok")) {
+			return result;
+		} else {
+			throw TgException(result.get("description", ""));
+		}
+	} catch (boost::property_tree::ptree_error& e) {
+		throw TgException("");
+	}
+}
+
+}
diff --git a/src/TgException.cpp b/src/TgException.cpp
new file mode 100644
index 0000000..0c118ec
--- /dev/null
+++ b/src/TgException.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/TgException.h"
+
+namespace TgBot {
+
+TgBot::TgException::TgException(const std::string description) : runtime_error(description) {
+}
+
+}
diff --git a/src/TgTypeParser.cpp b/src/TgTypeParser.cpp
new file mode 100644
index 0000000..9a1f93a
--- /dev/null
+++ b/src/TgTypeParser.cpp
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software", "to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/TgTypeParser.h"
+
+using namespace std;
+using namespace boost::property_tree;
+
+namespace TgBot {
+
+TgTypeParser& TgTypeParser::getInstance() {
+    static TgTypeParser result;
+    return result;
+}
+
+User::Ptr TgTypeParser::parseUser(const ptree& data) const {
+    User::Ptr result(new User);
+    result->id = data.get<int32_t>("id");
+    result->firstName = data.get<string>("first_name");
+    result->lastName = data.get("last_name", "");
+    result->username = data.get("username", "");
+    return result;
+}
+
+string TgTypeParser::parseUser(const User::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "id", object->id);
+    appendToJson(result, "first_name", object->firstName);
+    appendToJson(result, "last_name", object->lastName);
+    appendToJson(result, "username", object->username);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+GroupChat::Ptr TgTypeParser::parseGroupChat(const ptree& data) const {
+    GroupChat::Ptr result(new GroupChat);
+    result->id = data.get<int32_t>("id");
+    result->title = data.get<string>("title");
+    return result;
+}
+
+string TgTypeParser::parseGroupChat(const GroupChat::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "id", object->id);
+    appendToJson(result, "title", object->title);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Message::Ptr TgTypeParser::parseMessage(const ptree& data) const {
+    Message::Ptr result(new Message);
+    result->messageId = data.get<int32_t>("message_id");
+    result->from = parseUser(data.find("from")->second);
+    result->date = data.get<int32_t>("date");
+    result->chat = parseGenericChat(data.find("chat")->second);
+    result->forwardFrom = tryParse<User>(parseUser, data, "forward_from");
+    result->forwardDate = data.get("forward_date", 0);
+    result->replyToMessage = tryParse<Message>(parseMessage, data, "reply_to_message");
+    result->text = data.get("text", "");
+    result->audio = tryParse<Audio>(parseAudio, data, "audio");
+    result->document = tryParse<Document>(parseDocument, data, "document");
+    result->photo = parseArray<PhotoSize>(parsePhotoSize, data, "photo");
+    result->sticker = tryParse<Sticker>(parseSticker, data, "sticker");
+    result->video = tryParse<Video>(parseVideo, data, "video");
+    result->contact = tryParse<Contact>(parseContact, data, "contact");
+    result->location = tryParse<Location>(parseLocation, data, "location");
+    result->newChatParticipant = tryParse<User>(parseUser, data, "new_chat_participant");
+    result->leftChatParticipant = tryParse<User>(parseUser, data, "left_chat_participant");
+    result->newChatTitle = data.get("new_chat_title", "");
+    result->newChatPhoto = parseArray<PhotoSize>(parsePhotoSize, data, "new_chat_photo");
+    result->deleteChatPhoto = data.get("delete_chat_photo", false);
+    result->groupChatCreated = data.get("group_chat_created", false);
+    result->caption = data.get("caption", false);
+    return result;
+}
+
+string TgTypeParser::parseMessage(const Message::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "message_id", object->messageId);
+    appendToJson(result, "from", parseUser(object->from));
+    appendToJson(result, "date", object->date);
+    appendToJson(result, "chat", parseGenericChat(object->chat));
+    appendToJson(result, "forward_from", parseUser(object->forwardFrom));
+    appendToJson(result, "forward_date", object->forwardDate);
+    appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
+    appendToJson(result, "text", object->text);
+    appendToJson(result, "audio", parseAudio(object->audio));
+    appendToJson(result, "document", parseDocument(object->document));
+    appendToJson(result, "photo", parseArray(parsePhotoSize, object->photo));
+    appendToJson(result, "sticker", parseSticker(object->sticker));
+    appendToJson(result, "video", parseVideo(object->video));
+    appendToJson(result, "contact", parseContact(object->contact));
+    appendToJson(result, "location", parseLocation(object->location));
+    appendToJson(result, "new_chat_participant", parseUser(object->newChatParticipant));
+    appendToJson(result, "left_chat_participant", parseUser(object->leftChatParticipant));
+    appendToJson(result, "new_chat_title", object->newChatTitle);
+    appendToJson(result, "new_chat_photo", parseArray(parsePhotoSize, object->newChatPhoto));
+    appendToJson(result, "delete_chat_photo", object->deleteChatPhoto);
+    appendToJson(result, "group_chat_created", object->groupChatCreated);
+    appendToJson(result, "caption", object->caption);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+PhotoSize::Ptr TgTypeParser::parsePhotoSize(const ptree& data) const {
+    PhotoSize::Ptr result(new PhotoSize);
+    result->fileId = data.get<string>("file_id");
+    result->width = data.get<int32_t>("width");
+    result->height = data.get<int32_t>("height");
+    result->fileSize = data.get("file_size", 0);
+    return result;
+}
+
+string TgTypeParser::parsePhotoSize(const PhotoSize::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "file_id", object->fileId);
+    appendToJson(result, "width", object->width);
+    appendToJson(result, "height", object->height);
+    appendToJson(result, "file_size", object->fileSize);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Audio::Ptr TgTypeParser::parseAudio(const ptree& data) const {
+    Audio::Ptr result(new Audio);
+    result->fileId = data.get<string>("file_id");
+    result->duration = data.get<int32_t>("duration");
+    result->mimeType = data.get("mime_type", "");
+    result->fileSize = data.get("file_size", 0);
+    return result;
+}
+
+string TgTypeParser::parseAudio(const Audio::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "file_id", object->fileId);
+    appendToJson(result, "duration", object->duration);
+    appendToJson(result, "mime_type", object->mimeType);
+    appendToJson(result, "file_size", object->fileSize);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Document::Ptr TgTypeParser::parseDocument(const ptree& data) const {
+    Document::Ptr result(new Document);
+    result->fileId = data.get<string>("file_id");
+    result->thumb = parsePhotoSize(data.find("thumb")->second);
+    result->fileName = data.get("file_name", "");
+    result->mimeType = data.get("mime_type", "");
+    result->fileSize = data.get("file_size", 0);
+    return result;
+}
+
+string TgTypeParser::parseDocument(const Document::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "file_id", object->fileId);
+    appendToJson(result, "thumb", parsePhotoSize(object->thumb));
+    appendToJson(result, "file_name", object->fileName);
+    appendToJson(result, "mime_type", object->mimeType);
+    appendToJson(result, "file_size", object->fileSize);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Sticker::Ptr TgTypeParser::parseSticker(const ptree& data) const {
+    Sticker::Ptr result(new Sticker);
+    result->fileId = data.get<string>("file_id");
+    result->width = data.get<int32_t>("width");
+    result->height = data.get<int32_t>("height");
+    result->thumb = parsePhotoSize(data.find("thumb")->second);
+    result->fileSize = data.get("file_size", 0);
+    return result;
+}
+
+string TgTypeParser::parseSticker(const Sticker::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "file_id", object->fileId);
+    appendToJson(result, "width", object->width);
+    appendToJson(result, "height", object->height);
+    appendToJson(result, "thumb", parsePhotoSize(object->thumb));
+    appendToJson(result, "file_size", object->fileSize);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Video::Ptr TgTypeParser::parseVideo(const ptree& data) const {
+    Video::Ptr result(new Video);
+    result->fileId = data.get<string>("file_id");
+    result->width = data.get<int32_t>("width");
+    result->height = data.get<int32_t>("height");
+    result->duration = data.get<int32_t>("duration");
+    result->thumb = parsePhotoSize(data.find("thumb")->second);
+    result->mimeType = data.get("mime_type", "");
+    result->fileSize = data.get("file_size", 0);
+    return result;
+}
+
+string TgTypeParser::parseVideo(const Video::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "file_id", object->fileId);
+    appendToJson(result, "width", object->width);
+    appendToJson(result, "height", object->height);
+    appendToJson(result, "duration", object->duration);
+    appendToJson(result, "thumb", parsePhotoSize(object->thumb));
+    appendToJson(result, "mime_type", object->mimeType);
+    appendToJson(result, "file_size", object->fileSize);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Contact::Ptr TgTypeParser::parseContact(const ptree& data) const {
+    Contact::Ptr result(new Contact);
+    result->phoneNumber = data.get<string>("phone_number");
+    result->firstName = data.get<string>("first_name");
+    result->lastName = data.get("last_name", "");
+    result->userId = data.get("user_id", "");
+    return result;
+}
+
+string TgTypeParser::parseContact(const Contact::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "phone_number", object->phoneNumber);
+    appendToJson(result, "first_name", object->firstName);
+    appendToJson(result, "last_name", object->lastName);
+    appendToJson(result, "user_id", object->userId);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Location::Ptr TgTypeParser::parseLocation(const ptree& data) const {
+    Location::Ptr result(new Location);
+    result->longitude = data.get<float>("longitude");
+    result->latitude = data.get<float>("latitude");
+    return result;
+}
+
+string TgTypeParser::parseLocation(const Location::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "longitude", object->longitude);
+    appendToJson(result, "latitude", object->latitude);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+Update::Ptr TgTypeParser::parseUpdate(const ptree& data) const {
+    Update::Ptr result(new Update);
+    result->updateId = data.get<int32_t>("update_id");
+    result->message = parseMessage(data.find("message")->second);
+    return result;
+}
+
+string TgTypeParser::parseUpdate(const Update::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "update_id", object->updateId);
+    appendToJson(result, "message", parseMessage(object->message));
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+UserProfilePhotos::Ptr TgTypeParser::parseUserProfilePhotos(const ptree& data) const {
+    UserProfilePhotos::Ptr result(new UserProfilePhotos);
+    result->totalCount = data.get<int32_t>("total_count");
+    result->photos = parse2DArray<PhotoSize>(parsePhotoSize, data, "photos");
+    return result;
+}
+
+string TgTypeParser::parseUserProfilePhotos(const UserProfilePhotos::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "total_count", object->totalCount);
+    appendToJson(result, "photos", parse2DArray(parsePhotoSize, object->photos));
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+ReplyKeyboardMarkup::Ptr TgTypeParser::parseReplyKeyboardMarkup(const boost::property_tree::ptree& data) const {
+    ReplyKeyboardMarkup::Ptr result(new ReplyKeyboardMarkup);
+    for (const pair<const string, ptree>& item : data.find("keyboard")->second) {
+        vector<string> array;
+        for (const pair<const string, ptree>& innerItem : item.second) {
+            array.push_back(innerItem.second.data());
+        }
+        result->keyboard.push_back(array);
+    }
+    result->resizeKeyboard = data.get<bool>("resize_keyboard");
+    result->oneTimeKeyboard = data.get<bool>("one_time_keyboard");
+    result->selective = data.get<bool>("selective");
+    return result;
+}
+
+std::string TgTypeParser::parseReplyKeyboardMarkup(const ReplyKeyboardMarkup::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    result += "\"keyboard\":[";
+    for (vector<string>& item : object->keyboard) {
+        result += '[';
+        for (string& innerItem : item) {
+            result += '"';
+            result += innerItem;
+            result += "\",";
+        }
+        result.erase(result.length() - 1);
+        result += "],";
+    }
+    result.erase(result.length() - 1);
+    result += "],";
+    appendToJson(result, "resize_keyboard", object->resizeKeyboard);
+    appendToJson(result, "one_time_keyboard", object->oneTimeKeyboard);
+    appendToJson(result, "selective", object->selective);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+ReplyKeyboardHide::Ptr TgTypeParser::parseReplyKeyboardHide(const boost::property_tree::ptree& data) const {
+    ReplyKeyboardHide::Ptr result(new ReplyKeyboardHide);
+    result->selective = data.get<bool>("selective");
+    return result;
+}
+
+std::string TgTypeParser::parseReplyKeyboardHide(const ReplyKeyboardHide::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "selective", object->selective);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+ForceReply::Ptr TgTypeParser::parseForceReply(const boost::property_tree::ptree& data) const {
+    ForceReply::Ptr result(new ForceReply);
+    result->selective = data.get<bool>("selective");
+    return result;
+}
+
+std::string TgTypeParser::parseForceReply(const ForceReply::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    string result;
+    result += '{';
+    appendToJson(result, "selective", object->selective);
+    result.erase(result.length() - 1);
+    result += '}';
+    return result;
+}
+
+GenericChat::Ptr TgTypeParser::parseGenericChat(const ptree& data) const {
+    if (data.find("first_name") == data.not_found()) {
+        return static_pointer_cast<GenericChat>(parseGroupChat(data));
+    } else {
+        return static_pointer_cast<GenericChat>(parseUser(data));
+    }
+}
+
+string TgTypeParser::parseGenericChat(const GenericChat::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    if (dynamic_pointer_cast<User>(object) == nullptr) {
+        return parseGroupChat(static_pointer_cast<GroupChat>(object));
+    } else {
+        return parseUser(static_pointer_cast<User>(object));
+    }
+}
+
+GenericReply::Ptr TgTypeParser::parseGenericReply(const boost::property_tree::ptree& data) const {
+    if (data.find("force_reply") != data.not_found()) {
+        return static_pointer_cast<GenericReply>(parseForceReply(data));
+    } else if (data.find("hide_keyboard") != data.not_found()) {
+        return static_pointer_cast<GenericReply>(parseReplyKeyboardHide(data));
+    } else {
+        return static_pointer_cast<GenericReply>(parseReplyKeyboardMarkup(data));
+    }
+}
+
+std::string TgTypeParser::parseGenericReply(const GenericReply::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    if (dynamic_pointer_cast<ForceReply>(object) != nullptr) {
+        return parseForceReply(static_pointer_cast<ForceReply>(object));
+    } else if (dynamic_pointer_cast<ReplyKeyboardHide>(object) != nullptr) {
+        return parseReplyKeyboardHide(static_pointer_cast<ReplyKeyboardHide>(object));
+    } else {
+        return parseReplyKeyboardMarkup(static_pointer_cast<ReplyKeyboardMarkup>(object));
+    }
+}
+
+void TgTypeParser::appendToJson(string& json, const string& varName, const string& value) const {
+    if (value.empty()) {
+        return;
+    }
+    json += '"';
+    json += varName;
+    json += "\":";
+    if (value.front() != '{') {
+        json += '"';
+    }
+    json += value;
+    if (value.back() != '}') {
+        json += '"';
+    }
+    json += ',';
+}
+
+}
\ No newline at end of file
diff --git a/src/net/HttpClient.cpp b/src/net/HttpClient.cpp
new file mode 100644
index 0000000..5027b09
--- /dev/null
+++ b/src/net/HttpClient.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/net/HttpClient.h"
+
+#include <boost/asio/ssl.hpp>
+
+using namespace std;
+using namespace boost::asio;
+using namespace boost::asio::ip;
+using namespace boost::asio::local;
+
+namespace TgBot {
+
+HttpClient& HttpClient::getInstance() {
+    static HttpClient result;
+    return result;
+}
+
+string HttpClient::makeRequest(const Url& url, const vector<HttpReqArg>& args) {
+    ssl::context context(ssl::context::sslv23);
+    context.set_default_verify_paths();
+
+    ssl::stream<tcp::socket> socket(_ioService, context);
+    tcp::resolver resolver(_ioService);
+    tcp::resolver::query query(url.host, url.protocol);
+
+    connect(socket.lowest_layer(), resolver.resolve(query));
+
+    socket.set_verify_mode(ssl::verify_none);
+    socket.set_verify_callback(ssl::rfc2818_verification(url.host));
+    socket.handshake(ssl::stream<tcp::socket>::client);
+
+    string requestText = HttpParser::getInstance().generateRequest(url, args, false);
+    write(socket, buffer(requestText.c_str(), requestText.length()));
+
+    string response;
+    char buff[1024];
+    boost::system::error_code error;
+    while (!error) {
+        size_t bytes = read(socket, buffer(buff), error);
+        response += string(buff, bytes);
+    }
+
+    return HttpParser::getInstance().parseResponse(response);
+}
+
+}
diff --git a/src/net/HttpParser.cpp b/src/net/HttpParser.cpp
new file mode 100644
index 0000000..ae9de62
--- /dev/null
+++ b/src/net/HttpParser.cpp
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/net/HttpParser.h"
+
+#include <boost/algorithm/string.hpp>
+
+#include "tgbot/tools/StringTools.h"
+
+using namespace std;
+using namespace boost;
+
+namespace TgBot {
+
+HttpParser& HttpParser::getInstance() {
+    static HttpParser result;
+    return result;
+}
+
+string HttpParser::generateRequest(const Url& url, const vector<HttpReqArg>& args, bool isKeepAlive) {
+    string result;
+    if (args.empty()) {
+        result += "GET ";
+    } else {
+        result += "POST ";
+    }
+    result += url.path;
+    result += url.query.empty() ? "" : "?" + url.query;
+    result += " HTTP/1.1\r\n";
+    result += "Host: ";
+    result += url.host;
+    result += "\r\nConnection: ";
+    if (isKeepAlive) {
+        result += "keep-alive";
+    } else {
+        result += "close";
+    }
+    result += "\r\n";
+    if (args.empty()) {
+        result += "\r\n";
+    } else {
+        string requestData;
+
+        string bondary = generateMultipartBoundary(args);
+        if (bondary.empty()) {
+            result += "Content-Type: application/x-www-form-urlencoded\r\n";
+            requestData = generateWwwFormUrlencoded(args);
+        } else {
+            result += "Content-Type: multipart/form-data; boundary=";
+            result += bondary;
+            result += "\r\n";
+            requestData = generateMultipartFormData(args, bondary);
+        }
+
+        result += "Content-Length: ";
+        result += lexical_cast<string>(requestData.length());
+        result += "\r\n\r\n";
+        result += requestData;
+    }
+    return result;
+}
+
+string HttpParser::generateMultipartFormData(const vector<HttpReqArg>& args, const string& bondary) {
+    string result;
+    for (const HttpReqArg& item : args) {
+        result += "--";
+        result += bondary;
+        result += "\r\nContent-Disposition: form-data; name=\"";
+        result += item.name;
+        result += "\"\r\n";
+        if (item.isFile) {
+            result += "Content-Type: ";
+            result += item.mimeType;
+            result += "\r\n";
+        }
+        result += "\r\n";
+        result += item.value;
+        result += "\r\n";
+    }
+    return result;
+}
+
+string HttpParser::generateMultipartBoundary(const vector<HttpReqArg>& args) {
+    string result;
+    srand((unsigned int) time(nullptr));
+    for (const HttpReqArg& item : args) {
+        if (item.isFile) {
+            while (result.empty() || item.value.find(result) != item.value.npos) {
+                result += StringTools::generateRandomString(4);
+            }
+        }
+    }
+    return result;
+}
+
+string HttpParser::generateWwwFormUrlencoded(const vector<HttpReqArg>& args) {
+    string result;
+
+    bool firstRun = true;
+    for (const HttpReqArg& item : args) {
+        if (firstRun) {
+            firstRun = false;
+        } else {
+            result += '&';
+        }
+        result += StringTools::urlEncode(item.name);
+        result += '=';
+        result += StringTools::urlEncode(item.value);
+    }
+
+    return result;
+}
+
+string HttpParser::generateResponse(const string& data, const string& mimeType, unsigned short statusCode, const string& statusStr, bool isKeepAlive) {
+    string result;
+    result += "HTTP/1.1 ";
+    result += lexical_cast<string>(statusCode);
+    result += ' ';
+    result += statusStr;
+    result += "\r\nContent-Type: ";
+    result += mimeType;
+    result += "\r\nContent-Length: ";
+    result += lexical_cast<string>(data.length());
+    result += "\r\n\r\n";
+    result += data;
+    return result;
+}
+
+string HttpParser::parseHttp(bool isRequest, const string& data, map<string, string>& headers) {
+    bool onlyNewLineChar = false;
+    size_t headerEnd = data.find("\r\n\r\n");
+    if (headerEnd == data.npos) {
+        headerEnd = data.find("\n\n");
+        if (headerEnd != data.npos) {
+            onlyNewLineChar = true;
+            headerEnd += 2;
+        }
+    } else {
+        headerEnd += 4;
+    }
+
+    size_t lineStart = 0;
+    size_t lineEnd = 0;
+    size_t lineSepPos = 0;
+    size_t lastLineEnd = data.npos;
+    while (lastLineEnd != lineEnd) {
+        lastLineEnd = lineEnd;
+        if (lineEnd == 0) {
+            if (isRequest) {
+                lineSepPos = data.find(' ');
+                lineEnd = data.find(onlyNewLineChar ? "\n" : "\r\n");
+                headers["method"] = data.substr(0, lineSepPos);
+                headers["path"] = data.substr(lineSepPos + 1, data.find(' ', lineSepPos + 1) - lineSepPos - 1);
+            } else {
+                lineSepPos = data.find(' ');
+                lineEnd = data.find(onlyNewLineChar ? "\n" : "\r\n");
+                headers["status"] = data.substr(lineSepPos + 1, data.find(' ', lineSepPos + 1) - lineSepPos - 1);
+            }
+        } else {
+            lineStart = lineEnd;
+            lineStart += onlyNewLineChar ? 1 : 2;
+            lineEnd = data.find(onlyNewLineChar ? "\n" : "\r\n", lineStart);
+            lineSepPos = data.find(':', lineStart);
+            if (lineEnd >= headerEnd || lastLineEnd == lineEnd || lineSepPos >= headerEnd) {
+                break;
+            }
+            headers[to_lower_copy(data.substr(lineStart, lineSepPos - lineStart))] = trim_copy(data.substr(lineSepPos + 1, lineEnd - lineSepPos - 1));
+        }
+    }
+
+    return headerEnd == data.npos ? "" : data.substr(headerEnd);
+}
+
+string HttpParser::parseHttp(bool isRequest, const string& data) {
+    size_t headerEnd = data.find("\r\n\r\n");
+    if (headerEnd == data.npos) {
+        headerEnd = data.find("\n\n");
+    }
+    if (headerEnd == data.npos) {
+        headerEnd = 0;
+    }
+    return data.substr(headerEnd);
+}
+
+}
diff --git a/src/net/TgLongPoll.cpp b/src/net/TgLongPoll.cpp
new file mode 100644
index 0000000..f420e92
--- /dev/null
+++ b/src/net/TgLongPoll.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/net/TgLongPoll.h"
+
+namespace TgBot {
+
+TgLongPoll::TgLongPoll(const Api* api, const EventHandler* eventHandler) : _api(api), _eventHandler(eventHandler) {
+}
+
+TgLongPoll::TgLongPoll(const Bot& bot) : TgLongPoll(&bot.getApi(), &bot.getEventHandler()) {
+}
+
+void TgLongPoll::start() {
+    std::vector<Update::Ptr> updates = _api->getUpdates(_lastUpdateId, 100, 60);
+    for (Update::Ptr& item : updates) {
+        if (item->updateId >= _lastUpdateId) {
+            _lastUpdateId = item->updateId + 1;
+        }
+        _eventHandler->handleUpdate(item);
+    }
+}
+
+}
diff --git a/src/net/Url.cpp b/src/net/Url.cpp
new file mode 100644
index 0000000..c773f3b
--- /dev/null
+++ b/src/net/Url.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/net/Url.h"
+
+#include "tgbot/tools/StringTools.h"
+
+using namespace std;
+
+namespace TgBot {
+
+Url::Url(const string& url) {
+    bool isProtocolParsed = false;
+    bool isHostParsed = false;
+    bool isPathParsed = false;
+    bool isQueryParsed = false;
+
+    for (size_t i = 0, count = url.length(); i < count; ++i) {
+        char c = url[i];
+
+        if (!isProtocolParsed) {
+            if (c == ':') {
+                isProtocolParsed = true;
+                i += 2;
+            } else {
+                protocol += c;
+            }
+        } else if (!isHostParsed) {
+            if (c == '/') {
+                isHostParsed = true;
+                path += '/';
+            } else if (c == '?') {
+                isHostParsed = isPathParsed = true;
+                path += '/';
+            } else if (c == '#') {
+                isHostParsed = isPathParsed = isQueryParsed = true;
+                path += '/';
+            } else {
+                host += c;
+            }
+        } else if (!isPathParsed) {
+            if (c == '?') {
+                isPathParsed = true;
+            } else if (c == '#') {
+                isPathParsed = isQueryParsed = true;
+            } else {
+                path += c;
+            }
+        } else if (!isQueryParsed) {
+            if (c == '#') {
+                isQueryParsed = true;
+            } else {
+                query += c;
+            }
+        } else {
+            fragment += c;
+        }
+    }
+
+	host = StringTools::urlEncode(host, ".");
+	path = StringTools::urlEncode(path, "/");
+	query = StringTools::urlEncode(query, "&");
+	fragment = StringTools::urlEncode(fragment);
+}
+
+}
diff --git a/src/tgbot/Api.cpp b/src/tgbot/Api.cpp
deleted file mode 100644
index 913401b..0000000
--- a/src/tgbot/Api.cpp
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "Api.h"
-
-#include "tgbot/TgTypeParser.h"
-#include "tgbot/TgException.h"
-#include "tgbot/net/HttpClient.h"
-
-using namespace std;
-using namespace boost::property_tree;
-
-namespace TgBot {
-
-Api::Api(const std::string& token) : _token(token) {
-}
-
-User::Ptr Api::getMe() const {
-    return TgTypeParser::getInstance().parseUser(sendRequest("getMe").find("result")->second);
-}
-
-Message::Ptr Api::sendMessage(int32_t chatId, const string& text, bool disableWebPagePreview, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("text", text));
-    if (disableWebPagePreview) {
-        args.push_back(HttpReqArg("disable_web_page_preview", disableWebPagePreview));
-    }
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendMessage", args).find("result")->second);
-}
-
-Message::Ptr Api::forwardMessage(int32_t chatId, int32_t fromChatId, int32_t messageId) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("from_chat_id", fromChatId));
-    args.push_back(HttpReqArg("message_id", messageId));
-    return TgTypeParser::getInstance().parseMessage(sendRequest("forwardMessage", args).find("result")->second);
-}
-
-Message::Ptr Api::sendPhoto(int32_t chatId, const InputFile::Ptr& photo, const string& caption, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("photo", photo->data, true, photo->mimeType));
-    if (!caption.empty()) {
-        args.push_back(HttpReqArg("caption", caption));
-    }
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendPhoto", args).find("result")->second);
-}
-
-Message::Ptr Api::sendPhoto(int32_t chatId, const string& photo, const string& caption, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("photo", photo));
-    if (!caption.empty()) {
-        args.push_back(HttpReqArg("caption", caption));
-    }
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendPhoto", args).find("result")->second);
-}
-
-Message::Ptr Api::sendAudio(int32_t chatId, const InputFile::Ptr& audio, int32_t duration = 0, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("audio", audio->data, true, audio->mimeType));
-    if (duration) {
-        args.push_back(HttpReqArg("duration", duration));
-    }
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendAudio", args).find("result")->second);
-}
-
-Message::Ptr Api::sendAudio(int32_t chatId, const string& audio, int32_t duration = 0, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("audio", audio));
-    if (duration) {
-        args.push_back(HttpReqArg("duration", duration));
-    }
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendAudio", args).find("result")->second);
-}
-
-Message::Ptr Api::sendDocument(int32_t chatId, const InputFile::Ptr& document, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("document", document->data, true, document->mimeType));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendDocument", args).find("result")->second);
-}
-
-Message::Ptr Api::sendDocument(int32_t chatId, const string& document, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("document", document));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendDocument", args).find("result")->second);
-}
-
-Message::Ptr Api::sendSticker(int32_t chatId, const InputFile::Ptr& sticker, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("sticker", sticker->data, true, sticker->mimeType));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendSticker", args).find("result")->second);
-}
-
-Message::Ptr Api::sendSticker(int32_t chatId, const string& sticker, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("sticker", sticker));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendSticker", args).find("result")->second);
-}
-
-Message::Ptr Api::sendVideo(int32_t chatId, const InputFile::Ptr& video, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("video", video->data, true, video->mimeType));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendVideo", args).find("result")->second);
-}
-
-Message::Ptr Api::sendVideo(int32_t chatId, const string& video, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("video", video));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendVideo", args).find("result")->second);
-}
-
-Message::Ptr Api::sendLocation(int32_t chatId, float latitude, float longitude, int32_t replyToMessageId, const GenericReply::Ptr& replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("latitude", latitude));
-    args.push_back(HttpReqArg("longitude", longitude));
-    if (replyToMessageId) {
-        args.push_back(HttpReqArg("reply_to_message_id", replyToMessageId));
-    }
-    if (replyMarkup) {
-        args.push_back(HttpReqArg("reply_markup", TgTypeParser::getInstance().parseGenericReply(replyMarkup)));
-    }
-    return TgTypeParser::getInstance().parseMessage(sendRequest("sendLocation", args).find("result")->second);
-}
-
-void Api::sendChatAction(int32_t chatId, const string& action) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("chat_id", chatId));
-    args.push_back(HttpReqArg("action", action));
-    sendRequest("sendChatAction", args);
-}
-
-UserProfilePhotos::Ptr Api::getUserProfilePhotos(int32_t userId, int32_t offset, int32_t limit) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("user_id", userId));
-    if (offset) {
-        args.push_back(HttpReqArg("offset", offset));
-    }
-    limit = max(1, min(100, limit));
-    args.push_back(HttpReqArg("limit", limit));
-    return TgTypeParser::getInstance().parseUserProfilePhotos(sendRequest("getUserProfilePhotos", args).find("result")->second);
-}
-
-vector<Update::Ptr> Api::getUpdates(int32_t offset, int32_t limit, int32_t timeout) const {
-    vector<HttpReqArg> args;
-    if (offset) {
-        args.push_back(HttpReqArg("offset", offset));
-    }
-    limit = max(1, min(100, limit));
-    args.push_back(HttpReqArg("limit", limit));
-    if (timeout) {
-        args.push_back(HttpReqArg("timeout", timeout));
-    }
-    return TgTypeParser::getInstance().parseArray<Update>(TgTypeParser::getInstance().parseUpdate, sendRequest("getUpdates", args), "result");
-}
-
-void Api::setWebhook(const string& url) const {
-    vector<HttpReqArg> args;
-    args.push_back(HttpReqArg("url", url));
-    sendRequest("setWebhook", args);
-}
-
-boost::property_tree::ptree Api::sendRequest(const std::string& method, const std::vector<HttpReqArg>& args) const {
-    std::string url = "https://api.telegram.org/bot";
-    url += _token;
-    url += "/";
-    url += method;
-    try {
-        ptree result = TgTypeParser::getInstance().parseJson(HttpClient::getInstance().makeRequest(url, args));
-        if (result.get<bool>("ok")) {
-            return result;
-        } else {
-            throw TgException(result.get("description", ""));
-        }
-    } catch (boost::property_tree::ptree_error& e) {
-        return ptree();
-    }
-}
-
-}
diff --git a/src/tgbot/TgException.cpp b/src/tgbot/TgException.cpp
deleted file mode 100644
index 2c8263e..0000000
--- a/src/tgbot/TgException.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "TgException.h"
-
-namespace TgBot {
-
-TgBot::TgException::TgException(const std::string description) : runtime_error(description) {
-}
-
-}
diff --git a/src/tgbot/TgTypeParser.cpp b/src/tgbot/TgTypeParser.cpp
deleted file mode 100644
index 70588da..0000000
--- a/src/tgbot/TgTypeParser.cpp
+++ /dev/null
@@ -1,490 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software", "to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "TgTypeParser.h"
-
-using namespace std;
-using namespace boost::property_tree;
-
-namespace TgBot {
-
-TgTypeParser& TgTypeParser::getInstance() {
-    static TgTypeParser result;
-    return result;
-}
-
-User::Ptr TgTypeParser::parseUser(const ptree& data) const {
-    User::Ptr result(new User);
-    result->id = data.get<int32_t>("id");
-    result->firstName = data.get<string>("first_name");
-    result->lastName = data.get("last_name", "");
-    result->username = data.get("username", "");
-    return result;
-}
-
-string TgTypeParser::parseUser(const User::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "id", object->id);
-    appendToJson(result, "first_name", object->firstName);
-    appendToJson(result, "last_name", object->lastName);
-    appendToJson(result, "username", object->username);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-GroupChat::Ptr TgTypeParser::parseGroupChat(const ptree& data) const {
-    GroupChat::Ptr result(new GroupChat);
-    result->id = data.get<int32_t>("id");
-    result->title = data.get<string>("title");
-    return result;
-}
-
-string TgTypeParser::parseGroupChat(const GroupChat::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "id", object->id);
-    appendToJson(result, "title", object->title);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Message::Ptr TgTypeParser::parseMessage(const ptree& data) const {
-    Message::Ptr result(new Message);
-    result->messageId = data.get<int32_t>("message_id");
-    result->from = parseUser(data.find("from")->second);
-    result->date = data.get<int32_t>("date");
-    result->chat = parseGenericChat(data.find("chat")->second);
-    result->forwardFrom = tryParse<User>(parseUser, data, "forward_from");
-    result->forwardDate = data.get("forward_date", 0);
-    result->replyToMessage = tryParse<Message>(parseMessage, data, "reply_to_message");
-    result->text = data.get("text", "");
-    result->audio = tryParse<Audio>(parseAudio, data, "audio");
-    result->document = tryParse<Document>(parseDocument, data, "document");
-    result->photo = parseArray<PhotoSize>(parsePhotoSize, data, "photo");
-    result->sticker = tryParse<Sticker>(parseSticker, data, "sticker");
-    result->video = tryParse<Video>(parseVideo, data, "video");
-    result->contact = tryParse<Contact>(parseContact, data, "contact");
-    result->location = tryParse<Location>(parseLocation, data, "location");
-    result->newChatParticipant = tryParse<User>(parseUser, data, "new_chat_participant");
-    result->leftChatParticipant = tryParse<User>(parseUser, data, "left_chat_participant");
-    result->newChatTitle = data.get("new_chat_title", "");
-    result->newChatPhoto = parseArray<PhotoSize>(parsePhotoSize, data, "new_chat_photo");
-    result->deleteChatPhoto = data.get("delete_chat_photo", false);
-    result->groupChatCreated = data.get("group_chat_created", false);
-    result->caption = data.get("caption", false);
-    return result;
-}
-
-string TgTypeParser::parseMessage(const Message::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "message_id", object->messageId);
-    appendToJson(result, "from", parseUser(object->from));
-    appendToJson(result, "date", object->date);
-    appendToJson(result, "chat", parseGenericChat(object->chat));
-    appendToJson(result, "forward_from", parseUser(object->forwardFrom));
-    appendToJson(result, "forward_date", object->forwardDate);
-    appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
-    appendToJson(result, "text", object->text);
-    appendToJson(result, "audio", parseAudio(object->audio));
-    appendToJson(result, "document", parseDocument(object->document));
-    appendToJson(result, "photo", parseArray(parsePhotoSize, object->photo));
-    appendToJson(result, "sticker", parseSticker(object->sticker));
-    appendToJson(result, "video", parseVideo(object->video));
-    appendToJson(result, "contact", parseContact(object->contact));
-    appendToJson(result, "location", parseLocation(object->location));
-    appendToJson(result, "new_chat_participant", parseUser(object->newChatParticipant));
-    appendToJson(result, "left_chat_participant", parseUser(object->leftChatParticipant));
-    appendToJson(result, "new_chat_title", object->newChatTitle);
-    appendToJson(result, "new_chat_photo", parseArray(parsePhotoSize, object->newChatPhoto));
-    appendToJson(result, "delete_chat_photo", object->deleteChatPhoto);
-    appendToJson(result, "group_chat_created", object->groupChatCreated);
-    appendToJson(result, "caption", object->caption);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-PhotoSize::Ptr TgTypeParser::parsePhotoSize(const ptree& data) const {
-    PhotoSize::Ptr result(new PhotoSize);
-    result->fileId = data.get<string>("file_id");
-    result->width = data.get<int32_t>("width");
-    result->height = data.get<int32_t>("height");
-    result->fileSize = data.get("file_size", 0);
-    return result;
-}
-
-string TgTypeParser::parsePhotoSize(const PhotoSize::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "file_id", object->fileId);
-    appendToJson(result, "width", object->width);
-    appendToJson(result, "height", object->height);
-    appendToJson(result, "file_size", object->fileSize);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Audio::Ptr TgTypeParser::parseAudio(const ptree& data) const {
-    Audio::Ptr result(new Audio);
-    result->fileId = data.get<string>("file_id");
-    result->duration = data.get<int32_t>("duration");
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
-    return result;
-}
-
-string TgTypeParser::parseAudio(const Audio::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "file_id", object->fileId);
-    appendToJson(result, "duration", object->duration);
-    appendToJson(result, "mime_type", object->mimeType);
-    appendToJson(result, "file_size", object->fileSize);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Document::Ptr TgTypeParser::parseDocument(const ptree& data) const {
-    Document::Ptr result(new Document);
-    result->fileId = data.get<string>("file_id");
-    result->thumb = parsePhotoSize(data.find("thumb")->second);
-    result->fileName = data.get("file_name", "");
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
-    return result;
-}
-
-string TgTypeParser::parseDocument(const Document::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "file_id", object->fileId);
-    appendToJson(result, "thumb", parsePhotoSize(object->thumb));
-    appendToJson(result, "file_name", object->fileName);
-    appendToJson(result, "mime_type", object->mimeType);
-    appendToJson(result, "file_size", object->fileSize);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Sticker::Ptr TgTypeParser::parseSticker(const ptree& data) const {
-    Sticker::Ptr result(new Sticker);
-    result->fileId = data.get<string>("file_id");
-    result->width = data.get<int32_t>("width");
-    result->height = data.get<int32_t>("height");
-    result->thumb = parsePhotoSize(data.find("thumb")->second);
-    result->fileSize = data.get("file_size", 0);
-    return result;
-}
-
-string TgTypeParser::parseSticker(const Sticker::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "file_id", object->fileId);
-    appendToJson(result, "width", object->width);
-    appendToJson(result, "height", object->height);
-    appendToJson(result, "thumb", parsePhotoSize(object->thumb));
-    appendToJson(result, "file_size", object->fileSize);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Video::Ptr TgTypeParser::parseVideo(const ptree& data) const {
-    Video::Ptr result(new Video);
-    result->fileId = data.get<string>("file_id");
-    result->width = data.get<int32_t>("width");
-    result->height = data.get<int32_t>("height");
-    result->duration = data.get<int32_t>("duration");
-    result->thumb = parsePhotoSize(data.find("thumb")->second);
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
-    return result;
-}
-
-string TgTypeParser::parseVideo(const Video::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "file_id", object->fileId);
-    appendToJson(result, "width", object->width);
-    appendToJson(result, "height", object->height);
-    appendToJson(result, "duration", object->duration);
-    appendToJson(result, "thumb", parsePhotoSize(object->thumb));
-    appendToJson(result, "mime_type", object->mimeType);
-    appendToJson(result, "file_size", object->fileSize);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Contact::Ptr TgTypeParser::parseContact(const ptree& data) const {
-    Contact::Ptr result(new Contact);
-    result->phoneNumber = data.get<string>("phone_number");
-    result->firstName = data.get<string>("first_name");
-    result->lastName = data.get("last_name", "");
-    result->userId = data.get("user_id", "");
-    return result;
-}
-
-string TgTypeParser::parseContact(const Contact::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "phone_number", object->phoneNumber);
-    appendToJson(result, "first_name", object->firstName);
-    appendToJson(result, "last_name", object->lastName);
-    appendToJson(result, "user_id", object->userId);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Location::Ptr TgTypeParser::parseLocation(const ptree& data) const {
-    Location::Ptr result(new Location);
-    result->longitude = data.get<float>("longitude");
-    result->latitude = data.get<float>("latitude");
-    return result;
-}
-
-string TgTypeParser::parseLocation(const Location::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "longitude", object->longitude);
-    appendToJson(result, "latitude", object->latitude);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-Update::Ptr TgTypeParser::parseUpdate(const ptree& data) const {
-    Update::Ptr result(new Update);
-    result->updateId = data.get<int32_t>("update_id");
-    result->message = parseMessage(data.find("message")->second);
-    return result;
-}
-
-string TgTypeParser::parseUpdate(const Update::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "update_id", object->updateId);
-    appendToJson(result, "message", parseMessage(object->message));
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-UserProfilePhotos::Ptr TgTypeParser::parseUserProfilePhotos(const ptree& data) const {
-    UserProfilePhotos::Ptr result(new UserProfilePhotos);
-    result->totalCount = data.get<int32_t>("total_count");
-    result->photos = parse2DArray<PhotoSize>(parsePhotoSize, data, "photos");
-    return result;
-}
-
-string TgTypeParser::parseUserProfilePhotos(const UserProfilePhotos::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "total_count", object->totalCount);
-    appendToJson(result, "photos", parse2DArray(parsePhotoSize, object->photos));
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-ReplyKeyboardMarkup::Ptr TgTypeParser::parseReplyKeyboardMarkup(const boost::property_tree::ptree& data) const {
-    ReplyKeyboardMarkup::Ptr result(new ReplyKeyboardMarkup);
-    for (const pair<const string, ptree>& item : data.find("keyboard")->second) {
-        vector<string> array;
-        for (const pair<const string, ptree>& innerItem : item.second) {
-            array.push_back(innerItem.second.data());
-        }
-        result->keyboard.push_back(array);
-    }
-    result->resizeKeyboard = data.get<bool>("resize_keyboard");
-    result->oneTimeKeyboard = data.get<bool>("one_time_keyboard");
-    result->selective = data.get<bool>("selective");
-    return result;
-}
-
-std::string TgTypeParser::parseReplyKeyboardMarkup(const ReplyKeyboardMarkup::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    result += "\"keyboard\":[";
-    for (vector<string>& item : object->keyboard) {
-        result += '[';
-        for (string& innerItem : item) {
-            result += '"';
-            result += innerItem;
-            result += "\",";
-        }
-        result.erase(result.length() - 1);
-        result += "],";
-    }
-    result.erase(result.length() - 1);
-    result += "],";
-    appendToJson(result, "resize_keyboard", object->resizeKeyboard);
-    appendToJson(result, "one_time_keyboard", object->oneTimeKeyboard);
-    appendToJson(result, "selective", object->selective);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-ReplyKeyboardHide::Ptr TgTypeParser::parseReplyKeyboardHide(const boost::property_tree::ptree& data) const {
-    ReplyKeyboardHide::Ptr result(new ReplyKeyboardHide);
-    result->selective = data.get<bool>("selective");
-    return result;
-}
-
-std::string TgTypeParser::parseReplyKeyboardHide(const ReplyKeyboardHide::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "selective", object->selective);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-ForceReply::Ptr TgTypeParser::parseForceReply(const boost::property_tree::ptree& data) const {
-    ForceReply::Ptr result(new ForceReply);
-    result->selective = data.get<bool>("selective");
-    return result;
-}
-
-std::string TgTypeParser::parseForceReply(const ForceReply::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    string result;
-    result += '{';
-    appendToJson(result, "selective", object->selective);
-    result.erase(result.length() - 1);
-    result += '}';
-    return result;
-}
-
-GenericChat::Ptr TgTypeParser::parseGenericChat(const ptree& data) const {
-    if (data.find("first_name") == data.not_found()) {
-        return static_pointer_cast<GenericChat>(parseGroupChat(data));
-    } else {
-        return static_pointer_cast<GenericChat>(parseUser(data));
-    }
-}
-
-string TgTypeParser::parseGenericChat(const GenericChat::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    if (dynamic_pointer_cast<User>(object) == nullptr) {
-        return parseGroupChat(static_pointer_cast<GroupChat>(object));
-    } else {
-        return parseUser(static_pointer_cast<User>(object));
-    }
-}
-
-GenericReply::Ptr TgTypeParser::parseGenericReply(const boost::property_tree::ptree& data) const {
-    if (data.find("force_reply") != data.not_found()) {
-        return static_pointer_cast<GenericReply>(parseForceReply(data));
-    } else if (data.find("hide_keyboard") != data.not_found()) {
-        return static_pointer_cast<GenericReply>(parseReplyKeyboardHide(data));
-    } else {
-        return static_pointer_cast<GenericReply>(parseReplyKeyboardMarkup(data));
-    }
-}
-
-std::string TgTypeParser::parseGenericReply(const GenericReply::Ptr& object) const {
-    if (!object) {
-        return "";
-    }
-    if (dynamic_pointer_cast<ForceReply>(object) != nullptr) {
-        return parseForceReply(static_pointer_cast<ForceReply>(object));
-    } else if (dynamic_pointer_cast<ReplyKeyboardHide>(object) != nullptr) {
-        return parseReplyKeyboardHide(static_pointer_cast<ReplyKeyboardHide>(object));
-    } else {
-        return parseReplyKeyboardMarkup(static_pointer_cast<ReplyKeyboardMarkup>(object));
-    }
-}
-
-void TgTypeParser::appendToJson(string& json, const string& varName, const string& value) const {
-    if (value.empty()) {
-        return;
-    }
-    json += '"';
-    json += varName;
-    json += "\":";
-    if (value.front() != '{') {
-        json += '"';
-    }
-    json += value;
-    if (value.back() != '}') {
-        json += '"';
-    }
-    json += ',';
-}
-
-}
\ No newline at end of file
diff --git a/src/tgbot/net/HttpClient.cpp b/src/tgbot/net/HttpClient.cpp
deleted file mode 100644
index fefeac5..0000000
--- a/src/tgbot/net/HttpClient.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "HttpClient.h"
-
-#include <boost/asio/ssl.hpp>
-
-using namespace std;
-using namespace boost::asio;
-using namespace boost::asio::ip;
-using namespace boost::asio::local;
-
-namespace TgBot {
-
-HttpClient& HttpClient::getInstance() {
-    static HttpClient result;
-    return result;
-}
-
-string HttpClient::makeRequest(const Url& url, const vector<HttpReqArg>& args) {
-    ssl::context context(ssl::context::sslv23);
-    context.set_default_verify_paths();
-
-    ssl::stream<tcp::socket> socket(_ioService, context);
-    tcp::resolver resolver(_ioService);
-    tcp::resolver::query query(url.host, url.protocol);
-
-    connect(socket.lowest_layer(), resolver.resolve(query));
-
-//    boost::asio::socket_base::keep_alive keepAliveOption(true);
-//    socket.lowest_layer().set_option(keepAliveOption);
-
-    socket.set_verify_mode(ssl::verify_none);
-    socket.set_verify_callback(ssl::rfc2818_verification(url.host));
-    socket.handshake(ssl::stream<tcp::socket>::client);
-
-    string requestText = HttpParser::getInstance().generateRequest(url, args, false);
-    write(socket, buffer(requestText.c_str(), requestText.length()));
-
-    string response;
-    char buff[1024];
-    boost::system::error_code error;
-    while (!error) {
-        size_t bytes = read(socket, buffer(buff), error);
-        response += string(buff, bytes);
-        printf("%s", string(buff, bytes).c_str());
-    }
-
-    return HttpParser::getInstance().parseResponse(response);
-}
-
-}
diff --git a/src/tgbot/net/HttpParser.cpp b/src/tgbot/net/HttpParser.cpp
deleted file mode 100644
index 070c630..0000000
--- a/src/tgbot/net/HttpParser.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "HttpParser.h"
-
-#include <boost/algorithm/string.hpp>
-
-#include "tgbot/tools/StringTools.h"
-
-using namespace std;
-using namespace boost;
-
-namespace TgBot {
-
-HttpParser& HttpParser::getInstance() {
-    static HttpParser result;
-    return result;
-}
-
-string HttpParser::generateRequest(const Url& url, const vector<HttpReqArg>& args, bool isKeepAlive) {
-    string result;
-    if (args.empty()) {
-        result += "GET ";
-    } else {
-        result += "POST ";
-    }
-    result += url.path;
-    result += url.query.empty() ? "" : "?" + url.query;
-    result += " HTTP/1.1\r\n";
-    result += "Host: ";
-    result += url.host;
-    result += "\r\nConnection: ";
-    if (isKeepAlive) {
-        result += "keep-alive";
-    } else {
-        result += "close";
-    }
-    result += "\r\n";
-    if (args.empty()) {
-        result += "\r\n";
-    } else {
-        string requestData;
-
-        string bondary = generateMultipartBoundary(args);
-        if (bondary.empty()) {
-            result += "Content-Type: application/x-www-form-urlencoded\r\n";
-            requestData = generateWwwFormUrlencoded(args);
-        } else {
-            result += "Content-Type: multipart/form-data; boundary=";
-            result += bondary;
-            result += "\r\n";
-            requestData = generateMultipartFormData(args, bondary);
-        }
-
-        result += "Content-Length: ";
-        result += lexical_cast<string>(requestData.length());
-        result += "\r\n\r\n";
-        result += requestData;
-    }
-    return result;
-}
-
-string HttpParser::generateMultipartFormData(const vector<HttpReqArg>& args, const string& bondary) {
-    string result;
-    for (const HttpReqArg& item : args) {
-        result += "--";
-        result += bondary;
-        result += "\r\nContent-Disposition: form-data; name=\"";
-        result += item.name;
-        result += "\"\r\n";
-        if (item.isFile) {
-            result += "Content-Type: ";
-            result += item.mimeType;
-            result += "\r\n";
-        }
-        result += "\r\n";
-        result += item.value;
-        result += "\r\n";
-    }
-    return result;
-}
-
-string HttpParser::generateMultipartBoundary(const vector<HttpReqArg>& args) {
-    string result;
-    srand((unsigned int) time(nullptr));
-    for (const HttpReqArg& item : args) {
-        if (item.isFile) {
-            while (result.empty() || item.value.find(result) != item.value.npos) {
-                result += StringTools::generateRandomString(4);
-            }
-        }
-    }
-    return result;
-}
-
-string HttpParser::generateWwwFormUrlencoded(const vector<HttpReqArg>& args) {
-    string result;
-
-    bool firstRun = true;
-    for (const HttpReqArg& item : args) {
-        if (firstRun) {
-            firstRun = false;
-        } else {
-            result += '&';
-        }
-        result += StringTools::urlEncode(item.name);
-        result += '=';
-        result += StringTools::urlEncode(item.value);
-    }
-
-    return result;
-}
-
-string HttpParser::generateResponse(const string& data, const string& mimeType, unsigned short statusCode, const string& statusStr, bool isKeepAlive) {
-    string result;
-    result += "HTTP/1.1 ";
-    result += lexical_cast<string>(statusCode);
-    result += ' ';
-    result += statusStr;
-    result += "\r\nContent-Type: ";
-    result += mimeType;
-    result += "\r\nContent-Length: ";
-    result += lexical_cast<string>(data.length());
-    result += "\r\n\r\n";
-    result += data;
-    return result;
-}
-
-string HttpParser::parseHttp(bool isRequest, const string& data, map<string, string>& headers) {
-    bool onlyNewLineChar = false;
-    size_t headerEnd = data.find("\r\n\r\n");
-    if (headerEnd == data.npos) {
-        headerEnd = data.find("\n\n");
-        if (headerEnd != data.npos) {
-            onlyNewLineChar = true;
-            headerEnd += 2;
-        }
-    } else {
-        headerEnd += 4;
-    }
-
-    size_t lineStart = 0;
-    size_t lineEnd = 0;
-    size_t lineSepPos = 0;
-    size_t lastLineEnd = data.npos;
-    while (lastLineEnd != lineEnd) {
-        lastLineEnd = lineEnd;
-        if (lineEnd == 0) {
-            if (isRequest) {
-                lineSepPos = data.find(' ');
-                lineEnd = data.find(onlyNewLineChar ? "\n" : "\r\n");
-                headers["method"] = data.substr(0, lineSepPos);
-                headers["path"] = data.substr(lineSepPos + 1, data.find(' ', lineSepPos + 1) - lineSepPos - 1);
-            } else {
-                lineSepPos = data.find(' ');
-                lineEnd = data.find(onlyNewLineChar ? "\n" : "\r\n");
-                headers["status"] = data.substr(lineSepPos + 1, data.find(' ', lineSepPos + 1) - lineSepPos - 1);
-            }
-        } else {
-            lineStart = lineEnd;
-            lineStart += onlyNewLineChar ? 1 : 2;
-            lineEnd = data.find(onlyNewLineChar ? "\n" : "\r\n", lineStart);
-            lineSepPos = data.find(':', lineStart);
-            if (lineEnd >= headerEnd || lastLineEnd == lineEnd || lineSepPos >= headerEnd) {
-                break;
-            }
-            headers[to_lower_copy(data.substr(lineStart, lineSepPos - lineStart))] = trim_copy(data.substr(lineSepPos + 1, lineEnd - lineSepPos - 1));
-        }
-    }
-
-    return headerEnd == data.npos ? "" : data.substr(headerEnd);
-}
-
-string HttpParser::parseHttp(bool isRequest, const string& data) {
-    size_t headerEnd = data.find("\r\n\r\n");
-    if (headerEnd == data.npos) {
-        headerEnd = data.find("\n\n");
-    }
-    if (headerEnd == data.npos) {
-        headerEnd = 0;
-    }
-    return data.substr(headerEnd);
-}
-
-}
diff --git a/src/tgbot/net/TgLongPoll.cpp b/src/tgbot/net/TgLongPoll.cpp
deleted file mode 100644
index 6359ec6..0000000
--- a/src/tgbot/net/TgLongPoll.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "TgLongPoll.h"
-
-namespace TgBot {
-
-TgLongPoll::TgLongPoll(const Api* api, const EventHandler* eventHandler) : _api(api), _eventHandler(eventHandler) {
-}
-
-TgLongPoll::TgLongPoll(const Bot& bot) : TgLongPoll(&bot.getApi(), &bot.getEventHandler()) {
-}
-
-void TgLongPoll::start() {
-    std::vector<Update::Ptr> updates = _api->getUpdates(_lastUpdateId, 100, 60);
-    for (Update::Ptr& item : updates) {
-        if (item->updateId >= _lastUpdateId) {
-            _lastUpdateId = item->updateId + 1;
-        }
-        _eventHandler->handleUpdate(item);
-    }
-}
-
-}
diff --git a/src/tgbot/net/Url.cpp b/src/tgbot/net/Url.cpp
deleted file mode 100644
index 7424849..0000000
--- a/src/tgbot/net/Url.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "Url.h"
-
-using namespace std;
-
-namespace TgBot {
-
-Url::Url(const string& url) {
-    bool isProtocolParsed = false;
-    bool isHostParsed = false;
-    bool isPathParsed = false;
-    bool isQueryParsed = false;
-
-    for (size_t i = 0, count = url.length(); i < count; ++i) {
-        char c = url[i];
-
-        if (!isProtocolParsed) {
-            if (c == ':') {
-                isProtocolParsed = true;
-                i += 2;
-            } else {
-                protocol += c;
-            }
-        } else if (!isHostParsed) {
-            if (c == '/') {
-                isHostParsed = true;
-                path += '/';
-            } else if (c == '?') {
-                isHostParsed = isPathParsed = true;
-                path += '/';
-            } else if (c == '#') {
-                isHostParsed = isPathParsed = isQueryParsed = true;
-                path += '/';
-            } else {
-                host += c;
-            }
-        } else if (!isPathParsed) {
-            if (c == '?') {
-                isPathParsed = true;
-            } else if (c == '#') {
-                isPathParsed = isQueryParsed = true;
-            } else {
-                path += c;
-            }
-        } else if (!isQueryParsed) {
-            if (c == '#') {
-                isQueryParsed = true;
-            } else {
-                query += c;
-            }
-        } else {
-            fragment += c;
-        }
-    }
-}
-
-}
diff --git a/src/tgbot/tools/StringTools.cpp b/src/tgbot/tools/StringTools.cpp
deleted file mode 100644
index de3bbb8..0000000
--- a/src/tgbot/tools/StringTools.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) 2015 Oleg Morozenkov
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "StringTools.h"
-
-#include <stdlib.h>
-#include <iomanip>
-#include <stdio.h>
-
-using namespace std;
-
-namespace StringTools {
-
-bool startsWith(const string& str1, const string& str2) {
-    string::const_iterator it1(str1.begin());
-    string::const_iterator end1(str1.end());
-    string::const_iterator it2(str2.begin());
-    string::const_iterator end2(str2.end());
-    while (it1 != end1 && it2 != end2) {
-        if (*it1 != *it2) {
-            return false;
-        }
-        ++it1;
-        ++it2;
-    }
-    return true;
-}
-
-bool endsWith(const string& str1, const string& str2) {
-    string::const_iterator it1(str1.end());
-    string::const_iterator begin1(str1.begin());
-    string::const_iterator it2(str2.end());
-    string::const_iterator begin2(str2.begin());
-    while (it1 != begin1 && it2 != begin2) {
-        if (*it1 != *it2) {
-            return false;
-        }
-        --it1;
-        --it2;
-    }
-    return true;
-}
-
-void split(const string& str, char delimiter, vector<string>& dest) {
-    istringstream stream(str);
-    string s;
-    while (getline(stream, s, delimiter)) {
-        dest.push_back(s);
-    }
-}
-
-string generateRandomString(size_t length) {
-    static const string chars("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890-=[]\\;',./!@#$%^&*()_+{}|:\"<>?`~");
-    static const size_t charsLen = chars.length();
-    string result;
-    for (int i = 0; i < length; ++i) {
-        result += chars[rand() % charsLen];
-    }
-    return result;
-}
-
-string urlEncode(const string& value) {
-    static const string legitPunctuation = "-_.~";
-    ostringstream result;
-    result.fill('0');
-    result << hex;
-    for (const char& c : value) {
-        if (isalnum(c) || legitPunctuation.find(c) != legitPunctuation.npos) {
-            result << c;
-        } else {
-            result << '%' << setw(2) << int((unsigned char) c);
-        }
-    }
-
-    return result.str();
-}
-
-string urlDecode(const string& value) {
-    string result;
-    for (size_t i = 0, count = value.length(); i < count; ++i) {
-        const char c = value[i];
-        if (c == '%') {
-            int t = 0;
-            sscanf(value.substr(i + 1, 2).c_str(), "%x", &t);
-            result += (char) t;
-            i += 2;
-        } else {
-            result += c;
-        }
-    }
-    return result;
-}
-
-}
diff --git a/src/tools/StringTools.cpp b/src/tools/StringTools.cpp
new file mode 100644
index 0000000..188e71c
--- /dev/null
+++ b/src/tools/StringTools.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2015 Oleg Morozenkov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "tgbot/tools/StringTools.h"
+
+#include <stdlib.h>
+#include <iomanip>
+#include <stdio.h>
+
+using namespace std;
+
+namespace StringTools {
+
+bool startsWith(const string& str1, const string& str2) {
+    string::const_iterator it1(str1.begin());
+    string::const_iterator end1(str1.end());
+    string::const_iterator it2(str2.begin());
+    string::const_iterator end2(str2.end());
+    while (it1 != end1 && it2 != end2) {
+        if (*it1 != *it2) {
+            return false;
+        }
+        ++it1;
+        ++it2;
+    }
+    return true;
+}
+
+bool endsWith(const string& str1, const string& str2) {
+    string::const_iterator it1(str1.end());
+    string::const_iterator begin1(str1.begin());
+    string::const_iterator it2(str2.end());
+    string::const_iterator begin2(str2.begin());
+    while (it1 != begin1 && it2 != begin2) {
+        if (*it1 != *it2) {
+            return false;
+        }
+        --it1;
+        --it2;
+    }
+    return true;
+}
+
+void split(const string& str, char delimiter, vector<string>& dest) {
+    istringstream stream(str);
+    string s;
+    while (getline(stream, s, delimiter)) {
+        dest.push_back(s);
+    }
+}
+
+string generateRandomString(size_t length) {
+    static const string chars("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890-=[]\\;',./!@#$%^&*()_+{}|:\"<>?`~");
+    static const size_t charsLen = chars.length();
+    string result;
+    for (int i = 0; i < length; ++i) {
+        result += chars[rand() % charsLen];
+    }
+    return result;
+}
+
+string urlEncode(const string& value, const std::string additionalLegitChars) {
+    static const string legitPunctuation = "-_.~";
+    ostringstream result;
+    result.fill('0');
+    result << hex;
+    for (const char& c : value) {
+        if (isalnum(c) || legitPunctuation.find(c) != legitPunctuation.npos || additionalLegitChars.find(c) != additionalLegitChars.npos) {
+            result << c;
+        } else {
+            result << '%' << setw(2) << int((unsigned char) c);
+        }
+    }
+
+    return result.str();
+}
+
+string urlDecode(const string& value) {
+    string result;
+    for (size_t i = 0, count = value.length(); i < count; ++i) {
+        const char c = value[i];
+        if (c == '%') {
+            int t = 0;
+            sscanf(value.substr(i + 1, 2).c_str(), "%x", &t);
+            result += (char) t;
+            i += 2;
+        } else {
+            result += c;
+        }
+    }
+    return result;
+}
+
+}
-- 
cgit v1.2.3