be/src/common/names.h

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

/// The motivation for the using declarations below is to allow accessing the most
/// relevant and most frequently used library classes without having to explicitly pull
/// them into the global namespace. The goal is that when readers sees a usage of vector
/// (etc.) without any further specialization they can rely on the fact that it will be a
/// std::vector.
//
/// Instead of actually including the header files for the symbols, this file only checks
/// if certain include guards are defined before applying the using declaration. This
/// makes sure that including this file has no impact on the compile time.
//
/// Please make sure that this file is included last in the cc file's include list to make
/// sure that all relevant include guards are defined.
//
/// The content of this file is manually curated and should only be changed on rare
/// occasions.
#include <boost/version.hpp>

#ifdef _GLIBCXX_VECTOR
using std::vector;
#endif

#ifdef _GLIBCXX_MAP
using std::map;
using std::multimap;
#endif

#ifdef _GLIBCXX_LIST
using std::list;
#endif

#ifdef _GLIBCXX_SET
using std::set;
using std::multiset;
#endif

#ifdef _GLIBCXX_STACK
using std::stack;
#endif

#ifdef _GLIBCXX_QUEUE
using std::queue;
#endif

#ifdef _GLIBCXX_DEQUE
using std::deque;
#endif

#ifdef _GLIBCXX_STRING
using std::string;
#endif

#ifdef _GLIBCXX_IOSTREAM
using std::cout;
using std::cin;
using std::cerr;
#endif

#ifdef _GLIBCXX_OSTREAM
using std::ostream;
using std::endl;
#endif

#ifdef _GLIBCXX_IOS
using std::fixed;
using std::hex;
using std::oct;
using std::dec;
using std::left;
using std::ios;
#endif

#ifdef _GLIBCXX_IOMANIP
using std::setprecision;
using std::setfill;
using std::setw;
#endif


#ifdef _GLIBCXX_FSTREAM
using std::fstream;
using std::ifstream;
using std::ofstream;
#endif


#ifdef _GLIBCXX_SSTREAM
using std::stringstream;
using std::istringstream;
using std::ostringstream;
#endif

#ifdef _GLIBCXX_ALGORITHM
using std::swap;
using std::min;
using std::max;
using std::sort;
#endif

#ifdef _GLIBCXX_MEMORY
using std::make_shared;
using std::make_unique;
using std::shared_ptr;
using std::unique_ptr;
#endif

#ifdef _GLIBCXX_UTILITY
using std::move;
#endif

#ifdef _NEW
using std::nothrow;
#endif

#ifdef BOOST_THREAD_THREAD_COMMON_HPP
using boost::thread;
#endif

#ifdef BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
using boost::thread_group;
#endif

#ifdef BOOST_THREAD_MUTEX_HPP
using boost::mutex;
using boost::timed_mutex;
using boost::try_mutex;
#endif

#ifdef BOOST_LEXICAL_CAST_INCLUDED
using boost::lexical_cast;
#endif

#ifdef BOOST_THREAD_PTHREAD_SHARED_MUTEX_HPP
using boost::shared_mutex;
#endif


/// In older versions of boost, when including mutex.hpp, it would include locks.hpp that
/// would in turn provide lock_guard<>. In more recent versions, including mutex.hpp would
/// include lock_types.hpp that does not provide lock_guard<>. This check verifies if boost
/// locks have been included and makes sure to only include lock_guard if the provided lock
/// implementations were not included using lock_types.hpp (for older boost versions) or if
/// lock_guard.hpp was explicitly included.
#if (defined(BOOST_THREAD_LOCKS_HPP) && BOOST_VERSION < 105300)  || defined(BOOST_THREAD_LOCK_GUARD_HPP)
using boost::lock_guard;
#endif

#if defined(BOOST_THREAD_LOCKS_HPP) || defined(BOOST_THREAD_LOCK_TYPES_HPP)
using boost::unique_lock;
using boost::shared_lock;
using boost::upgrade_lock;
#endif

#ifdef BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED
using boost::scoped_ptr;
#endif

#ifdef BOOST_UNORDERED_MAP_HPP_INCLUDED
using boost::unordered_map;
#endif

#ifdef BOOST_UNORDERED_SET_HPP_INCLUDED
using boost::unordered_set;
#endif

#ifdef BOOST_FUNCTION_PROLOGUE_HPP
using boost::function;
#endif

#ifdef BOOST_BIND_HPP_INCLUDED
using boost::bind;
using boost::mem_fn;
#endif

#ifdef STRINGS_SUBSTITUTE_H_
using strings::Substitute;
#endif