feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

Initial version of std::array for Boost.Fusion

Browse Source 
Functional, though ADL issues have not been solved (see README).
This commit is contained in:
Mateusz Loskot
2013-07-02 13:28:20 +01:00
commit 93a1fc3b87
17 changed files with 639 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
.gitignore vendored Normal file
View File

@ -0,0 +1,17 @@
# Compiled Object files
*.slo
*.lo
*.o
# Compiled Dynamic libraries
*.so
*.dylib
# Compiled Static libraries
*.lai
*.la
*.a
# Build directories
_build*
build*

27
Jamroot Normal file
View File

@ -0,0 +1,27 @@
#
# Copyright (C) 2013 Mateusz Loskot <mateusz@loskot.net>
#
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or copy
# at http://www.boost.org/LICENSE_1_0.txt)
#
import os ;
local BOOST_ROOT = [ os.environ BOOST_ROOT ] ;
if $(BOOST_ROOT)
{
use-project /boost : $(BOOST_ROOT) ;
}
# Declare project
project boost_fusion_std_array
:
requirements
<include>.
<toolset>clang:<cxxflags>-std=c++11
<toolset>gcc:<cxxflags>-std=c++0x
<toolset>gcc:<threading>multi
<toolset>gcc:<cxxflags>-ftemplate-depth=300
<toolset>msvc:<cxxflags>/wd4996
<use>/boost//headers
;

13
README.md Normal file
View File

@ -0,0 +1,13 @@
Boost.Fusion extension for std::array
=====================================
An attempt to adapt ```std::array``` for Boost.Fusion.
The implementation is functional and passes the same test as adapted Boost.Array.
However, there is a problem with ADL and range-based access to the sequence
which is a well-known issue:
* [Fusion begin/end ADL issues with C++0x range-based for](http://lists.boost.org/Archives/boost/2010/12/index.php)
* Boost ticket: [https://svn.boost.org/trac/boost/ticket/4028 fusion::begin and fusion::end lead to problems with ADL-based begin and end functions for ranges]
* Boost ticket: [https://svn.boost.org/trac/boost/ticket/8241 Treat std::array as a Fusion sequence]

25
boost/fusion/adapted/std_array/detail/array_size.hpp Normal file
View File

@ -0,0 +1,25 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_ARRAY_SIZE_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_ARRAY_SIZE_01062013_1700
#include <cstddef>
#include <type_traits>
namespace boost { namespace fusion
{
namespace extension
{
template<class T>
struct std_array_size;
template<template<typename, std::size_t> class Array, typename T, std::size_t N>
struct std_array_size<Array<T, N>> : std::integral_constant<std::size_t, N> {};
}
}}
#endif

45
boost/fusion/adapted/std_array/detail/at_impl.hpp Normal file
View File

@ -0,0 +1,45 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_AT_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_AT_IMPL_01062013_1700
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/if.hpp>
namespace boost { namespace fusion {
struct std_array_tag;
namespace extension
{
template<typename T>
struct at_impl;
template<>
struct at_impl<std_array_tag>
{
template<typename Sequence, typename N>
struct apply
{
typedef typename mpl::if_<
is_const<Sequence>,
typename Sequence::const_reference,
typename Sequence::reference>::type type;
static type
call(Sequence& seq)
{
return seq[N::value];
}
};
};
}
}}
#endif

41
boost/fusion/adapted/std_array/detail/begin_impl.hpp Normal file
View File

@ -0,0 +1,41 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_BEGIN_OF_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_BEGIN_OF_IMPL_01062013_1700
#include <boost/fusion/adapted/std_array/std_array_iterator.hpp>
namespace boost { namespace fusion {
struct std_array_tag;
namespace extension
{
template<typename T>
struct begin_impl;
template <>
struct begin_impl<std_array_tag>
{
template <typename Sequence>
struct apply
{
typedef std_array_iterator<Sequence, 0> type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif

35
boost/fusion/adapted/std_array/detail/category_of_impl.hpp Normal file
View File

@ -0,0 +1,35 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_CATEGORY_OF_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_CATEGORY_OF_IMPL_01062013_1700
#include <boost/config/no_tr1/utility.hpp>
namespace boost { namespace fusion {
struct std_array_tag;
struct random_access_traversal_tag;
namespace extension
{
template<typename T>
struct category_of_impl;
template<>
struct category_of_impl<std_array_tag>
{
template<typename T>
struct apply
{
typedef random_access_traversal_tag type;
};
};
}
}}
#endif

45
boost/fusion/adapted/std_array/detail/end_impl.hpp Normal file
View File

@ -0,0 +1,45 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_END_OF_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_END_OF_IMPL_01062013_1700
#include <boost/fusion/adapted/std_array/std_array_iterator.hpp>
#include <boost/fusion/adapted/std_array/detail/array_size.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion {
struct std_array_tag;
namespace extension
{
template <typename Tag>
struct end_impl;
template <>
struct end_impl<std_array_tag>
{
template <typename Sequence>
struct apply
{
typedef typename remove_const<Sequence>::type seq_type;
static int const size = std_array_size<seq_type>::value;
typedef std_array_iterator<Sequence, size> type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif

32
boost/fusion/adapted/std_array/detail/is_sequence_impl.hpp Normal file
View File

@ -0,0 +1,32 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_IS_SEQUENCE_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_IS_SEQUENCE_IMPL_01062013_1700
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion {
struct std_array_tag;
namespace extension
{
template<typename Tag>
struct is_sequence_impl;
template<>
struct is_sequence_impl<std_array_tag>
{
template<typename Sequence>
struct apply : mpl::true_ {};
};
}
}}
#endif

33
boost/fusion/adapted/std_array/detail/is_view_impl.hpp Normal file
View File

@ -0,0 +1,33 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_IS_VIEW_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_IS_VIEW_IMPL_01062013_1700
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion
{
struct std_array_tag;
namespace extension
{
template<typename Tag>
struct is_view_impl;
template<>
struct is_view_impl<std_array_tag>
{
template<typename T>
struct apply : mpl::false_
{};
};
}
}}
#endif

41
boost/fusion/adapted/std_array/detail/size_impl.hpp Normal file
View File

@ -0,0 +1,41 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_SIZE_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_SIZE_IMPL_01062013_1700
#include <boost/fusion/adapted/std_array/detail/array_size.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace boost { namespace fusion {
struct std_array_tag;
namespace extension
{
template<typename T>
struct size_impl;
template<>
struct size_impl<std_array_tag>
{
template<typename Sequence>
struct apply
: mpl::int_
<
std_array_size
<
typename remove_const<Sequence>::type
>::value
>
{};
};
}
}}
#endif

32
boost/fusion/adapted/std_array/detail/value_at_impl.hpp Normal file
View File

@ -0,0 +1,32 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_VALUE_AT_IMPL_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_VALUE_AT_IMPL_01062013_1700
namespace boost { namespace fusion {
struct std_array_tag;
namespace extension
{
template<typename T>
struct value_at_impl;
template <>
struct value_at_impl<std_array_tag>
{
template <typename Sequence, typename N>
struct apply
{
typedef typename Sequence::value_type type;
};
};
}
}}
#endif

108
boost/fusion/adapted/std_array/std_array_iterator.hpp Normal file
View File

@ -0,0 +1,108 @@
/*=============================================================================
Copyright (c) 2013 Mateusz Loskot
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_ARRAY_ITERATOR_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_ARRAY_ITERATOR_01062013_1700
#include <cstddef>
#include <boost/config.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/minus.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/fusion/iterator/iterator_facade.hpp>
namespace boost { namespace fusion
{
struct random_access_traversal_tag;
template <typename Array, int Pos>
struct std_array_iterator
: iterator_facade<std_array_iterator<Array, Pos>, random_access_traversal_tag>
{
BOOST_MPL_ASSERT_RELATION(Pos, >=, 0);
BOOST_MPL_ASSERT_RELATION(Pos, <=, static_cast<int>(extension::std_array_size<Array>::value));
typedef mpl::int_<Pos> index;
typedef Array array_type;
std_array_iterator(Array& a)
: array(a) {}
Array& array;
template <typename Iterator>
struct value_of
{
typedef typename Iterator::array_type array_type;
typedef typename array_type::value_type type;
};
template <typename Iterator>
struct deref
{
typedef typename Iterator::array_type array_type;
typedef typename
mpl::if_<
is_const<array_type>
, typename array_type::const_reference
, typename array_type::reference
>::type
type;
static type
call(Iterator const & it)
{
return it.array[Iterator::index::value];
}
};
template <typename Iterator, typename N>
struct advance
{
typedef typename Iterator::index index;
typedef typename Iterator::array_type array_type;
typedef std_array_iterator<array_type, index::value + N::value> type;
static type
call(Iterator const& i)
{
return type(i.array);
}
};
template <typename Iterator>
struct next : advance<Iterator, mpl::int_<1> > {};
template <typename Iterator>
struct prior : advance<Iterator, mpl::int_<-1> > {};
template <typename I1, typename I2>
struct distance : mpl::minus<typename I2::index, typename I1::index>
{
typedef typename
mpl::minus<
typename I2::index, typename I1::index
>::type
type;
static type
call(I1 const&, I2 const&)
{
return type();
}
};
private:
std_array_iterator<Array, Pos>& operator=(std_array_iterator<Array, Pos> const&);
};
}}
#endif

58
boost/fusion/adapted/std_array/tag_of.hpp Normal file
View File

@ -0,0 +1,58 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_STD_ARRAY_TAG_OF_01062013_1700)
#define BOOST_FUSION_STD_ARRAY_TAG_OF_01062013_1700
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <cstddef>
namespace std
{
template<typename T, std::size_t N>
class array;
}
namespace boost { namespace fusion
{
struct std_array_tag;
struct fusion_sequence_tag;
namespace traits
{
template<typename T, std::size_t N>
#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
struct tag_of<std::array<T,N>, void >
#else
struct tag_of<std::array<T,N> >
#endif
{
typedef std_array_tag type;
};
}
}}
namespace boost { namespace mpl
{
template<typename>
struct sequence_tag;
template<typename T, std::size_t N>
struct sequence_tag<std::array<T,N> >
{
typedef fusion::fusion_sequence_tag type;
};
template<typename T, std::size_t N>
struct sequence_tag<std::array<T,N> const>
{
typedef fusion::fusion_sequence_tag type;
};
}}
#endif

22
libs/fusion/test/Jamfile Normal file
View File

@ -0,0 +1,22 @@
##==============================================================================
# Copyright (c) 2013 Mateusz Loskot
# Copyright (c) 2003-2006 Joel de Guzman
#
# Use, modification and distribution is subject to the Boost Software
# License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
#==============================================================================
# bring in rules for testing
import testing ;
project
: requirements
;
{
test-suite fusion_std_array :
[ run sequence/std_array.cpp : : : : ]
;
}

23
libs/fusion/test/sequence/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
cmake_minimum_required (VERSION 2.8)
project(boost_fusion_std_array)
if(MSVC)
list(APPEND CMAKE_CXX_FLAGS /Za)
else()
list(APPEND CMAKE_CXX_FLAGS -pedantic -Wall)
if(CMAKE_COMPILER_IS_GNUCXX)
list(APPEND CMAKE_CXX_FLAGS -std=c++0x)
elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_CXX_COMPILER}" MATCHES "clang")
list(APPEND CMAKE_CXX_FLAGS -std=c++11)
endif()
endif()
string(REPLACE ";" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
find_package(Boost 1.54)
if (NOT Boost_FOUND)
message(FATAL_ERROR "Cannot find Boost")
endif()
include_directories(${Boost_INCLUDE_DIRS})
add_executable(std_array std_array.cpp)

42
libs/fusion/test/sequence/std_array.cpp Normal file
View File

@ -0,0 +1,42 @@
//
// Copyright (C) 2013 Mateusz Loskot <mateusz@loskot.net>
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy
// at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma warning(disable:4180)
#include <boost/detail/lightweight_test.hpp>
#include <boost/fusion/adapted/std_array.hpp>
#include <array>
#include <boost/fusion/sequence/intrinsic.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/support/is_view.hpp>
#include <boost/fusion/iterator.hpp>
#include <boost/mpl/assert.hpp>
int main()
{
using namespace boost::fusion;
typedef std::array<int,3> array_type;
BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
array_type arr = {{1,2,3}};
BOOST_TEST(*boost::fusion::begin(arr) == 1);
BOOST_TEST(*boost::fusion::next(boost::fusion::begin(arr)) == 2);
BOOST_TEST(*advance_c<2>(boost::fusion::begin(arr)) == 3);
BOOST_TEST(prior(boost::fusion::next(boost::fusion::begin(arr))) == boost::fusion::begin(arr));
BOOST_TEST(*prior(boost::fusion::end(arr)) == 3);
BOOST_TEST(at_c<2>(arr) == 3);
BOOST_TEST(size(arr) == 3);
BOOST_TEST(distance(boost::fusion::begin(arr), boost::fusion::end(arr)) == 3);
return boost::report_errors();
}