Linq
1.0.0
O LINQ for List Compreensão em C ++ fornece uma implementação do LINQ para C ++. Atualmente, ele suporta apenas as faixas de C ++, mas suporta os métodos de extensão e consulta para LINQ. Aqui está um exemplo:
struct student_t
{
std :: string last_name ;
std :: vector < int > scores ;
} ;
std :: vector < student_t > students =
{
{ "Omelchenko" , { 97 , 72 , 81 , 60 } } ,
{ "O'Donnell" , { 75 , 84 , 91 , 39 } } ,
{ "Mortensen" , { 88 , 94 , 65 , 85 } } ,
{ "Garcia" , { 97 , 89 , 85 , 82 } } ,
{ "Beebe" , { 35 , 72 , 91 , 70 } }
} ;
auto scores = LINQ ( from ( student , students )
from ( score , student . scores )
where ( score > 90 )
select ( std :: make_pair ( student . last_name , score ) ) ) ;
for ( auto x : scores )
{
printf ( "%s score: %i n " , x . first . c_str ( ) , x . second ) ;
}O código C ++ acima será produzido (sim, esse é o código C ++ acima):
Omelchenko score: 97
O'Donnell score: 91
Mortensen score: 94
Garcia score: 97
Beebe score: 91
As extensões são implementadas usando o | operador de tubo. Isso permite que eles sejam aplicados a qualquer intervalo, sem exigir a inércia de alguma classe base especial. Portanto, as extensões podem funcionar assim:
vector< int > numbers = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 };
auto r = numbers
| linq::where([]( int x) { return x > 2 ; })
| linq::select([]( int x) { return x * x; });Os métodos de extensão suportados são:
A biblioteca também fornece uma classe range_extension , que também pode ser usada para escrever suas próprias extensões. Primeiro, basta definir a função como uma classe de objeto de função, assim:
struct contains_t
{
template < class Range , class T >
bool operator ()(Range && r, T && x) const
{ return (r | linq::find (x)) != boost::end (r); };
};Em seguida, inicialize a extensão usando a inicialização estática:
range_extension< contains_t > contains = {};Então a extensão pode ser usada assim:
if (numbers | contains( 5 )) printf( " We have a 5 " ); Todas as consultas do LINQ devem começar com uma declaração from declaração. Isso especifica o nome da variável a ser usado para os Lambdas e o contêiner ao qual as consultas serão aplicadas. Além disso, várias from podem ser usadas.
struct student
{
std :: string name ;
std :: vector < int > grades ;
student ( ) { }
template < class Range >
student ( std :: string name , Range && r )
: name ( name ) , grades ( boost :: begin ( r ) , boost :: end ( r ) )
{ }
} ;
std :: vector < student > students =
{
student ( "Bob" , { 90 , 100 , 75 } )
student ( "Tom" , { 92 , 81 , 70 } )
student ( "Terry" , { 105 , 98 , 94 } )
} ;
// { 90, 100, 75, 92, 81, 70, 105, 98, 94 }
auto q = LINQ ( from ( s , students ) from ( g , s . grades ) select ( g ) ) ; A cláusula WHERE retorna o elemento que corresponde ao predicado. É opcional, mas deve vir após uma cláusula from cláusula e deve estar antes de uma cláusula select , se houver uma.
vector < int > v = { 1 , 3 , 4 , 5 } ;
// { 1, 3, 5 }
auto q = LINQ ( from ( i , v ) where ( i % 2 ) ) ;A cláusula de seleção aplica uma transformação aos elementos. Também é opcional, mas deve ser a última cláusula.
std :: vector < int > v = { 1 , 2 , 4 } ;
// { 3, 6, 24 }
auto q = LINQ ( from ( x , v ) select ( x * 3 ) ) ; A cláusula orderby permite especificar elementos para solicitar o intervalo por. Além disso, ascending ou descending podem ser precedidas pelo seletor para especificar a direção do pedido. O padrão está ascendente.
struct person
{
std :: string name ;
int age ;
person ( ) { }
person ( std :: string name , int age )
: name ( name ) , age ( age )
{ }
} ;
std :: vector < person > people =
{
person ( "Tom" , 25 ) ,
person ( "Bob" , 22 ) ,
person ( "Terry" , 37 ) ,
person ( "Jerry" , 22 )
}
// { "Jerry", "Bob", "Tom", "Terry" }
auto q = LINQ ( from ( p , people ) orderby ( p . age , descending p . name ) select ( p . name ) ) ; A cláusula group agrupa os elementos de uma sequência. O primeiro parâmetro é o seletor de chaves e o segundo é o seletor de valor.
struct person
{
std :: string name ;
int age ;
person ( ) { }
person ( std :: string name , int age )
: name ( name ) , age ( age )
{ }
} ;
std :: vector < person > people =
{
person ( "Tom" , 25 ) ,
person ( "Bob" , 22 ) ,
person ( "Terry" , 37 ) ,
person ( "Jerry" , 22 )
}
auto q = LINQ ( from ( p , people ) group ( p . age , p . name ) ) ; O LINQ pode ser facilmente instalado com CGE:
cget install pfultz2/Linq
Isso instalará a dependência do impulso automaticamente. A biblioteca também pode ser instalada manualmente com CMake.
find_package(Linq) também está disponível para consumir LINQ da CMake:
find_package(Linq)
target_linkq_libraries(yourLib linq::linq)
Para suporte total, requer CLANG ou GCC e Boost. Há suporte parcial ao Visual Studio. O Visual Studio não suporta o default_if_empty , group_by , group_join , join , order_by , select_many e then_by Extensions, e não suporta orderby , group e aninhados das cláusulas. Talvez alguns assistentes do Visual Studio possam ajudar a encontrar soluções alternativas para bugs do MSVC.
Múltiplas from são implementadas usando lambdas aninhados. No entanto, devido a um bug no MSVC 2010, os lambas aninhados não funcionam (isso deve ser corrigido no MSVC 2012, mas eu não o testei). Se houver uma maneira de implementar identificadores transparentes no C ++, lambdas aninhados poderão ser evitados.
Além disso, as cláusulas let e join ainda não são suportadas. A cláusula into não pode ser apoiada sem a ajuda de lambdas polimorhpic.
BSL-1.0
