interprocess file_lock Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/interprocess/sync/file_lock.hpp>

Constructor - file name
Açıklaması şöyle

"If you are using a std::fstream/native file handle to write to the file while using file locks on that file, don't close the file before releasing all the locks of the file."

Şöyle yaparız

ofstream file_out ("fileLock.txt");
file_lock f_lock ("fileLock.txt");

file_out << 10;
...

asio ip address Sınıfı

Giriş
Bu sınıf genellikle tcp endpoint veya udp endpoint ile beraber kullanılır.

Constructor
Şöyle yaparız.

boost::asio::ip::address addr (
  boost::asio::ip::address::from_string ("239.1.1.100" ));

Bağlanmış bir socketten elde edebiliriz. Şöyle yaparız.

boost::asio::ip::address addr = socket.remote_endpoint().address();

to_string metodu
Şöyle yaparız.

std::cout << "IP: " << addr.to_string();

coroutine symmetric_coroutine Sınıfı

call_type Tipi
Constructor
Şöyle yaparız.

boost::coroutines::symmetric_coroutine<int>::call_type coro (
  [&](boost::coroutines::symmetric_coroutine<int>::yield_type& yield)
  {
    ...
  }
);

operator () metodu
Şöyle yaparız.

coro (3);

yield_type Tipi
get metodu
Şöyle yaparız.

boost::coroutines::symmetric_coroutine<int>::yield_type yield = ...
std::cout << yield.get() << std::endl;

operator () metodu
Şöyle yaparız.

boost::coroutines::symmetric_coroutine<int>::yield_type& yield = ...;
yield ();

utiliity

string_ref Sınıfı
Giriş
Açıklaması şöyle. Bu sınıfın C++'taki karşılığı std::string_view

Boost.StringRef is an implementation of Jeffrey Yaskin's N3442: string_ref: a non-owning reference to a string.

Constructor - const char*
Şöyle yaparız

boost::string_ref ref = "...";

Şöyle yaparız.

void foo(const boost::string_ref ref) {...}

foo("...");

Yanlış kullanım şekli şöyle! Satırın sonunda temporary string yok olduğu için dangling reference olur.

boost::string_ref ref = string("<a>\n1234567\n</a>\n<a>");

find metodu
Şöyle yaparız

size_t pos = ref.find ("...")

find_first_of metodu
Şöyle yaparız

size_t pos = ref.find_first_of ("...")

graph subgraph Sınıfı

Giriş
Şu satırları dahil ederiz.

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/subgraph.hpp>

Tanımlama
Şöyle yaparız.

typedef subgraph<adjacency_list<vecS, vecS, undirectedS,  
property<vertex_color_t,int>,property<edge_name_t,int,property<edge_index_t,int>>,
propertyy<vertex_name_t, int,property<vertex_index_t,  int>>  >> Graph;

Constructor
Şöyle yaparız.

const int N = 6;

Graph G (N);

create_subgraph metodu
Şöyle yaparız.

Graph& g1 = g.create_subgraph();

log sources severity_channel_logger Sınıfı

Giriş
Şu satırları dahil ederiz.

#include <boost/log/trivial.hpp>
#include <boost/log/sources/severity_channel_logger.hpp>

Kolay kullanım için şöyle tanımlarız.

namespace logging = boost::log;

using logger_type =
 logging::sources::severity_channel_logger_mt<logging::trivial::severity_level>;

severity_logger ile kardeş sınıftır.

Constructor
Şöyle yaparız.

logger_type logger;

open_record metodu
Şöyle yaparız.

auto rec = logger.open_record( 
  (logging::keywords::channel = std::string{"channel"},
   logging::keywords::severity = logging::trivial::info)
);    
if (rec) {
  ...
  logger.push_record(std::move(rec));
}

tokenizer Kendi Ayraç Sınıfım

Giriş
char_delimeters_separator (depricated),
char_separator
sınıfları ayraç olarak karakterleri kullanır.

Eğer bir metni ayraç olarak kullanmak istersek şöyle yaparız.

struct my_tokenizer_func
{
  template<typename It>
  bool operator()(It& next, It end, std::string & tok)
  {
    if (next == end)
      return false;
    char const * del = ">=";
    auto pos = std::search(next, end, del, del + 2);
    tok.assign(next, pos);
    next = pos;
    if (next != end)
      std::advance(next, 2);
    return true;
  }

  void reset() {}
};

Kullanmak için şöyle yaparız.

std::string s = "...";;
boost::tokenizer<my_tokenizer_func> tok (s);

for (auto t : tok)
  std::cout << t << '\n';

python'dan C Kullanmak

Giriş
Kolay kullanım için şu satırı dahil ederiz.

using namespace boost::python;

Windows için proje'yi derlemeden önce şunlar yapılır.
1. python geliştirme ortamı kurulu olmalıdır (include dosyaları ve libler)
2. Proje .pyd uzantılı dosya üretmelidir.  'Properties->General->Target Extension'  ".pyd"
3. Dll'den export edilecek metodlar için def dosyası hazırlanır. source.def şöyledir

LIBRARY hello
EXPORT greet

3. boot ve python kütüphanaleri ile linklenir. boot static linklenecekse preprocessor olarak şu tanımlanır.
"BOOST_PYTHON_STATIC_LIB"

BOOST_PYTHON_MODULE
Şu satırı dahil ederiz.

#include <boost/python/module.hpp>

python içinde kullanılacak module ismini belirtir. Şöyle yaparız.

BOOST_PYTHON_MODULE(hell) {
  ...
}

def
Şu satırı dahil ederiz.

#include <boost/python/def.hpp>

Module içinden dışarıya açılan metod ismini belirtir. Metodun imzası belirtilmez. Şöyle yaparız.

const char* greet () {
  return "hello, world";}

BOOST_PYTHON_MODULE(hello) {
  def("init", init);
}

python'dan Çağırmak
Şöyle yaparız.

import hello
print hello.greet()

serialization tmpdir metodu

Giriş
Şu satırı dahil ederiz.

#include <boost/archive/tmpdir.hpp>

Şöyle yaparız.

std::string filename (boost::archive::tmpdir());
filename += "/tmp.txt";

serialization BOOST_CLASS_TRACKING

Şu satırı dahil ederiz.

#include <boost/serialization/tracking.hpp>

Şöyle yaparız.

class MyClass {

public:
    double value;

    template <class Archive>
    void serialize(Archive &ar, const unsigned int){
        ar & Double_wrapper(value);
    }
};
BOOST_CLASS_TRACKING(MyClass, boost::serialization::track_never)

multi_index

Ne Zaman Kullanılır?
Elimizde bir liste varken, elemanlara güncelleme yapmak gerekiyorsa O(n) arama yerine O(1) arama yapmak için multiindex kullanılmaz! Basit bir map sorunu halledebilir. Elemanlara farklı indeksler kullanarak erişmek gerekiyorsa bu sınıf işe yarar.

İçi Neye Benzer
İç modelinin aşağıdaki şekle benzediğini düşünüyorum.

Index çeşitleri

Key kullananlar

1. hashed_unique - std::unordered_map gibi

2. hashed_non_unique - std::unordered_multimap gibi. hashed_non_unique Sınıfı yazısına taşıdım.

3. ordered_unique - std::set gibi. ordered_unique Sınıfı yazısına taşıdım.

4. ordered_non_unique - ordered_non_unique Sınıfı yazısına taşıdım.

Key kullanmayanlar

1. sequenced - std::list gibi. sequenced Sınfı yazısına taşıdım.

2. random_access - std::vector gibi. random_access Sınıfı yazısına taşıdım.

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

1. hash_unique Index

Hash Index ve Composite Key

Tag kullanan bir hashed index şöyle tanımlanır. Örnekte composite_key kullanılıyor. Include olarak şunlar gerekir. Bu sefer member field yerine getter() metodlar kullandığımız için member.hpp yerine mem_fun.hpp'yi dahil etmek gerekir.

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/composite_key.hpp>

Kod ise şöyledir.

typedef multi_index_container<
      MyClass,
      indexed_by<
        hashed_unique< tag<struct hash> ,
          composite_key< 
            MyClass,
            const_mem_fun<MyClass,int,&MyClass::get_int >,
            const_mem_fun<MyClass,const std::vector<int>&,&MyClass::get_vec >
          >
        >,
        random_access< >
      >
    > my_list;

identity kullanılan örnekler de var. identity şöyle tanımlanır.

typedef multi_index_container<
          MyClass,
          indexed_by<
              hashed_unique< tag<hash>,
              identity<MyClass>
            >
          >
        > my_list;

Identitiy anladığım kadarıyla nesne için hash metodu olmasını istiyor. Nesne için hash metodu şöyle tanımlanıyor.

std::size_t hash_value(const MyClass& myClass)
{
  std::size_t seed = 0;

  boost::hash_combine(seed, myClass.getX());
  boost::hash_combine(seed, myClass.getY());
  boost::hash_combine(seed, myClass.getZ());

  return seed;
}

find metodu

Metodun imzası şöyle

template<
  typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
>
iterator find(const CompatibleKey& k,
              const CompatibleHash& hash,
              const CompatiblePred& eq) const;

Parametrelerin anlamları ise şöyle

KeyFromValue = composite_key<...>
CompatibleKey = MyClass
CompatibleHash = boost::hash<KeyFromValue>
CompatiblePred = equal_to<KeyFromValue>

find() metoduna key yerine tüm nesneyi geçersek hata alıyoruz. Yani şu kod hata verebiliyor.

MyClass tempy(5);
hashed_index::iterator pos = mylist.get<hash>().find(tempy);

Sebebi ise find metodunun key beklemesi. Biz ise tüm nesneyi geçiyoruz. Çözümü iki şekilde olabiliyor. İlk çözümü anlamadım ama çalışıyor.

hashed_index::iterator pos =
  mylist.get<hash>().find(boost::make_tuple(tempy));

İkinci çözüm çok daha karmaşık ama o da çalışıyor. Ben bu yöntemi kullandım çünkü projede boost::tuple bağımlılığı yaratmak istemedim.
hashed_index::iterator pos = mylist.get<hash>().find( mylist.get<hash>().key_extractor()(tempy));

Hashed Indeks'in find metodu bir iterator döner. Bu iterator end() ile karşılaştırılarak nesnenin mevcudiyeti bulunabilir.

hashed_index::iterator it = mylist.get<hash>().find(myObject);