polygon polygon_with_holes_data Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/polygon/polygon.hpp>

Tanımlama
Şöyle yaparız

typedef polygon_with_holes_data<float> polygon;

log sinks text_ostream_backend Sınıfı

Giriş
Bu sınıf bir sink ile beraber yaratılır. Şöyle yaparız.

// Initialize sink.
typedef boost::log::sinks::synchronous_sink
  <boost::log::sinks::text_ostream_backend> text_sink;

boost::shared_ptr<text_sink> sink = boost::make_shared<text_sink>();

Şöyle yaparız.

using text_sink = sinks::synchronous_sink< sinks::text_ostream_backend >;
boost::shared_ptr< text_sink > sink = boost::make_shared< text_sink >();

add_stream metodu
ofstream eklemek için şöyle yaparız.

sink->locked_backend()->add_stream(
  boost::make_shared< std::ofstream >("regular.log"));

auto_flush metodu
Açıklaması şöyle. Bu parametre sink ile ilgili backend ile ilgili değil deniyor. Ancak o zaman niçin backend sınıfına ait bir şey ben de anlamadım.

First, auto_flush makes the sink flush its buffers after each log record is written, whether or not it contains a newline. Second, auto_flush can only be enabled or disabled on per-sink basis. In the particular case of text_ostream_backend it means either all streams attached to the sink will be flushed, or none of them.

Şöyle yaparız.

sink->locked_backend()->auto_flush (false);

log filter Sınıfı

constructor - Tanımlı attribute
Şöyle yaparız.

auto filt = logging::filter(logging::trivial::severity >= logging::trivial::info);
logging::core::get()->set_filter(filt);

constructor - Custom attribute
Şöyle yaparız.

// Define your severity levels
enum severity_level
{
    debug, normal, error, fatal
};

// Define an attribute keyword for severity level
BOOST_LOG_ATTRIBUTE_KEYWORD(a_severity, "Severity", severity_level)

// Define a filter that will check the severity
bool abort_filter(
    boost::log::value_ref< severity_level, tag::a_severity > const& level)
{
  // Don't forget to check if the record has a severity level at all
  if (level && level.get() >= error)
    std::abort();

  // Pass all log records that didn't trigger the abort
  return true;
}

Kullanım
core'a eklenir. Şöyle yaparız.

auto filt = logging::filter(...);
logging::core::get()->set_filter (filt);

multi_index hashed_non_unique Sınıfı

Giriş
Şu satırı dahil ederiz.

#include<boost/multi_index/hashed_index.hpp>

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

namespace mi = boost::multi_index;

std::unordered_multimap gibidir.
1.Cycle + Slot içinde gönderilen n tane mesaja bu anahtar değerler ile tekrar erişmek için kullandım. 

const_mem_fun - Üye Metod

Şu satırı dahil ederiz.

#include<boost/multi_index/mem_fun.hpp>

Elimizde şöyle iki sınıf olsun

class Bar
{
  int a, b;
};

class Foo
{
  Bar ex;
public:
  void setId(Bar a) {
    ex = a;
  };
  virtual const Bar& getId() const { 
    return ex; 
  }
};

Şöyle yaparız. Metod imzasındaki donüş tipi birebir uygulanmalıdır. Dönüş tipi const ise const kullanılmalıdır.

bi::multi_index_container<
  StoreMe,
  bi::indexed_by<
    bi::hashed_non_unique<bi::const_mem_fun<Foo,const Bar&, &Foo::getId> >  >
>;

Tag + const_mem_fun - Üye Metod
Tag ile kullanmak istersek şöyle yaparız.

bi::hashed_non_unique<
  bi::tag<IndexByNonUniqueId>,
  bi::const_mem_fun<StoredObj, std::string,&StoredObj::getNonUniqueIdString> 
>

Tag + mem - Üye Alan
Elimizdee bir yapı olsun.

struct X
{
  long long l; // assume unique
  int i1; // assume unique
  int i2; // assume non-unique
  // plus any ohter data you have in your class X
};

Tag'lerimiz olsun.

struct IndexByL {};
struct IndexByI1 {};
struct IndexByI2 {};

Şöyle yaparız.

using Container = boost::multi_index_container<
  X*, // the data type stored
  boost::multi_index::indexed_by< // list of indexes
    ...,
    boost::multi_index::hashed_non_unique<  //hashed non-unique index over 'i2'
      boost::multi_index::tag<IndexByI2>, // give that index a name
      boost::multi_index::member<X, int, &X::i2> // what will be the index's key
    >
  >
>;

count metodu
Şöyle yaparız.

Container c = ...;

// Look up by i2
auto& indexByI2 = c.get<IndexByI2>();
size_t numberOfHundreds = indexByI2.count(100);

graph random_edge metodu

Giriş
Şu satırı dahil ederiz.

#include <boost/graph/random.hpp>

Elimizde bir sayı üreteci olsun

typedef boost::uniform_int<> UniformIntDistr;
typedef boost::variate_generator<boost::mt19937&, UniformIntDistr> IntRNG;

// make random number generator
boost::mt19937 rng;
UniformIntDistr dis(0, num_edges(g)-1);
IntRNG gen_int(rng, dis);

random_edge metodu
Şöyle yaparız.

// select two edges uniformly at random (a million times)
Graph::edge_descriptor e1;
Graph::edge_descriptor e2;
for (int i=0; i<1000000;i++) {
  Graph::edge_descriptor e1 = boost::random_edge(g, gen_int);
  Graph::edge_descriptor e2 = boost::random_edge(g, gen_int);
};

graph erdos_renyi_iterator Sınıfı

Giriş
Şu satırı dahil ederiz.

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

Constructor
Elimizde bir Graph ve bunu dolduracak bir generator olsun.

typedef boost::adjacency_list<boost::setS,boost::vecS,boost::undirectedS> Graph;
typedef boost::erdos_renyi_iterator<boost::minstd_rand, Graph> ERGen;

Bir sayı üreteci olsun.

typedef boost::uniform_int<> UniformIntDistr;
typedef boost::variate_generator<boost::mt19937&, UniformIntDistr> IntRNG;

// make random graph
int n = 17000;
boost::graph_traits<Graph>::edges_size_type m = 250000;
boost::minstd_rand gen;

Şöyle yaparız.

Graph g(ERGen(gen, n, m), ERGen(), n);

random uniform_int Sınıfı

Constructor
Şöyle yaparız.

typedef boost::uniform_int<> UniformIntDistr;
UniformIntDistr dis (0, 1000);

graph graph_traits Sınıfı

Giriş
Elimizde şöyle bir graph olsun

using GraphType = boost::adjacency_list <...,...,...,...,...>;

edge_descriptor
Şöyle yaparız.

using EdgeDesc = boost::graph_traits<GraphType>::edge_descriptor;

edge_iterator
Şöyle yaparız.

using EdgeIter = boost::graph_traits<GraphType>::edge_iterator;

edges_size_type
Kaç tane edge olduğunu belirtmek için kullanılır. Şöyle yaparız.

boost::graph_traits<Graph>::edges_size_type m = 250000;

out_edge_iterator
Çok emin olmamakla beraber sanırım graph bidirectionalS olarak tanımlanmalı. Şöyle yaparız.

using OutEdgeIter = boost::graph_traits<Graph>::out_edge_iterator;

vertex_descriptor
Şöyle yaparız.

using VertexDesc = boost::graph_traits<GraphType>::vertex_descriptor;

vertex_iterator
Şöyle yaparız.

using VertexIter = boost::graph_traits<GraphType>::vertex_iterator;