Suchanfrage senden und Suchergebnisse zurückerhalten

drakon

Das hat mit PHP nichts zu tun. Was du machst ist eine Anfrage (HTTP) an den Server senden und der gibt dir dann Antwort. Wie er die Antwort macht (also mit PHP, Ruby usw.) spielt keine Rolle. Theoretisch könnte da sogar ein Typ sitzen, welcher dir auf Anfrage eine neue Seite tippt.

Kóyaánasqatsi

CiPlüPlü schrieb:

Entschuldigung dass ich so voreilig war ^^

Äh, wie?

CiPlüPlü

Kóyaánasqatsi schrieb:

CiPlüPlü schrieb:

Entschuldigung dass ich so voreilig war ^^

Äh, wie?

Lol das war bezogen auf das Thema, das ich gesagt hatte das sichs erledigt habe. Dem war es eben nicht so und ...

dann sagte ich halt:

Entschuldigung dass ich so voreilig war ^^

MfG

Kóyaánasqatsi

Achsou
Kannst du das den noch gebrauchen? Weil sonst landet das gleich im Mülleimer

CiPlüPlü

Kóyaánasqatsi schrieb:

Achsou
Kannst du das den noch gebrauchen? Weil sonst landet das gleich im Mülleimer

Ich weiß nicht, mit welchem Programm du es gebastelt hast, weil ich es noch nicht getestet habe, aber lösche den Quellcode trotzdem nicht!

Und ja ich kann es wahrscheinlich gebrauchen ^^

Kóyaánasqatsi

CiPlüPlü schrieb:

Ich weiß nicht, mit welchem Programm du es gebastelt hast

Boost^^. Ist kein Programm sondern ne lib. Kannste dir 4free im Netz saugen^^

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);
}