boolinq 2.0

C++ single-file header-only Ranges and LINQ template library

Just imagine LINQ support for STL/Qt collections :)

Get source code here: boolinq.h

How it looks like?

Example with integers

int src[] = {1,2,3,4,5,6,7,8};
auto dst = from(src).where( [](int a){return a%2 == 1;})    // 1,3,5,7
                    .select([](int a){return a*2;})         // 2,6,10,14
                    .where( [](int a){return a>2 && a<12;}) // 6,10
                    .toVector();

// dst type: std::vector<int>
// dst items: 6,10

Example with structs

struct Man
{
    std::string name;
    int age;
};

Man src[] =
{
    {"Kevin",14},
    {"Anton",18},
    {"Agata",17},
    {"Terra",20},
    {"Layer",15},
};

auto dst = from(src).where(  [](const Man & man){return man.age < 18;})
                    .orderBy([](const Man & man){return man.age;})
                    .select( [](const Man & man){return man.name;})
                    .toVector();

// dst type: std::vector<std::string>
// dst items: "Kevin", "Layer", "Agata"

Interesting example

struct Message
{
    std::string PhoneA;
    std::string PhoneB;
    std::string Text;
};

Message messages[] =
{
    {"Anton","Troll","Hello, friend!"},
    {"Denis","Wride","OLOLO"},
    {"Anton","Papay","WTF?"},
    {"Denis","Maloy","How r u?"},
    {"Denis","Wride","Param-pareram!"},
};

int DenisUniqueContactCount =
    from(messages).where(   [](const Message & msg){return msg.PhoneA == "Denis";})
                  .distinct([](const Message & msg){return msg.PhoneB;})
                  .count();

// DenisUniqueContactCount == 2    

Containers supported?

• C++: Native arrays, pairs of pointers
• STL: list, stack, queue, vector, deque, set, map, any compatible ....
• Qt: QList, QVector, QSet, QMap.

Operators supported?

Today:

• cast<T>()
• take(int)
• skip(int)
• concat(range)
• where(lambda)
• select(lambda)
• reverse()
• orderBy()
• orderBy(lambda)
• groupBy(lambda)
• distinct()
• distinct(lambda)
• for_each(lambda)
• all()
• all(lambda)
• any()
• any(lambda)
• sum()
• sum(lambda)
• avg()
• avg(lambda)
• min()
• min(lambda)
• max()
• max(lambda)
• count()
• count(lambda)
• contains(value)
• elementAt(int)
• toSet()
• toList()
• toDeque()
• toVector()
• toContainer<T>()

Custom:

• bytes()
• bytes<ByteOrder>()
• unbytes<T>()
• unbytes<T,ByteOrder>()
• bits()
• bits<BitOrder>()
• bits<BitOrder,ByteOrder>()
• unbits()
• unbits<BitOrder>()
• unbits<T>()
• unbits<T,BitOrder>()
• unbits<T,BitOrder,ByteOrder>()

Coming soon:

• selectMany(lambda)

May be will be:

• gz()
• ungz()
• leftJoin
• rightJoin
• crossJoin
• fullJoin