boost regex

regex Sınıfı
constructor
Şöyle yaparız

boost::regex r ("...");

Şöyle yaparız

boost::regex r ("...", boost::regex_constants::optimize);

sregex_iterator Sınıfı

constructor

Şöyle yaparız.

std::string str ("...");
boost::regex r("...");
boost::sregex_iterator it (str.begin(),str.end(),r);

Free Style Metodlar
regex_match metodu
std::regex_match ile aynıdır. Şöyle yaparız

string str = 
if (boost::regex_match (str, r)) {...}

regex_search metodu
std::regex_search ile aynıdır. Aralıktaki tüm eşleşmeleri bulur. Şöyle yaparız. Önce başlangıç konumunu belirleriz.

std::string::const_iterator startPos = constpath.begin();

Sonra aramayı yaparız

const std::string str ("...");
boost::regex r("...");
boost::smatch match;
while(boost::regex_search(startPos, str.end(), match, r) { 
  startPos = match[0].second  //mathc[0] is whole string
};

boost date_time

Gregorian Sınıfları
date_time Gregorian Sınıfları yazısına taşıdım.

Posix Time Sınıfları

ptime, time_duration, time_period, time_iterator gibi sınıflar mevcut.

microseconds sınıfı

boost Time Duration Sınıfları yazısına taşıdım.

microsec_clock sınıfı
local_time metodu

Şöyle yaparız.

boost::posix_time::microsec_clock::local_time()

milliseconds sınıfı

boost Time Duration Sınıfları yazısına taşıdım.

ptime Sınıfı
date_time ptime Sınıfı yazısına taşıdım

second sınıfı
boost Time Duration Sınıfları yazısına taşıdım.

second_clock sınıfı
local_time metodu
Şöyle yaparız.

ptime p = second_clock::local_time();

time_duration sınıfı
boost Time Duration Sınıfları yazısına taşıdım.

time_facet sınıfı
Şöyle yaparız.

boost::posix_time::ptime epoch = ...;
time_facet * facet = new time_facet("...");
std::ostringstream stream;
stream.imbue(std::locale(stream.getloc(), facet));
stream << epoch ;

Local Time Sınıfları
posix_time_zone, tz_database, local_sec_clock gibi sınıflar mevcut.

local_date_time Sınıfı
date + time + timezone bilgisi içerir. Şöyle yaparız.

posix_time ptime = ...;
time_zone_ptr ptr = ...;
local_date_time mytime (ptime, ptr);

posix_time_zone Sınıfı
Şöyle yaparız.

time_zone_ptr zone (new posix_time_zone(...));

has_dst metodu
Şöyle yaparız.

zone->has_dst();

tz_database Sınıfı
constructor
Şöyle yaparız.

tz_database db;

load_from_file metodu
Şöyle yaparız.

db.load_from_file("date_time_zonespec.csv"); 

time_zone_from_region metodu
Şöyle yaparız.

time_zone_ptr ptz = db.time_zone_from_region("America/New_York");

boost function

Giriş
Şu satırı dahil ederiz.

#include <boost/function.hpp>

Tanımlama
Şöyle yaparız.

typedef boost::function<void(bool)> Function;
Function f;

Constructor
Şöyle yaparız.

#include <boost/bind/bind.hpp>
#include <boost/function.hpp>

class Foo {
  public:
    Foo() {...};
    void bar(bool i) {...}

};

Foo foo;
f = boost::bind(&Foo::bar, foo, _1);

boost range

boost::irange Sınıfı
s setinde olmayan sayılar resultVector'e eklemek için şöyle yaparız

auto abRange = boost::irange(a,b+1);
std::set_difference(abRange.begin(), abRange.end(), 
                    s.lower_bound(a), s.upper_bound(b), 
                    std::back_inserter(resultVector));

irange verilen aralık için hafıza harcıyor counting_range ise harcamıyor.

boost::make_iterator_range metodu
Verilen iki iterator'ü range haline getirilerek algoritmalarda kullanılabilir. Vector için şöyle yaparız.

std::vector<std::string> s { "bob", "hey", "joe", "doe" };
 std::vector<std::string> d;

 for (auto i = std::begin(s); i != std::end(s); ++i) {
     d.push_back(boost::algorithm::join(
         boost::make_iterator_range(std::begin(s), i + 1), 
         std::string(" ")
     ));
 }

Şu çıktıyı alırız.

bob
bob hey
bob hey joe
bob hey joe doe

Map için şöyle yaparız.

tMyMap const& my_map; // NOTE const
// ...
boost::make_iterator_range(my_map.lower_bound(123), mymap.upper_bound(456));

filtered Sınıfı
range adaptors yazısına taşıdım.

sliced Sınıfı
range adaptors yazısına taşıdım.

asio tcp

acceptor Sınıfı
acceptor Sınıfı yazısına taşıdım.

endpoint Sınıfı

Constructor - Port
Sınıf şöyle kurulur. Endpoint bir ip adresi ve bir de port numarasından oluşur.

asio::ip::tcp::endpoint end(asio::ip::tcp::v4(), 1234);

Constructor - IP + Port
string ve port numarasından şöyle kurarız.

std::string HostName = "...";const int Port = ...;
asio::ip::tcp::endpoint e(asio::ip::address::from_string(HostName), Port);

Constructor - Resolver
Şöyle yaparız.

tcp::resolver resolver = ...;
tcp::resolver::query query (host, port);
tcp::resolver::iterator it = resolver.resolve(query);
tcp::endpoint endpoint = *it;

address metodu - getter
address değerini verir.  Şöyle yaparız.

std::string s = socket.remote_endpoint().address().to_string();

address metodu - setter
Şöyle yaparız.

tcp::endpoint endpoint;endpoint.address(boost::asio::ip::address_v4::from_string("127.0.0.1"));

port metod - setter
Şöyle yaparız.

tcp::endpoint endpoint;
endpoint.port(90);

iostream Sınıfı

Constructor
Şöyle yaparız. Bağlanmak için connect metodu çağrılır.

boost::asio::ip::tcp::iostream stream;

Constructor - hostname + port
Şöyle yaparız.

string hostname = ...;
boost::asio::ip::tcp::iostream stream (hostname, "http");

connect metodu

Şöyle yaparız.

stream.connect ("localhost", "12345");

good metodu

Şöyle yaparız.

if(!stream.good()){
  throw runtime_error("...");
}

opertor << Şöyle yaparız.

stream << "Test" <<std::endl;

Şöyle yaparız.

stream << "GET " << path << " HTTP/1.0\r\n" << "Host: " << hostname << "\r\n";
stream << "Accept: */*\r\n" << "Connection: close\r\n\r\n";
stream << flush;

Stream aynı zamanda STL algoritmaları ile de kullanılabilir. 

string lineContent;
while(getline(stream, lineContent)){
  ...
}

rdbuf metodu
Sokette okumaya hazır veriyi öğrenmek için şöyle yaparız.

// Block until 6 bytes are available.
while (stream.rdbuf()->available() < 6)
{
  std::this_thread::sleep_for(std::chrono::seconds(1));
}

read metodu
Şöyle yaparız.

/// @brief Read up to `n` characters from `stream` and store them
///        into `buffer` without blocking.  This may not read all
///        of the requested amount of bytes.
template <typename... Args>
std::streamsize readsome(
  boost::asio::basic_socket_iostream<Args...>& stream,
  char* buffer,
  std::streamsize n)
{
  std::streamsize available =
    stream.rdbuf()->in_avail()     // available on input sequence
    + stream.rdbuf()->available(); // available on socket
  n = std::min(n, available);
  if (n == 0) return 0;

  stream.read(buffer, n);
  return n;
}

read_some metodu

Şöyle yaparız.

char inp[6]={0,0,0,0,0,0};
size_t r = stream.read_some (inp,5);

socket Sınıfı
tcp socket Sınıfı yazısına taşıdım.

query Sınıfı

Constructor
Sınıf şöyle kurulur.

asio::tcp::resolver::query query(tcp::v4(),"10.0.0.16",80); 

Kendi bilgisayar ismimiz için şöyle kurulur.

asio::ip::tcp::resolver::query query(boost::asio::ip::host_name(),"");

resolver Sınıfı

Bu sınıfın kardeşi udp isim alanı altında mevcuttur.
Constructor
Verilen query nesnesini endpoint'e çevirir. Sınıf şöyle kurulur.

asio::ip::tcp::resolver (io_svc)

resolve metodu
resolve metodu şöyle kullanılır.

ip::tcp::resolver resolver(my_io_service);
ip::tcp::resolver::query query("www.boost.org", "http");
ip::tcp::resolver::iterator iter = resolver.resolve(query);
ip::tcp::resolver::iterator end; // End marker.
while (iter != end)
{
    ip::tcp::endpoint endpoint = *iter++;
    std::cout << endpoint << std::endl;
}

async_resolve metodu
Şöyle sorgulanır.

resolver.async_resolve(
          query,
          boost::bind(
              &MyClass::handle_resolve,
              this,
              boost::asio::placeholders::error,
              boost::asio::placeholders::iterator));

resolve callback completion şuna benzer.

void MyClass::handle_resolve(
        const boost::system::error_code & error,
        boost::asio::ip::tcp::resolver::iterator endpoint_itr)
    {
      if (!error)
      {
        boost::asio::ip::tcp::endpoint endpoint = *endpoint_itr;
        socket_.async_connect(
            endpoint,
            boost::bind(
              &Session::handle_connect,
              this,
              boost::asio::placeholders::error,
              ++endpoint_itr));
      }
      else
      {
        std::cerr << "Failed to resolve\n";
        std::cerr << "Error: " << error.message() << std::endl;
      }
    }

Bir başka örnek

#include <boost/asio/io_service.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <array>
#include <string>
#include <iostream>

using namespace boost::asio;
using namespace boost::asio::ip;
using namespace std;

void resolve_handler(const boost::system::error_code &ec,
                     tcp::resolver::iterator it)
{
  tcp::resolver::iterator end;
  for (; it != end; ++it) {
    cout << it->host_name() << endl;
  }
}

int main()
{
  io_service ioservice;
  tcp::resolver resolv{ioservice};
  tcp::endpoint endpoint{address::from_string("74.125.239.48"), 80};
  resolv.async_resolve(endpoint, resolve_handler);
  ioservice.run();
  return 0;
}