stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
@@ -0,0 +1,290 @@
|
||||
/*
|
||||
* Copyright Andrey Semashev 2007 - 2015.
|
||||
* 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 attribute_mapping.hpp
|
||||
* \author Andrey Semashev
|
||||
* \date 07.11.2008
|
||||
*
|
||||
* The header contains facilities that are used in different sinks to map attribute values
|
||||
* used throughout the application to values used with the specific native logging API.
|
||||
* These tools are mostly needed to map application severity levels on native levels,
|
||||
* required by OS-specific sink backends.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_LOG_SINKS_ATTRIBUTE_MAPPING_HPP_INCLUDED_
|
||||
#define BOOST_LOG_SINKS_ATTRIBUTE_MAPPING_HPP_INCLUDED_
|
||||
|
||||
#include <map>
|
||||
#include <boost/log/detail/config.hpp>
|
||||
#include <boost/log/detail/tagged_integer.hpp>
|
||||
#include <boost/log/core/record_view.hpp>
|
||||
#include <boost/log/attributes/attribute_name.hpp>
|
||||
#include <boost/log/attributes/attribute_value_set.hpp>
|
||||
#include <boost/log/attributes/value_visitation.hpp>
|
||||
#include <boost/log/detail/header.hpp>
|
||||
|
||||
#ifdef BOOST_HAS_PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
BOOST_LOG_OPEN_NAMESPACE
|
||||
|
||||
namespace sinks {
|
||||
|
||||
//! Base class for attribute mapping function objects
|
||||
template< typename MappedT >
|
||||
struct basic_mapping
|
||||
{
|
||||
//! Mapped value type
|
||||
typedef MappedT mapped_type;
|
||||
//! Result type
|
||||
typedef mapped_type result_type;
|
||||
};
|
||||
|
||||
namespace aux {
|
||||
|
||||
//! Attribute value visitor
|
||||
template< typename MappedT >
|
||||
struct direct_mapping_visitor
|
||||
{
|
||||
typedef void result_type;
|
||||
typedef MappedT mapped_type;
|
||||
|
||||
explicit direct_mapping_visitor(mapped_type& extracted) :
|
||||
m_Extracted(extracted)
|
||||
{
|
||||
}
|
||||
template< typename T >
|
||||
void operator() (T const& val) const
|
||||
{
|
||||
m_Extracted = mapped_type(val);
|
||||
}
|
||||
|
||||
private:
|
||||
mapped_type& m_Extracted;
|
||||
};
|
||||
// Specialization for the tagged integer
|
||||
template< typename IntT, typename TagT >
|
||||
struct direct_mapping_visitor< boost::log::aux::tagged_integer< IntT, TagT > >
|
||||
{
|
||||
typedef void result_type;
|
||||
typedef boost::log::aux::tagged_integer< IntT, TagT > mapped_type;
|
||||
|
||||
explicit direct_mapping_visitor(mapped_type& extracted) :
|
||||
m_Extracted(extracted)
|
||||
{
|
||||
}
|
||||
template< typename T >
|
||||
void operator() (T const& val) const
|
||||
{
|
||||
mapped_type v = { static_cast< IntT >(val) };
|
||||
m_Extracted = v;
|
||||
}
|
||||
|
||||
private:
|
||||
mapped_type& m_Extracted;
|
||||
};
|
||||
|
||||
} // namespace aux
|
||||
|
||||
/*!
|
||||
* \brief Straightforward mapping
|
||||
*
|
||||
* This type of mapping assumes that attribute with a particular name always
|
||||
* provides values that map directly onto the native values. The mapping
|
||||
* simply returns the extracted attribute value converted to the native value.
|
||||
*/
|
||||
template< typename MappedT, typename AttributeValueT = int >
|
||||
class basic_direct_mapping :
|
||||
public basic_mapping< MappedT >
|
||||
{
|
||||
//! Base type
|
||||
typedef basic_direct_mapping< MappedT > base_type;
|
||||
|
||||
public:
|
||||
//! Attribute contained value type
|
||||
typedef AttributeValueT attribute_value_type;
|
||||
//! Mapped value type
|
||||
typedef typename base_type::mapped_type mapped_type;
|
||||
|
||||
private:
|
||||
//! Attribute name
|
||||
const attribute_name m_Name;
|
||||
//! Visitor invoker for the attribute value
|
||||
value_visitor_invoker< attribute_value_type > m_Invoker;
|
||||
//! Default native value
|
||||
mapped_type m_DefaultValue;
|
||||
|
||||
public:
|
||||
/*!
|
||||
* Constructor
|
||||
*
|
||||
* \param name Attribute name
|
||||
* \param default_value The default native value that is returned if the attribute value is not found
|
||||
*/
|
||||
explicit basic_direct_mapping(attribute_name const& name, mapped_type const& default_value) :
|
||||
m_Name(name),
|
||||
m_DefaultValue(default_value)
|
||||
{
|
||||
}
|
||||
|
||||
/*!
|
||||
* Extraction operator
|
||||
*
|
||||
* \param rec A log record to extract value from
|
||||
* \return An extracted attribute value
|
||||
*/
|
||||
mapped_type operator() (record_view const& rec) const
|
||||
{
|
||||
mapped_type res = m_DefaultValue;
|
||||
aux::direct_mapping_visitor< mapped_type > vis(res);
|
||||
m_Invoker(m_Name, rec.attribute_values(), vis);
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
/*!
|
||||
* \brief Customizable mapping
|
||||
*
|
||||
* The class allows to setup a custom mapping between an attribute and native values.
|
||||
* The mapping should be initialized similarly to the standard \c map container, by using
|
||||
* indexing operator and assignment.
|
||||
*
|
||||
* \note Unlike many other components of the library, exact type of the attribute value
|
||||
* must be specified in the template parameter \c AttributeValueT. Type sequences
|
||||
* are not supported.
|
||||
*/
|
||||
template< typename MappedT, typename AttributeValueT = int >
|
||||
class basic_custom_mapping :
|
||||
public basic_mapping< MappedT >
|
||||
{
|
||||
//! Base type
|
||||
typedef basic_mapping< MappedT > base_type;
|
||||
|
||||
public:
|
||||
//! Attribute contained value type
|
||||
typedef AttributeValueT attribute_value_type;
|
||||
//! Mapped value type
|
||||
typedef typename base_type::mapped_type mapped_type;
|
||||
|
||||
private:
|
||||
//! \cond
|
||||
|
||||
//! Mapping type
|
||||
typedef std::map< attribute_value_type, mapped_type > mapping_type;
|
||||
//! Smart reference class for implementing insertion into the map
|
||||
class reference_proxy;
|
||||
friend class reference_proxy;
|
||||
class reference_proxy
|
||||
{
|
||||
mapping_type& m_Mapping;
|
||||
attribute_value_type m_Key;
|
||||
|
||||
public:
|
||||
//! Constructor
|
||||
reference_proxy(mapping_type& mapping, attribute_value_type const& key) : m_Mapping(mapping), m_Key(key) {}
|
||||
//! Insertion
|
||||
reference_proxy const& operator= (mapped_type const& val) const
|
||||
{
|
||||
m_Mapping[m_Key] = val;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
//! Attribute value visitor
|
||||
struct visitor;
|
||||
friend struct visitor;
|
||||
struct visitor
|
||||
{
|
||||
typedef void result_type;
|
||||
|
||||
visitor(mapping_type const& mapping, mapped_type& extracted) :
|
||||
m_Mapping(mapping),
|
||||
m_Extracted(extracted)
|
||||
{
|
||||
}
|
||||
template< typename T >
|
||||
void operator() (T const& val) const
|
||||
{
|
||||
typename mapping_type::const_iterator it = m_Mapping.find(val);
|
||||
if (it != m_Mapping.end())
|
||||
m_Extracted = it->second;
|
||||
}
|
||||
|
||||
private:
|
||||
mapping_type const& m_Mapping;
|
||||
mapped_type& m_Extracted;
|
||||
};
|
||||
|
||||
//! \endcond
|
||||
|
||||
private:
|
||||
//! Attribute name
|
||||
const attribute_name m_Name;
|
||||
//! Visitor invoker for the attribute value
|
||||
value_visitor_invoker< attribute_value_type > m_Invoker;
|
||||
//! Default native value
|
||||
mapped_type m_DefaultValue;
|
||||
//! Conversion mapping
|
||||
mapping_type m_Mapping;
|
||||
|
||||
public:
|
||||
/*!
|
||||
* Constructor
|
||||
*
|
||||
* \param name Attribute name
|
||||
* \param default_value The default native value that is returned if the conversion cannot be performed
|
||||
*/
|
||||
explicit basic_custom_mapping(attribute_name const& name, mapped_type const& default_value) :
|
||||
m_Name(name),
|
||||
m_DefaultValue(default_value)
|
||||
{
|
||||
}
|
||||
/*!
|
||||
* Extraction operator. Extracts the attribute value and attempts to map it onto
|
||||
* the native value.
|
||||
*
|
||||
* \param rec A log record to extract value from
|
||||
* \return A mapped value, if mapping was successful, or the default value if
|
||||
* mapping did not succeed.
|
||||
*/
|
||||
mapped_type operator() (record_view const& rec) const
|
||||
{
|
||||
mapped_type res = m_DefaultValue;
|
||||
visitor vis(m_Mapping, res);
|
||||
m_Invoker(m_Name, rec.attribute_values(), vis);
|
||||
return res;
|
||||
}
|
||||
/*!
|
||||
* Insertion operator
|
||||
*
|
||||
* \param key Attribute value to be mapped
|
||||
* \return An object of unspecified type that allows to insert a new mapping through assignment.
|
||||
* The \a key argument becomes the key attribute value, and the assigned value becomes the
|
||||
* mapped native value.
|
||||
*/
|
||||
#ifndef BOOST_LOG_DOXYGEN_PASS
|
||||
reference_proxy operator[] (attribute_value_type const& key)
|
||||
#else
|
||||
implementation_defined operator[] (attribute_value_type const& key)
|
||||
#endif
|
||||
{
|
||||
return reference_proxy(m_Mapping, key);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace sinks
|
||||
|
||||
BOOST_LOG_CLOSE_NAMESPACE // namespace log
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/log/detail/footer.hpp>
|
||||
|
||||
#endif // BOOST_LOG_SINKS_ATTRIBUTE_MAPPING_HPP_INCLUDED_
|
||||
Reference in New Issue
Block a user