Update of /cvsroot/boost/boost/boost/bimap/relation/support
In directory
sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv24149/boost/bimap/relation/support
Added Files:
data_extractor.hpp get.hpp get_pair_functor.hpp
is_tag_of_member_at.hpp member_with_tag.hpp opposite_tag.hpp
pair_by.hpp pair_type_by.hpp value_type_of.hpp
Log Message:
first bimap commit
--- NEW FILE: data_extractor.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/data_extractor.hpp
/// \brief Data extraction functor.
#ifndef BOOST_BIMAP_RELATION_SUPPORT_DATA_EXTRACTOR_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_DATA_EXTRACTOR_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
/** \struct boost::bimaps::relation::support::data_extractor
\brief Data extraction functor.
\ingroup relation_group
**/
#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
template< class Tag, class Relation >
struct data_extractor_implementation;
template< class Relation >
struct data_extractor_implementation< member_at::left, Relation > :
public std::unary_function<Relation,BOOST_DEDUCED_TYPENAME
Relation::left_value_type>
{
BOOST_DEDUCED_TYPENAME Relation::left_value_type const &
operator()(Relation const & rel) const
{
return rel.left;
}
BOOST_DEDUCED_TYPENAME Relation::left_value_type &
operator()(Relation & rel) const
{
return rel.left;
}
};
template< class Relation >
struct data_extractor_implementation< member_at::right, Relation > :
public std::unary_function<Relation,BOOST_DEDUCED_TYPENAME
Relation::right_value_type>
{
BOOST_DEDUCED_TYPENAME Relation::right_value_type const &
operator()(Relation const & rel) const
{
return rel.right;
}
BOOST_DEDUCED_TYPENAME Relation::right_value_type &
operator()(Relation & rel) const
{
return rel.right;
}
};
template< class Tag, class Relation >
struct data_extractor
{
typedef data_extractor_implementation
<
BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
Relation
> type;
};
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
#endif // BOOST_BIMAP_RELATION_SUPPORT_DATA_EXTRACTOR_HPP
--- NEW FILE: get.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/get.hpp
/// \brief get<tag>(r) function
#ifndef BOOST_BIMAP_RELATION_SUPPORT_GET_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_GET_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/standard_relation_fwd.hpp>
#include <boost/bimap/relation/support/value_type_of.hpp>
#include <boost/bimap/relation/detail/access_builder.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/utility/enable_if.hpp>
#ifdef BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
/** \brief Gets a pair view of the relation.
\ingroup relation_group
**/
template< class Tag, class SymmetricType >
BOOST_DEDUCED_TYPENAME result_of::get<Tag,SymmetricType>::type
get( SymmetricType & );
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
// Since it is very error-prone to directly write the hole bunch
// of relation accesor. They are buil from litle macro blocks that
// are both more readable, leading to self docummenting code and a
// lot more easier to understand and mantain.
// It is very important to note that the three building blocks have
// to laid in the same namespace in order to work. There is also
// important to keep them in order.
// The forward declaration are not necesary but they help a lot to
// the reader, as they undercover what is the signature of the
// result code.
// In the end, it is not quicker to do it in this way because you
// write a lot. But this code has no complexity at all and almost
// every word writed is for documentation.
// Result of
// -------------------------------------------------------------------------
/*
namespace result_of {
template< class Tag, class Relation >
struct get<Tag,Relation>;
{
typedef -unspecified- type;
};
} // namespace result_of
*/
BOOST_BIMAP_SYMMETRIC_ACCESS_RESULT_OF_BUILDER
(
get,
value_type_of
);
// Implementation
// -------------------------------------------------------------------------
BOOST_BIMAP_SYMMETRIC_ACCESS_IMPLEMENTATION_BUILDER
(
get,
Relation,
rel,
return rel.get_left(),
return rel.get_right()
);
// Interface
//----------------------------------------------------------------------------
template< class Tag, class Symmetric >
BOOST_DEDUCED_TYPENAME enable_if<
::boost::mpl::or_<
is_standard_pair_view< Symmetric >,
is_standard_relation_view< Symmetric >
>,
BOOST_DEDUCED_TYPENAME result_of::get< Tag, Symmetric >::type
>::type
get( Symmetric s )
{
typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
member_with_tag
<
Tag, Symmetric
>::type member_at_tag;
return detail::get(member_at_tag(),s);
}
template< class Tag, class Symmetric >
BOOST_DEDUCED_TYPENAME disable_if<
::boost::mpl::or_<
is_standard_pair_view< Symmetric >,
is_standard_relation_view< Symmetric >
>,
BOOST_DEDUCED_TYPENAME result_of::get< Tag, Symmetric >::type
>::type
get( Symmetric & s )
{
typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
member_with_tag
<
Tag, Symmetric
>::type member_at_tag;
return detail::get(member_at_tag(),s);
}
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
#endif // BOOST_BIMAP_RELATION_SUPPORT_GET_HPP
--- NEW FILE: get_pair_functor.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/get_pair_functor.hpp
/// \brief get_pair_functor definition
#ifndef BOOST_BIMAP_RELATION_SUPPORT_GET_PAIR_FUNCTOR_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_GET_PAIR_FUNCTOR_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/support/pair_by.hpp>
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
/// \brief A Functor that takes a relation as a parameter an return the desired
view.
/**
This functor is included to help users of the relation class when using
stl algorithms.
See also member_at, pair_by().
\ingroup relation_group
**/
template< class Tag, class Relation >
struct get_pair_functor
{
BOOST_DEDUCED_TYPENAME result_of::pair_by<Tag,Relation>::type
operator()( Relation & r ) const
{
return pair_by<Tag>(r);
}
BOOST_DEDUCED_TYPENAME result_of::pair_by<Tag,const Relation>::type
operator()( const Relation & r ) const
{
return pair_by<Tag>(r);
}
};
/// \brief A Functor that takes a relation as a parameter an return the above
view.
/**
\ingroup relation_group
**/
template< class Relation >
struct get_above_view_functor
{
BOOST_DEDUCED_TYPENAME Relation::above_view_reference
operator()( Relation & r ) const
{
return r.get_view();
}
BOOST_DEDUCED_TYPENAME Relation::const_above_view_reference
operator()( const Relation & r ) const
{
return r.get_view();
}
};
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_RELATION_SUPPORT_GET_PAIR_FUNCTOR_HPP
--- NEW FILE: is_tag_of_member_at.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/is_tag_of_member_at.hpp
/// \brief is_tag_of_member_at<tag,relation> metafunction
#ifndef BOOST_BIMAP_RELATION_SUPPORT_IS_TAG_OF_MEMBER_AT_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_IS_TAG_OF_MEMBER_AT_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/member_at.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/bimap/relation/support/member_with_tag.hpp>
/** \struct boost::bimaps::relation::support::is_tag_of_member_at_left
\brief Metafunction to test if a user tag is refering to the left member.
\code
template< class Tag, class Relation >
struct is_tag_of_member_at_left : {true_|false_} {};
\endcode
This metafunction is somewhat redundant with member_with_tag, but it is included
because it is a lot easier to metaprogram with it. The result type is the
same that:
\code
is_same< member_with_tag<Tag,Relation>::type , member_at::left >::type
\endcode
See also member_with_tag, member_at, is_tag_of_member_at_right.
\ingroup relation_group
**/
/** \struct boost::bimaps::relation::support::is_tag_of_member_at_right
\brief Metafunction to test if a user tag is refering to the left member.
\code
template< class Tag, class Relation >
struct is_tag_of_member_at_right : {true_|false_} {};
\endcode
This metafunction is somewhat redundat with member_with_tag, but it is included
because it is a lot easier to metaprogram with it. The result type is the
same that:
\code
is_same< member_with_tag<Tag,Relation>::type , member_at::right >::type
\endcode
See also member_with_tag, member_at, is_tag_of_member_at_left.
\ingroup relation_group
**/
#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
// Metafunction is_tag_of_member_at_left
// Easiear metaprogramming
template
<
class Tag,
class Relation,
class Enable = void
>
struct is_tag_of_member_at_left :
::boost::mpl::false_ {};
template< class Tag, class Relation >
struct is_tag_of_member_at_left
<
Tag, Relation,
BOOST_DEDUCED_TYPENAME enable_if
<
is_same
<
BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
member_at::left
>
>::type
> :
::boost::mpl::true_ {};
// Metafunction is_tag_of_member_at_right
// Easiear metaprogramming
template
<
class Tag,
class Relation,
class Enable = void
>
struct is_tag_of_member_at_right :
::boost::mpl::false_ {};
template< class Tag, class Relation >
struct is_tag_of_member_at_right
<
Tag, Relation,
BOOST_DEDUCED_TYPENAME enable_if
<
is_same
<
BOOST_DEDUCED_TYPENAME member_with_tag<Tag,Relation>::type,
member_at::right
>
>::type
> :
::boost::mpl::true_ {};
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
#endif // BOOST_BIMAP_RELATION_SUPPORT_IS_TAG_OF_MEMBER_AT_HPP
--- NEW FILE: member_with_tag.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/member_with_tag.hpp
/// \brief member_with_tag<tag,relation> metafunction
#ifndef BOOST_BIMAP_RELATION_SUPPORT_MEMBER_WITH_TAG_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_MEMBER_WITH_TAG_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/member_at.hpp>
#include <boost/bimap/detail/debug/static_error.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/and.hpp>
/** \struct boost::bimaps::relation::support::member_with_tag
\brief Metafunction to convert user tags to the member_at idiom.
\code
template< class Tag, class Relation >
struct member_with_tag
{
typedef member_at::{side} type;
};
\endcode
We have to allow that all the metafunctions that works with tags
and retrieves data from a Relation will work with member_at idiom
even if the type was tagged. This will be great for the user,
because he can choose to tag a member after he is using the
relation and the code will still work.
If we perform this check in every metafunction it will be very
tedious and error prone, so instead of that all metafunctions
that works with relations first call this metafunction that
convert the tag to a member_at tag.
See also member_at, is_tag_of_member_at_left, is_tag_of_member_at_right.
\ingroup relation_group
**/
#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
template
<
class Tag,
class Relation,
class Enable = void
>
struct member_with_tag
{
BOOST_BIMAP_STATIC_ERROR( MEMBER_WITH_TAG_FAILURE, (Relation,Tag) );
};
template< class Relation >
struct member_with_tag
<
member_at::left, Relation, void
>
{
typedef member_at::left type;
};
template< class Relation >
struct member_with_tag
<
member_at::right, Relation, void
>
{
typedef member_at::right type;
};
template< class Tag, class Relation >
struct member_with_tag
<
Tag, Relation,
BOOST_DEDUCED_TYPENAME enable_if
<
mpl::and_
<
mpl::not_< is_same<Tag,member_at::left> >,
is_same
<
Tag,
BOOST_DEDUCED_TYPENAME Relation::left_tag
>
>
>::type
>
{
typedef member_at::left type;
};
template< class Tag, class Relation >
struct member_with_tag
<
Tag,
Relation,
BOOST_DEDUCED_TYPENAME enable_if
<
mpl::and_
<
mpl::not_< is_same<Tag,member_at::right> >,
is_same
<
Tag,
BOOST_DEDUCED_TYPENAME Relation::right_tag
>
>
>::type
>
{
typedef member_at::right type;
};
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
#endif // BOOST_BIMAP_RELATION_SUPPORT_MEMBER_WITH_TAG_HPP
--- NEW FILE: opposite_tag.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/opposite_tag.hpp
/// \brief Metafunction to obtain the opposite tag in a relation.
#ifndef BOOST_BIMAP_RELATION_SUPPORT_OPPOSITE_TAG_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_OPPOSITE_TAG_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
/** \struct boost::bimaps::relation::support::opposite_tag
\brief Metafunction to obtain the opposite tag in a relation.
\code
template< class Tag, class Relation >
struct opposite_tag
{
typedef {OppositeTag} type;
};
\endcode
\ingroup relation_group
**/
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
// Implementation of const pair reference type by metafunction
BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
(
opossite_tag,
right_tag,
left_tag
);
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_RELATION_SUPPORT_OPPOSITE_TAG_HPP
--- NEW FILE: pair_by.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/pair_by.hpp
/// \brief pair_by<member>(r) function
#ifndef BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/standard_relation_fwd.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/bimap/relation/support/pair_type_by.hpp>
#include <boost/bimap/relation/detail/access_builder.hpp>
#ifdef BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
/** \brief Gets a pair view of the relation.
\ingroup relation_group
**/
template< class Tag, class Relation >
BOOST_DEDUCED_TYPENAME result_of::pair_by<Tag,Relation>::type
pair_by( Relation & rel );
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_ONLY_DOXYGEN_WILL_PROCESS_THE_FOLLOWING_LINES
#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
// Since it is very error-prone to directly write the hole bunch
// of relation accesor. They are buil from litle macro blocks that
// are both more readable, leading to self docummenting code and a
// lot more easier to understand and mantain.
// It is very important to note that the three building blocks have
// to laid in the same namespace in order to work. There is also
// important to keep them in order.
// The forward declaration are not necesary but they help a lot to
// the reader, as they undercover what is the signature of the
// result code.
// In the end, it is not quicker to do it in this way because you
// write a lot. But this code has no complexity at all and almost
// every word writed is for documentation.
// Result of
// -------------------------------------------------------------------------
/*
namespace result_of {
template< class Tag, class Relation >
struct pair_by<Tag,Relation>;
{
typedef -unspecified- type;
};
} // namespace result_of
*/
// TODO
// This works for Boost.Bimap but not for all the uses of Relation outside
// Boost.Bimap. For now it will stay as is, because if standard_relation is
// eliminated all the functions will be simplified.
// It cannot be used directly BOOST_BIMAP_SYMMETRIC_ACCESS_RESULT_OF_BUILDER
here.
namespace result_of {
template< class Tag, class Relation >
struct pair_by
{
typedef BOOST_DEDUCED_TYPENAME mpl::if_< is_const<Relation>,
// {
BOOST_DEDUCED_TYPENAME const_pair_reference_type_by< Tag,Relation
>::type,
// }
// else
// {
BOOST_DEDUCED_TYPENAME pair_reference_type_by< Tag,Relation >::type
// }
>::type type;
};
} // namespace result_of
// Implementation
// -------------------------------------------------------------------------
BOOST_BIMAP_SYMMETRIC_ACCESS_IMPLEMENTATION_BUILDER
(
pair_by,
Relation,
rel,
return rel.get_left_pair(),
return rel.get_right_pair()
);
// Interface
// --------------------------------------------------------------------------
template< class Tag, class Symmetric >
BOOST_DEDUCED_TYPENAME enable_if<
::boost::mpl::or_<
is_standard_pair_view< Symmetric >,
is_standard_relation_view< Symmetric >
>,
BOOST_DEDUCED_TYPENAME result_of::pair_by< Tag, Symmetric >::type
>::type
pair_by( Symmetric s )
{
typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
member_with_tag
<
Tag, Symmetric
>::type member_at_tag;
return detail::pair_by(member_at_tag(),s);
}
template< class Tag, class Symmetric >
BOOST_DEDUCED_TYPENAME disable_if<
::boost::mpl::or_<
is_standard_pair_view< Symmetric >,
is_standard_relation_view< Symmetric >
>,
BOOST_DEDUCED_TYPENAME result_of::pair_by< Tag, Symmetric >::type
>::type
pair_by( Symmetric & s )
{
typedef BOOST_DEDUCED_TYPENAME ::boost::bimaps::relation::support::
member_with_tag
<
Tag, Symmetric
>::type member_at_tag;
return detail::pair_by(member_at_tag(),s);
}
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_DOXIGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
#endif // BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_HPP
--- NEW FILE: pair_type_by.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/pair_type_by.hpp
/// \brief pair_type_by<tag,relation> metafunction
#ifndef BOOST_BIMAP_RELATION_SUPPORT_PAIR_TYPE_BY_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_PAIR_TYPE_BY_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
/** \struct boost::bimaps::relation::support::pair_type_by
\brief Metafunction to obtain the view type indexed by one of the sides.
\code
template< class Tag, class Relation >
struct pair_type_by
{
typedef {signature-compatible with std::pair} type;
};
\endcode
See also member_at, pair_by().
\ingroup relation_group
**/
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
// Implementation of pair type by metafunction
BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
(
pair_type_by,
left_pair,
right_pair
);
// Implementation of pair reference type by metafunction
BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
(
pair_reference_type_by,
left_pair_reference,
right_pair_reference
);
// Implementation of const pair reference type by metafunction
BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
(
const_pair_reference_type_by,
const_left_pair_reference,
const_right_pair_reference
);
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_RELATION_SUPPORT_PAIR_BY_TYPE_HPP
--- NEW FILE: value_type_of.hpp ---
// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)
/// \file relation/support/value_type_of.hpp
/// \brief value_type_of<tag,relation> metafunction
#ifndef BOOST_BIMAP_RELATION_SUPPORT_VALUE_TYPE_OF_HPP
#define BOOST_BIMAP_RELATION_SUPPORT_VALUE_TYPE_OF_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
/** \struct boost::bimaps::relation::support::value_type_of
\brief Metafunction to obtain the value type of one of the sides.
\code
template< class Tag, class Relation >
struct value_type_of
{
typedef typename Relation::{side}_type type;
};
\endcode
See also member_at, get().
\ingroup relation_group
**/
namespace boost {
namespace bimaps {
namespace relation {
namespace support {
// Metafunction value_type_of
/*
template< class Tag, class Relation >
struct value_type_of
{
typedef -unspecified- type;
};
*/
BOOST_BIMAP_SYMMETRIC_METADATA_ACCESS_BUILDER
(
value_type_of,
left_value_type,
right_value_type
);
} // namespace support
} // namespace relation
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_RELATION_SUPPORT_VALUE_TYPE_OF_HPP
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
