26 Aralık 2016 Pazartesi

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;


23 Aralık 2016 Cuma

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

22 Aralık 2016 Perşembe

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

21 Aralık 2016 Çarşamba

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;