shared Namespace Reference

Classes
struct	PrintContainer
struct	is_std_container
struct	is_std_container< std::deque< T, A > >
struct	is_std_container< std::list< T, A > >
struct	is_std_container< std::set< T, A > >
struct	is_std_container< std::unordered_set< T, A > >
struct	is_std_container< std::vector< T, A > >
struct	DivUMod

Functions
std::string	decode_base64_uri (const std::string &data, bool trim_nulls)
std::string	decode_base64 (const std::string &val, bool trim_nulls)
std::string	decode_base64 (const std::string &val)
static std::string	encode_base64 (const std::string &val)
size_t	formatDate (char *buf, size_t const max, int64_t const unixtime)
size_t	formatDateTime (char *buf, size_t const max, int64_t const timestamp, int const dimension)
size_t	formatHMS (char *buf, size_t const max, int64_t const unixtime)
template<typename T >
size_t	appendMove (std::vector< T > &destination, std::vector< T > &source)
template<typename... Ts, typename T >
bool	dynamic_castable_to_any (T const *ptr)
template<typename CONTAINER >
PrintContainer< CONTAINER >	printContainer (CONTAINER &container)
template<typename OSTREAM , typename CONTAINER >
OSTREAM &	operator<< (OSTREAM &os, PrintContainer< CONTAINER > pc)
DivUMod	divUMod (int64_t num, int64_t den)
uint64_t	unsignedMod (int64_t num, int64_t den)

Function Documentation

template<typename T >

size_t shared::appendMove	(	std::vector< T > &	destination,
		std::vector< T > &	source
	)

Definition at line 33 of file misc.h.

                                                                   {
  if (source.empty()) {
    return 0;
  } else if (destination.empty()) {
    destination = std::move(source);
    return destination.size();
  } else {
    size_t const source_size = source.size();
    destination.reserve(destination.size() + source_size);
    std::move(std::begin(source), std::end(source), std::back_inserter(destination));
    source.clear();
    return source_size;
  }
}

std::string shared::decode_base64 ( const std::string &  val, bool  trim_nulls  )

inline

Definition at line 27 of file base64.h.

Referenced by decode_base64(), and decode_base64_uri().

                                                                      {
  // For some strings, signatature particualary it is important no to trim
  // '\0' characters
  using namespace boost::archive::iterators;
  using It = transform_width<binary_from_base64<std::string::const_iterator>, 8, 6>;

  if (!trim_nulls) {
    return std::string(It(val.begin()), It(val.end()));
  }
  return boost::algorithm::trim_right_copy_if(
      std::string(It(std::begin(val)), It(std::end(val))),
      [](char c) { return c == '\0'; });
}

Here is the caller graph for this function:

std::string shared::decode_base64 ( const std::string &  val )

inline

Definition at line 41 of file base64.h.

References decode_base64().

                                                     {
  return decode_base64(val, true);
}

Here is the call graph for this function:

std::string shared::decode_base64_uri	(	const std::string &	data,
		bool	trim_nulls
	)

Definition at line 21 of file base64.cpp.

References decode_base64().

                                                                    {
  // Allocate a string large enough to hold exta '=' as padding
  std::string uri_dec;
  size_t data_len = data.length();
  // base64_uri encoding removes '=' padding at the end of the string.
  size_t padding = 4 - (data_len % 4);
  if (padding == 4) {
    padding = 0;
  }
  uri_dec.resize(data_len + padding);

  // base64_uri encoding replaces all '+' and '/' with '-' and '_' respectively.
  std::transform(
      data.begin(), data.end(), uri_dec.begin(), [](unsigned char c) -> unsigned char {
        switch (c) {
          case '-':
            return '+';
          case '_':
            return '/';
          default:
            return c;
        }
      });
  if (padding != 0) {
    uri_dec.replace(uri_dec.begin() + data_len, uri_dec.end(), padding, '=');
  }
  // in the case of a signature from a JWT trim_nulls should be false
  return decode_base64(uri_dec, trim_nulls);
}

Here is the call graph for this function:

DivUMod shared::divUMod ( int64_t  num, int64_t  den  )

inline

Definition at line 128 of file misc.h.

References shared::DivUMod::quot.

Referenced by formatDate(), and formatDateTime().

                                                 {
  DivUMod div{num / den, num % den};
  if (div.rem < 0) {
    --div.quot;
    div.rem += den;
  }
  return div;
}

Here is the caller graph for this function:

template<typename... Ts, typename T >

bool shared::dynamic_castable_to_any

(

T const *

ptr

)

Definition at line 49 of file misc.h.

                                           {
  return (... || dynamic_cast<Ts const*>(ptr));
}

static std::string shared::encode_base64 ( const std::string &  val )

inlinestatic

Definition at line 45 of file base64.h.

                                                            {
  using namespace boost::archive::iterators;
  using It = base64_from_binary<transform_width<std::string::const_iterator, 6, 8>>;
  auto tmp = std::string(It(std::begin(val)), It(std::end(val)));
  return tmp.append((3 - val.size() % 3) % 3, '=');
}

size_t shared::formatDate	(	char *	buf,
		size_t const	max,
		int64_t const	unixtime
	)

Definition at line 25 of file misc.cpp.

References divUMod(), shared::DivUMod::quot, and shared::DivUMod::rem.

Referenced by DatumToString().

                                                                       {
  DivUMod const div_day = divUMod(unixtime, 24 * 60 * 60);
  DivUMod const div_era = divUMod(div_day.quot - 11017, 146097);
  unsigned const doe = static_cast<unsigned>(div_era.rem);
  unsigned const yoe = (doe - doe / 1460 + doe / 36524 - (doe == 146096)) / 365;
  unsigned const doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
  unsigned const moy = (5 * doy + 2) / 153;
  static_assert(8 <= sizeof(long long));  // long long needed for snprintf()
  long long const y = 2000 + div_era.quot * 400 + yoe + (9 < moy);
  unsigned const m = moy + (9 < moy ? -9 : 3);
  unsigned const d = doy - (153 * moy + 2) / 5 + 1;
  int const len = snprintf(buf, max, "%04lld-%02u-%02u", y, m, d);
  if (0 <= len && static_cast<size_t>(len) < max) {
    return static_cast<size_t>(len);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t shared::formatDateTime	(	char *	buf,
		size_t const	max,
		int64_t const	timestamp,
		int const	dimension
	)

Definition at line 43 of file misc.cpp.

References divUMod(), shared::DivUMod::quot, and shared::DivUMod::rem.

Referenced by DatumToString().

                                           {
  constexpr int pow10[10]{
      1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
  DivUMod const div_hip = divUMod(timestamp, pow10[dimension]);
  DivUMod const div_day = divUMod(div_hip.quot, 24 * 60 * 60);
  DivUMod const div_era = divUMod(div_day.quot - 11017, 146097);
  unsigned const doe = static_cast<unsigned>(div_era.rem);
  unsigned const yoe = (doe - doe / 1460 + doe / 36524 - (doe == 146096)) / 365;
  unsigned const doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
  unsigned const moy = (5 * doy + 2) / 153;
  static_assert(8 <= sizeof(long long));  // long long needed for snprintf()
  long long const y = 2000 + div_era.quot * 400 + yoe + (9 < moy);
  unsigned const m = moy + (9 < moy ? -9 : 3);
  unsigned const d = doy - (153 * moy + 2) / 5 + 1;
  unsigned const minutes = static_cast<unsigned>(div_day.rem) / 60;
  unsigned const ss = div_day.rem % 60;
  unsigned const hh = minutes / 60;
  unsigned const mm = minutes % 60;
  int const len =
      snprintf(buf, max, "%04lld-%02u-%02u %02u:%02u:%02u", y, m, d, hh, mm, ss);
  if (0 <= len && static_cast<size_t>(len) < max) {
    if (dimension) {
      int const len_frac = snprintf(
          buf + len, max - len, ".%0*d", dimension, static_cast<int>(div_hip.rem));
      if (0 <= len_frac && static_cast<size_t>(len + len_frac) < max) {
        return static_cast<size_t>(len + len_frac);
      }
    } else {
      return static_cast<size_t>(len);
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t shared::formatHMS	(	char *	buf,
		size_t const	max,
		int64_t const	unixtime
	)

Definition at line 80 of file misc.cpp.

References unsignedMod().

Referenced by DatumToString(), import_export::QueryExporterCSV::exportResults(), import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_array_column(), and import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_scalar_column().

                                                                      {
  unsigned const seconds = static_cast<unsigned>(unsignedMod(unixtime, 24 * 60 * 60));
  unsigned const minutes = seconds / 60;
  unsigned const ss = seconds % 60;
  unsigned const hh = minutes / 60;
  unsigned const mm = minutes % 60;
  int const len = snprintf(buf, max, "%02u:%02u:%02u", hh, mm, ss);
  if (0 <= len && static_cast<size_t>(len) < max) {
    return static_cast<size_t>(len);
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename OSTREAM , typename CONTAINER >

OSTREAM& shared::operator<<	(	OSTREAM &	os,
		PrintContainer< CONTAINER >	pc
	)

Definition at line 82 of file misc.h.

References printContainer().

                                                               {
  if (pc.container.empty()) {
    return os << "()";
  } else {
    if constexpr (is_std_container<typename CONTAINER::value_type>::value) {
      os << '(';
      for (auto& container : pc.container) {
        os << printContainer(container);
      }
    } else {
      for (auto itr = pc.container.begin(); itr != pc.container.end(); ++itr) {
        if constexpr (std::is_pointer_v<typename CONTAINER::value_type>) {
          os << (itr == pc.container.begin() ? '(' : ' ') << (void const*)*itr;
        } else {
          os << (itr == pc.container.begin() ? '(' : ' ') << *itr;
        }
      }
    }
    return os << ')';
  }
}

Here is the call graph for this function:

template<typename CONTAINER >

PrintContainer<CONTAINER> shared::printContainer

(

CONTAINER &

container

)

Definition at line 64 of file misc.h.

Referenced by QueryFragmentDescriptor::buildFragmentPerKernelMapForUnion(), RelAlgExecutor::createCompoundWorkUnit(), RelAlgExecutor::createUnionWorkUnit(), Executor::executePlanWithGroupBy(), Executor::fetchUnionChunks(), import_export::import_thread_delimited(), operator<<(), operator<<(), foreign_storage::csv_file_buffer_parser::parse_buffer(), ddl_utils::set_whitelisted_paths(), and anonymous_namespace{RelAlgExecutor.cpp}::target_exprs_for_union().

                                                               {
  return {container};
}

Here is the caller graph for this function:

uint64_t shared::unsignedMod ( int64_t  num, int64_t  den  )

inline

Definition at line 138 of file misc.h.

Referenced by formatHMS().

                                                      {
  int64_t mod = num % den;
  if (mod < 0) {
    mod += den;
  }
  return mod;
}

Here is the caller graph for this function: