toString.h File Reference

#include <cxxabi.h>
#include <cassert>
#include <chrono>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "sqldefs.h"
#include <mutex>

Include dependency graph for toString.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	anonymous_namespace{toString.h}::has_toString< T, typename >
struct	anonymous_namespace{toString.h}::has_toString< T, decltype(std::declval< T >().toString(), void())>
struct	anonymous_namespace{toString.h}::get_has_toString< T, typename >
struct	anonymous_namespace{toString.h}::has_printTo< T, typename >
struct	anonymous_namespace{toString.h}::has_printTo< T, decltype(std::declval< T >().printTo(std::declval< std::ostream & >()), void())>

Namespaces
	anonymous_namespace{toString.h}

Macros
#define	HAVE_TOSTRING
#define	__FILENAME__   (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
#define	PRINT(...)

Functions
template<typename T >
std::string	typeName (const T *v)
template<typename T , typename... Args>
std::string	typeName (T(*v)(Args...args))
template<typename T >
struct get_has_toString< T, decltype(std::declval< T > ().get() ->	anonymous_namespace{toString.h}::toString ()
template<typename T >
std::string	toString (const T &v)
template<typename T1 , typename T2 >
std::string	toString (const std::pair< T1, T2 > &v)
template<typename T >
std::string	toString (const std::vector< T > &v)
template<typename T1 , typename T2 >
std::string	toString (const std::unordered_map< T1, T2 > &v)
template<typename T1 , typename T2 >
std::string	toString (const std::map< T1, T2 > &v)
template<typename T >
std::string	toString (const std::list< T > &v)
template<typename T >
std::string	toString (const std::unordered_set< T > &v)
template<typename T >
std::string	toString (const std::set< T > &v)
template<typename... Ts, size_t... Is>
std::string	toStringImpl (const std::tuple< Ts...> &t, const std::index_sequence< 0, Is...>)
template<typename... T>
std::string	toStringImpl (const std::tuple<> &t, const std::index_sequence<>)
template<typename... Ts>
std::string	toString (const std::tuple< Ts...> &t)

Variables
static std::mutex	toString_PRINT_mutex
template<class T >
constexpr bool	anonymous_namespace{toString.h}::has_toString_v = has_toString<T>::value
template<class T >
struct get_has_toString< T, decltype(std::declval< T > ().get() -> void())> constexpr bool	anonymous_namespace{toString.h}::get_has_toString_v = get_has_toString<T>::value
template<class T >
constexpr bool	anonymous_namespace{toString.h}::has_printTo_v = has_printTo<T>::value

Macro Definition Documentation

#define __FILENAME__   (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)

Definition at line 90 of file toString.h.

#define HAVE_TOSTRING

Definition at line 39 of file toString.h.

#define PRINT

(

...

)

Value:

{                                                                                     \
    std::lock_guard<std::mutex> print_lock(toString_PRINT_mutex);                       \
    std::cout << std::hex                                                               \
              << ((std::hash<std::thread::id>()(std::this_thread::get_id())) & 0xffff)  \
              << std::dec << " [" << __FILENAME__ << ":" << __func__ << "#" << __LINE__ \
              << "]: " #__VA_ARGS__ "=" << ::toString(std::make_tuple(__VA_ARGS__))     \
              << std::endl                                                              \
              << std::flush;                                                            \
  }

Definition at line 91 of file toString.h.

Function Documentation

template<typename T >

std::string toString

(

const T &

v

)

Definition at line 180 of file toString.h.

References ANTI, INNER, INVALID, LEFT, SEMI, heavydb.dtypes::T, to_string(), toString(), typeName(), WINDOW_FUNCTION, and WINDOW_FUNCTION_FRAMING.

                               {
  if constexpr (std::is_same_v<T, std::string>) {  // NOLINT
    return "\"" + v + "\"";
#ifdef ENABLE_TOSTRING_RAPIDJSON
  } else if constexpr (std::is_same_v<T, rapidjson::Value>) {  // NOLINT
    rapidjson::StringBuffer buffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
    v.Accept(writer);
    return buffer.GetString();
#endif
#ifdef ENABLE_TOSTRING_LLVM
  } else if constexpr (std::is_same_v<T, llvm::Module>) {  // NOLINT
    std::string type_str;
    llvm::raw_string_ostream rso(type_str);
    v.print(rso, nullptr);
    return "(" + rso.str() + ")";
  } else if constexpr (std::is_same_v<T, llvm::Function>) {  // NOLINT
    std::string type_str;
    llvm::raw_string_ostream rso(type_str);
    v.print(rso, nullptr);
    return "(" + rso.str() + ")";
  } else if constexpr (std::is_same_v<T, llvm::Value>) {  // NOLINT
    std::string type_str;
    llvm::raw_string_ostream rso(type_str);
    v.print(rso);
    return "(" + rso.str() + ")";
  } else if constexpr (std::is_same_v<T, llvm::Argument>) {  // NOLINT
    std::string type_str;
    llvm::raw_string_ostream rso(type_str);
    v.print(rso);
    return "(" + rso.str() + ")";
  } else if constexpr (std::is_same_v<T, llvm::Type>) {  // NOLINT
    std::string type_str;
    llvm::raw_string_ostream rso(type_str);
    v.print(rso);
    return "(" + rso.str() + ")";
  } else if constexpr (std::is_same_v<T, llvm::Triple>) {  // NOLINT
    return v.str();
  } else if constexpr (std::is_same_v<T, llvm::opt::ArgStringList>) {  // NOLINT
    std::string r;
    for (unsigned i = 0; i < v.size(); i++) {
      if (i) {
        r += ", ";
      }
      r += v[i];
    }
    return "[" + r + "]";
  } else if constexpr (std::is_same_v<T, llvm::opt::DerivedArgList>) {  // NOLINT
    std::string r;
    for (unsigned i = 0; i < v.getNumInputArgStrings(); i++) {
      if (i) {
        r += ", ";
      }
      r += v.getArgString(i);
    }
    return "[" + r + "]";
  } else if constexpr (std::is_same_v<T, clang::driver::JobList>) {  // NOLINT
    std::string type_str;
    llvm::raw_string_ostream rso(type_str);
    v.Print(rso, nullptr, true);
    return rso.str();
#endif
#ifdef ENABLE_TOSTRING_PTHREAD
  } else if constexpr (std::is_same_v<T, pthread_mutex_t>) {  // NOLINT
    std::string r;
    r += "lock=" + std::to_string(v.__data.__lock);
    r += ", &owner=" + std::to_string(v.__data.__owner);
    r += ", &nusers=" + std::to_string(v.__data.__nusers);
    r += ", &count=" + std::to_string(v.__data.__count);
    return "{" + r + "}";
#endif
  } else if constexpr (std::is_same_v<T, bool>) {  // NOLINT
    return v ? "True" : "False";
  } else if constexpr (std::is_arithmetic_v<T>) {  // NOLINT
    return std::to_string(v);
#ifdef ENABLE_TOSTRING_str
  } else if constexpr (has_str_v<T>) {  // NOLINT
    return v.str();
#endif
#ifdef ENABLE_TOSTRING_to_string
  } else if constexpr (has_to_string_v<T>) {  // NOLINT
    return v.to_string();
#endif
  } else if constexpr (has_toString_v<T>) {  // NOLINT
    return v.toString();
  } else if constexpr (get_has_toString_v<T>) {
    auto ptr = v.get();
    return (ptr == NULL ? "NULL" : "&" + ptr->toString());
  } else if constexpr (std::is_same_v<T, void*>) {
    std::ostringstream ss;
    ss << std::hex << (uintptr_t)v;
    return "0x" + ss.str();
  } else if constexpr (std::is_same_v<
                           T,
                           std::chrono::time_point<std::chrono::system_clock>>) {
    std::string s(30, '\0');
    auto converted_v = (std::chrono::time_point<std::chrono::system_clock>)v;
    std::time_t ts = std::chrono::system_clock::to_time_t(v);
    std::strftime(&s[0], s.size(), "%Y-%m-%d %H:%M:%S", std::localtime(&ts));
    return s + "." +
           std::to_string((converted_v.time_since_epoch().count() / 1000) % 1000000);
  } else if constexpr (std::is_same_v<T, JoinType>) {
    switch (v) {
      case JoinType::INNER:
        return "INNER";
      case JoinType::LEFT:
        return "LEFT";
      case JoinType::SEMI:
        return "SEMI";
      case JoinType::ANTI:
        return "ANTI";
      case JoinType::WINDOW_FUNCTION:
        return "WINDOW_FUNCTION";
      case JoinType::WINDOW_FUNCTION_FRAMING:
        return "WINDOW_FUNCTION_FRAMING";
      case JoinType::INVALID:
        return "INVALID";
    }
    assert(false);
    return "";
  } else if constexpr (std::is_pointer_v<T>) {
    return (v == NULL ? "NULL" : "&" + toString(*v));
  } else if constexpr (has_printTo_v<T>) {
    std::ostringstream ss;
    v.printTo(ss);
    return ss.str();
  } else {
    return typeName(&v);
  }
}

Here is the call graph for this function:

template<typename T1 , typename T2 >

std::string toString

(

const std::pair< T1, T2 > &

v

)

Definition at line 325 of file toString.h.

References toString().

                                             {
  return "(" + toString(v.first) + ", " + toString(v.second) + ")";
}

Here is the call graph for this function:

template<typename T >

std::string toString

(

const std::vector< T > &

v

)

Definition at line 330 of file toString.h.

References run_benchmark_import::result, and toString().

                                          {
  auto result = std::string("[");
  for (size_t i = 0; i < v.size(); ++i) {
    if (i) {
      result += ", ";
    }
    result += toString(v[i]);
  }
  result += "]";
  return result;
}

Here is the call graph for this function:

template<typename T1 , typename T2 >

std::string toString

(

const std::unordered_map< T1, T2 > &

v

)

Definition at line 343 of file toString.h.

References run_benchmark_import::result, and toString().

                                                      {
  auto result = std::string("{");
  size_t i = 0;
  for (const auto& p : v) {
    if (i) {
      result += ", ";
    }
    result += toString(p);
    i++;
  }
  result += "}";
  return result;
}

Here is the call graph for this function:

template<typename T1 , typename T2 >

std::string toString

(

const std::map< T1, T2 > &

v

)

Definition at line 358 of file toString.h.

References run_benchmark_import::result, and toString().

                                            {
  auto result = std::string("{");
  size_t i = 0;
  for (const auto& p : v) {
    if (i) {
      result += ", ";
    }
    result += toString(p);
    i++;
  }
  result += "}";
  return result;
}

Here is the call graph for this function:

template<typename T >

std::string toString

(

const std::list< T > &

v

)

Definition at line 373 of file toString.h.

References run_benchmark_import::result, and toString().

                                        {
  auto result = std::string("[");
  size_t i = 0;
  for (const auto& p : v) {
    if (i) {
      result += ", ";
    }
    result += toString(p);
    i++;
  }
  result += "]";
  return result;
}

Here is the call graph for this function:

template<typename T >

std::string toString

(

const std::unordered_set< T > &

v

)

Definition at line 388 of file toString.h.

References run_benchmark_import::result, and toString().

                                                 {
  auto result = std::string("{");
  size_t i = 0;
  for (const auto& p : v) {
    if (i) {
      result += ", ";
    }
    result += toString(p);
    i++;
  }
  result += "}";
  return result;
}

Here is the call graph for this function:

template<typename T >

std::string toString

(

const std::set< T > &

v

)

Definition at line 403 of file toString.h.

References run_benchmark_import::result, and toString().

                                       {
  auto result = std::string("{");
  size_t i = 0;
  for (const auto& p : v) {
    if (i) {
      result += ", ";
    }
    result += toString(p);
    i++;
  }
  result += "}";
  return result;
}

Here is the call graph for this function:

template<typename... Ts>

std::string toString

(

const std::tuple< Ts...> &

t

)

Definition at line 429 of file toString.h.

References toStringImpl().

                                             {
  return "(" + toStringImpl(t, std::index_sequence_for<Ts...>{}) + ")";
}

Here is the call graph for this function:

template<typename... Ts, size_t... Is>

std::string toStringImpl	(	const std::tuple< Ts...> &	t,
		const std::index_sequence< 0, Is...>
	)

Definition at line 418 of file toString.h.

References toString().

Referenced by toString().

                                                            {
  return (toString(std::get<0>(t)) + ... + (", " + toString(std::get<Is>(t))));
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename... T>

std::string toStringImpl	(	const std::tuple<> &	t,
		const std::index_sequence<>
	)

Definition at line 424 of file toString.h.

                                                                       {
  return {};
}

template<typename T >

std::string typeName

(

const T *

v

)

Definition at line 103 of file toString.h.

References setup::name, and heavydb.dtypes::T.

Referenced by ai.heavy.jdbc.HeavyAIConnection::createArrayOf(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker::doesOperandTypeMatch(), com.mapd.calcite.parser.HeavyDBTypeSystem::getMaxPrecision(), com.mapd.parser.extension.ddl.heavydb.HeavyDBTypeNameSpec::HeavyDBTypeNameSpec(), ColumnList< T >::operator[](), CompilationResult::toString(), InputDescriptor::toString(), ExecutionResult::toString(), ColumnDescriptor::toString(), InputColDescriptor::toString(), RexAbstractInput::toString(), QueryCompilationDescriptor::toString(), Chunk_NS::Chunk::toString(), TableFunctionExecutionUnit::toString(), toString(), ResultSet::toString(), RexOperator::toString(), RexSubQuery::toString(), RexInput::toString(), RexCase::toString(), RexFunctionOperator::toString(), SortField::toString(), RexWindowFunctionOperator::toString(), RexRef::toString(), RexAgg::toString(), RelScan::toString(), RelProject::toString(), RelAggregate::toString(), RelJoin::toString(), RelTranslatedJoin::toString(), RelFilter::toString(), RelLeftDeepInnerJoin::toString(), RelCompound::toString(), RelSort::toString(), RelModify::toString(), RelTableFunction::toString(), RelLogicalValues::toString(), and RelLogicalUnion::toString().

                               {
  std::stringstream stream;
  int status;
#ifdef _WIN32
  stream << std::string(typeid(T).name());
#else
  char* demangled = abi::__cxa_demangle(typeid(T).name(), 0, 0, &status);
  stream << std::string(demangled);
  free(demangled);
#endif
  return stream.str();
}

Here is the caller graph for this function:

template<typename T , typename... Args>

std::string typeName

(

T(*)(Args...args)

v

)

Definition at line 117 of file toString.h.

References setup::name.

                                         {
  std::stringstream stream;
  int status;
#ifdef _WIN32
  stream << std::string(typeid(v).name());
#else
  char* demangled = abi::__cxa_demangle(typeid(v).name(), 0, 0, &status);
  stream << std::string(demangled);
  free(demangled);
#endif
  stream << "@0x" << std::hex << (uintptr_t)(reinterpret_cast<const void*>(v));
  return stream.str();
}

Variable Documentation

std::mutex toString_PRINT_mutex

inlinestatic

Definition at line 88 of file toString.h.