229 lines
6.7 KiB
C++
229 lines
6.7 KiB
C++
/*
|
|
* 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_name.cpp
|
|
* \author Andrey Semashev
|
|
* \date 28.06.2010
|
|
*
|
|
* \brief This header is the Boost.Log library implementation, see the library documentation
|
|
* at http://www.boost.org/doc/libs/release/libs/log/doc/html/index.html.
|
|
*/
|
|
|
|
#include <boost/log/detail/config.hpp>
|
|
#include <cstring>
|
|
#include <deque>
|
|
#include <ostream>
|
|
#include <stdexcept>
|
|
#include <boost/assert.hpp>
|
|
#include <boost/throw_exception.hpp>
|
|
#include <boost/smart_ptr/shared_ptr.hpp>
|
|
#include <boost/smart_ptr/make_shared_object.hpp>
|
|
#include <boost/intrusive/set.hpp>
|
|
#include <boost/intrusive/set_hook.hpp>
|
|
#include <boost/intrusive/options.hpp>
|
|
#include <boost/log/exceptions.hpp>
|
|
#include <boost/log/detail/singleton.hpp>
|
|
#include <boost/log/attributes/attribute_name.hpp>
|
|
#if !defined(BOOST_LOG_NO_THREADS)
|
|
#include <boost/log/detail/locks.hpp>
|
|
#include <boost/log/detail/light_rw_mutex.hpp>
|
|
#endif
|
|
#include <boost/log/detail/header.hpp>
|
|
|
|
namespace boost {
|
|
|
|
BOOST_LOG_OPEN_NAMESPACE
|
|
|
|
//! A global container of all known attribute names
|
|
class attribute_name::repository :
|
|
public log::aux::lazy_singleton<
|
|
repository,
|
|
shared_ptr< repository >
|
|
>
|
|
{
|
|
typedef log::aux::lazy_singleton<
|
|
repository,
|
|
shared_ptr< repository >
|
|
> base_type;
|
|
|
|
#if !defined(BOOST_LOG_BROKEN_FRIEND_TEMPLATE_SPECIALIZATIONS)
|
|
friend class log::aux::lazy_singleton<
|
|
repository,
|
|
shared_ptr< repository >
|
|
>;
|
|
#else
|
|
friend class base_type;
|
|
#endif
|
|
|
|
public:
|
|
// Import types from the basic_attribute_name template
|
|
typedef attribute_name::id_type id_type;
|
|
typedef attribute_name::string_type string_type;
|
|
|
|
//! A base hook for arranging the attribute names into a set
|
|
typedef intrusive::set_base_hook<
|
|
intrusive::link_mode< intrusive::safe_link >,
|
|
intrusive::optimize_size< true >
|
|
> node_by_name_hook;
|
|
|
|
private:
|
|
//! An element of the attribute names repository
|
|
struct node :
|
|
public node_by_name_hook
|
|
{
|
|
typedef node_by_name_hook base_type;
|
|
|
|
public:
|
|
//! A predicate for name-based ordering
|
|
struct order_by_name
|
|
{
|
|
typedef bool result_type;
|
|
|
|
bool operator() (node const& left, node const& right) const
|
|
{
|
|
return std::strcmp(left.m_name.c_str(), right.m_name.c_str()) < 0;
|
|
}
|
|
bool operator() (node const& left, const char* right) const
|
|
{
|
|
return std::strcmp(left.m_name.c_str(), right) < 0;
|
|
}
|
|
bool operator() (const char* left, node const& right) const
|
|
{
|
|
return std::strcmp(left, right.m_name.c_str()) < 0;
|
|
}
|
|
};
|
|
|
|
public:
|
|
id_type m_id;
|
|
string_type m_name;
|
|
|
|
public:
|
|
node() : m_id(0), m_name() {}
|
|
node(id_type i, string_type const& n) :
|
|
base_type(),
|
|
m_id(i),
|
|
m_name(n)
|
|
{
|
|
}
|
|
node(node const& that) :
|
|
base_type(),
|
|
m_id(that.m_id),
|
|
m_name(that.m_name)
|
|
{
|
|
}
|
|
};
|
|
|
|
//! The container that provides storage for nodes
|
|
typedef std::deque< node > node_list;
|
|
//! The container that provides name-based lookup
|
|
typedef intrusive::set<
|
|
node,
|
|
intrusive::base_hook< node_by_name_hook >,
|
|
intrusive::constant_time_size< false >,
|
|
intrusive::compare< node::order_by_name >
|
|
> node_set;
|
|
|
|
private:
|
|
#if !defined(BOOST_LOG_NO_THREADS)
|
|
typedef log::aux::light_rw_mutex mutex_type;
|
|
log::aux::light_rw_mutex m_Mutex;
|
|
#endif
|
|
node_list m_NodeList;
|
|
node_set m_NodeSet;
|
|
|
|
public:
|
|
//! Converts attribute name string to id
|
|
id_type get_id_from_string(const char* name)
|
|
{
|
|
BOOST_ASSERT(name != NULL);
|
|
|
|
#if !defined(BOOST_LOG_NO_THREADS)
|
|
{
|
|
// Do a non-blocking lookup first
|
|
log::aux::shared_lock_guard< mutex_type > _(m_Mutex);
|
|
node_set::const_iterator it =
|
|
m_NodeSet.find(name, node::order_by_name());
|
|
if (it != m_NodeSet.end())
|
|
return it->m_id;
|
|
}
|
|
#endif // !defined(BOOST_LOG_NO_THREADS)
|
|
|
|
BOOST_LOG_EXPR_IF_MT(log::aux::exclusive_lock_guard< mutex_type > _(m_Mutex);)
|
|
node_set::iterator it =
|
|
m_NodeSet.lower_bound(name, node::order_by_name());
|
|
if (it == m_NodeSet.end() || it->m_name != name)
|
|
{
|
|
const std::size_t new_id = m_NodeList.size();
|
|
if (new_id >= static_cast< id_type >(attribute_name::uninitialized))
|
|
BOOST_THROW_EXCEPTION(limitation_error("Too many log attribute names"));
|
|
|
|
m_NodeList.push_back(node(static_cast< id_type >(new_id), name));
|
|
it = m_NodeSet.insert(it, m_NodeList.back());
|
|
}
|
|
return it->m_id;
|
|
}
|
|
|
|
//! Converts id to the attribute name string
|
|
string_type const& get_string_from_id(id_type id)
|
|
{
|
|
BOOST_LOG_EXPR_IF_MT(log::aux::shared_lock_guard< mutex_type > _(m_Mutex);)
|
|
BOOST_ASSERT(id < m_NodeList.size());
|
|
return m_NodeList[id].m_name;
|
|
}
|
|
|
|
private:
|
|
//! Initializes the singleton instance
|
|
static void init_instance()
|
|
{
|
|
base_type::get_instance() = boost::make_shared< repository >();
|
|
}
|
|
};
|
|
|
|
BOOST_LOG_API attribute_name::id_type
|
|
attribute_name::get_id_from_string(const char* name)
|
|
{
|
|
return repository::get()->get_id_from_string(name);
|
|
}
|
|
|
|
BOOST_LOG_API attribute_name::string_type const&
|
|
attribute_name::get_string_from_id(id_type id)
|
|
{
|
|
return repository::get()->get_string_from_id(id);
|
|
}
|
|
|
|
template< typename CharT, typename TraitsT >
|
|
BOOST_LOG_API std::basic_ostream< CharT, TraitsT >& operator<< (
|
|
std::basic_ostream< CharT, TraitsT >& strm,
|
|
attribute_name const& name)
|
|
{
|
|
if (!!name)
|
|
strm << name.string().c_str();
|
|
else
|
|
strm << "[uninitialized]";
|
|
return strm;
|
|
}
|
|
|
|
// Explicitly instantiate attribute name implementation
|
|
#ifdef BOOST_LOG_USE_CHAR
|
|
template BOOST_LOG_API std::basic_ostream< char, std::char_traits< char > >&
|
|
operator<< < char, std::char_traits< char > >(
|
|
std::basic_ostream< char, std::char_traits< char > >& strm,
|
|
attribute_name const& name);
|
|
#endif
|
|
#ifdef BOOST_LOG_USE_WCHAR_T
|
|
template BOOST_LOG_API std::basic_ostream< wchar_t, std::char_traits< wchar_t > >&
|
|
operator<< < wchar_t, std::char_traits< wchar_t > >(
|
|
std::basic_ostream< wchar_t, std::char_traits< wchar_t > >& strm,
|
|
attribute_name const& name);
|
|
#endif
|
|
|
|
BOOST_LOG_CLOSE_NAMESPACE // namespace log
|
|
|
|
} // namespace boost
|
|
|
|
#include <boost/log/detail/footer.hpp>
|