Suchanfrage senden und Suchergebnisse zurückerhalten

CiPlüPlü

Ach du schande, ich habe nun ein Ordner entpackt, welcher ca. 40.000 Dateien enthält.

Muss ich den ganzen Ordner in meiner C++ bearbeitungsdateien beifügen oder reicht schon ein PATH aus?

Und nochmal zur Erinnerung: Es ist noch aktuell ^^

MfG

*PUSH*

So nach langer Zeit habe ich dennoch eine Frage:

Wie bekomme ich den ganzen Quelltext in einer char Variable untergebracht???

MfG

drakon

CiPlüPlü(unregistered) schrieb:

Wie bekomme ich den ganzen Quelltext in einer char Variable untergebracht???

LOL. Wenn du das schaffst, dann melde bitte die Technik beim Patentamt, weil du dann verdammt schnell unheimlich reich wirst (Sofern der untergebrachte Quelltext nicht nur aus einem Zeichen besteht).

Was ich damit sagen will ist, dass ein char lediglich (wie es der Name sagt) 1 Zeichen aufnehmen kann. Du suchst eher nach einem string, wie z.B std::string .

Kóyaánasqatsi

So, hatte vor nen paar Wochen nochmal die HTTP-Anfrage miteingebaut. Habe nur keine zeit mehr zum proggen, weil wegen Freundinn

#include <iostream>
#include <vector>
#include <string>
#include <utility>

#include <boost/asio.hpp>
#include <boost/utility.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/algorithm/string.hpp> 

template <typename T>
class AsyncHTTPClient : boost::noncopyable
{
	public:
		AsyncHTTPClient(std::string Host,
			            boost::asio::io_service &IOService,
						const std::string &Port = "80");

		const std::vector<char> GetWebPageContent() const
		{ return m_Buffer; }

	private:
		boost::scoped_ptr<boost::asio::ip::tcp::resolver> m_pResolver;
		boost::asio::ip::tcp::resolver::query             m_Query;
		boost::asio::ip::tcp::socket					  m_Socket;
		std::vector<T>                                    m_Buffer;     
		const std::string                                 m_Host;

		void ResolveSuceeded(const boost::system::error_code &Error,
							 boost::asio::ip::tcp::resolver::iterator it);

		void ConnectSuceeded(const boost::system::error_code &Error);

		void ResultOfQuery(const boost::system::error_code& Error, 
						   std::size_t bytes_transferred);

		const std::pair<std::string, std::string> SplitUrl(std::string Url) const;
};

template <typename T>
AsyncHTTPClient<T>::AsyncHTTPClient(std::string Host,
									boost::asio::io_service &IOService,
								    const std::string &Port) :
	m_pResolver(new boost::asio::ip::tcp::resolver(IOService)),
	m_Query(boost::asio::ip::tcp::resolver::query("www.google.de", Port)),
	m_Socket(IOService),
	m_Buffer(1500),
	m_Host(Host)
	{
		m_pResolver->async_resolve
		(
			m_Query,
			boost::bind(&AsyncHTTPClient::ResolveSuceeded,
										  this, 
										  boost::asio::placeholders::error, 
										  boost::asio::placeholders::iterator)
		);
	}

template <typename T>
void AsyncHTTPClient<T>::ResolveSuceeded(const boost::system::error_code &Error,
									     boost::asio::ip::tcp::resolver::iterator it)
{
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Resolve at "<< SplitUrl(m_Host).first <<" suceeded"<<std::endl;

		boost::system::error_code error = boost::asio::error::host_not_found;

		boost::asio::ip::tcp::endpoint EndPoint = *it;

		m_Socket.async_connect
		(
			EndPoint, 
			boost::bind(&AsyncHTTPClient::ConnectSuceeded, this, boost::asio::placeholders::error)
		);
	}
}

template <typename T>
void AsyncHTTPClient<T>::ConnectSuceeded(const boost::system::error_code &Error)
{
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Connect to "<< SplitUrl(m_Host).first <<" suceeded"<<std::endl;

		std::string GET("GET ");
		GET += SplitUrl(m_Host).second;
		GET += " Host: www.google.de";

		boost::asio::write(m_Socket, boost::asio::buffer(GET)); 

		m_Socket.async_read_some
		(
			boost::asio::buffer(m_Buffer, 1500),
			boost::bind(&AsyncHTTPClient::ResultOfQuery, this, boost::asio::placeholders::error, _2)
		);
	}
}

template <typename T>
void AsyncHTTPClient<T>::ResultOfQuery(const boost::system::error_code& Error, 
							           std::size_t bytes_transferred)
{ 	
	if(Error)
	{
		std::cout<<"Error:"<<std::endl;
		std::cout<< boost::system::system_error(Error).what() <<std::endl;
	}
	else
	{
		std::cout<<"... Successfully connected to DNS-Server"<<std::endl;
		std::cout<<"... "<< bytes_transferred <<"Bytes transferred"<<std::endl;
	}
}

template <typename T>
const std::pair<std::string, std::string> AsyncHTTPClient<T>::SplitUrl(std::string Url) const
{
	std::pair<std::string, std::string> UrlPair;

	UrlPair.second = Url.substr(Url.find(std::string("/")));

	Url.erase(Url.find(std::string("/"), (Url.size() - UrlPair.second.size())));

	UrlPair.first = Url;

	return UrlPair;
}

/// Formal characters not supported
class GoogleLinkBuilder : boost::noncopyable
{
	public:
		const std::string BuildLink(const std::string &Keyword)
		{
			std::string Link("www.google.de/search?hl=de&safe=off&q=");
			Link += Keyword;
			Link += "&meta=&aq=f&aqi=&aql=&oq=&gs_rfai=";

			return Link;
		}
};

class GoogleResultParser : boost::noncopyable,
						   public GoogleLinkBuilder
{
	public:
		GoogleResultParser(const std::string &Keyword);

	private:
		boost::asio::io_service                  m_IOService;
		boost::scoped_ptr<AsyncHTTPClient<char>> m_pClient;
		boost::scoped_ptr<boost::thread>         m_pThread;
		boost::scoped_ptr<boost::thread>         m_pIOThread;
		bool									 m_StopLoop;
		std::vector<char>						 m_TempStorage;

		void CheckBuffer();
		void ParseResults(const std::vector<char> &Results) const;
};

GoogleResultParser::GoogleResultParser(const std::string &Keyword) :
	m_IOService(boost::asio::io_service()),
	m_pClient(new AsyncHTTPClient<char>(BuildLink(Keyword), m_IOService)),
	m_pThread
	(
		new boost::thread(boost::bind(&GoogleResultParser::CheckBuffer, this))
	),
	m_pIOThread
	(
		new boost::thread(boost::bind(&boost::asio::io_service::run, &m_IOService))
	),
	m_StopLoop(false)
	{ }

void GoogleResultParser::CheckBuffer()
{
	m_TempStorage = m_pClient->GetWebPageContent();

	while(m_StopLoop == false)
	{
		if(!m_TempStorage.empty() && m_TempStorage[0] != 0)
		{
			ParseResults(m_TempStorage);

			m_StopLoop = true;
		}
	}
}

void GoogleResultParser::ParseResults(const std::vector<char> &Results) const
{
	std::cout<<"Results != empty"<<std::endl;

	for(std::vector<char>::const_iterator it(Results.begin());
		it != Results.end();
		++it)
		std::cout<< *it <<std::endl;
}

int main()
{
	std::string Keyword;

	std::cout<<"Keyword: "<<std::endl;
	std::cin>>Keyword;

	GoogleResultParser parser(Keyword);
}