jbelloncastro

enum class Kind : unsigned int;

struct Base {
    const Kind kind;
    explicit Base(Kind kind) : kind(kind) {}

    template <class T> bool is() const { return kind == T::kind; }
    template <class T> const T* cast() const { return is<T>()? static_cast<const T*>(this) : nullptr; }
};

jbelloncastro

#include <boost/icl/interval_map.hpp>
#include <boost/optional.hpp>
#include <iostream>

using namespace boost::icl;

template <class Type>
struct inplace_overwrite : identity_based_inplace_combine<Type> {
  void operator()(Type &object, const Type &operand) const { object = operand; }
};

jbelloncastro

#include <type_traits>
#include <llvm/ADT/STLExtras.h>

struct Base { virtual ~Base() = default; };

bool traverse( const Base* base, llvm::function_ref<bool(const Base*)> );

struct dispatcher {
    template <class F, class U, class... Args>
    auto operator()( F &&f, U &&u, Args&&... args ) const {

jbelloncastro

#include <tuple>
#include <type_traits>

enum class A {
    a, b
};

enum class B {
    c, d
};

jbelloncastro

#include <memory>
#include <tuple>
#include <algorithm>
#include <experimental/array>
#include <type_traits>

namespace {
                                                                                                                                                                                                           
// This fails to evaluate if any element in Args is not a valid type.                                                                                              
// Otherwise it evaluates to void.                                                                                                                        

jbelloncastro

#!/usr/bin/gnuplot
# Output format
set terminal png enhanced font "freesans,16" linewidth 2

# Caption
set key inside top horizontal nobox font ",12"

set xlabel ''                   
set ylabel ''                              
set auto x                   

jbelloncastro

#include <algorithm>
#include <cstring>
#include <string>
#include <limits>

// Literal for the IEC Mebi binary prefix
static
std::string operator""_Mi( unsigned long long value ) {
    struct Generator {
        Generator( unsigned long long value ) :

jbelloncastro

#ifndef SAX_H
#define SAX_H

#include <nlohmann/json.hpp>
#include <bitset>
#include <string_view>
#include <sstream>

template < class T >
struct sax_reader;

jbelloncastro

#include <array>
#include <tuple>
#include <string_view>
#include <utility>

template < class CharT, CharT... cs >
struct Literal {
    static bool match( std::basic_string_view<CharT> s ) {
        static constexpr std::array<CharT,sizeof...(cs)> value{cs...};
        return std::equal(value.begin(), value.end(), s.begin(), s.end());

jbelloncastro

#include <array>
#include <utility>

template < class F, size_t... Ns >
constexpr
std::array<decltype(std::declval<F>()(size_t(0))),sizeof...(Ns)>
generate_array( F&& f, std::index_sequence<Ns...> )
{
    return { f(Ns)... };
}