internal::arg_map< Context > Class Template Reference

Collaboration diagram for internal::arg_map< Context >:

Classes
struct	entry

Public Member Functions
	arg_map (const arg_map &)=delete
void	operator= (const arg_map &)=delete
void	init (const basic_format_args< Context > &args)
basic_format_arg< Context >	find (basic_string_view< char_type > name) const

Private Types
using	char_type = typename Context::char_type

Private Member Functions
void	push_back (value< Context > val)

Private Attributes
entry *	map_
unsigned	size_

Constructor & Destructor Documentation

arg_map()

template<typename Context >

internal::arg_map< Context >::arg_map ( )

inline

: map_(nullptr), size_(0) {}

~arg_map()

template<typename Context >

internal::arg_map< Context >::~arg_map ( )

inline

{ delete[] map_; }

Member Function Documentation

push_back()

template<typename Context >

void internal::arg_map< Context >::push_back ( value< Context >  val )

inlineprivate

                                     {
    const auto& named = *val.named_arg;
    map_[size_] = {named.name, named.template deserialize<Context>()};
    ++size_;
  }

init()

template<typename Context >

void internal::arg_map< Context >::init

(

const basic_format_args< Context > &

args

)

                                                                  {
  if (map_) return;
  map_ = new entry[internal::to_unsigned(args.max_size())];
  if (args.is_packed()) {
    for (int i = 0;; ++i) {
      internal::type arg_type = args.type(i);
      if (arg_type == internal::none_type) return;
      if (arg_type == internal::named_arg_type) push_back(args.values_[i]);
    }
  }
  for (int i = 0, n = args.max_size(); i < n; ++i) {
    auto type = args.args_[i].type_;
    if (type == internal::named_arg_type) push_back(args.args_[i].value_);
  }
}

find()

template<typename Context >

basic_format_arg< Context > internal::arg_map< Context >::find ( basic_string_view< char_type >  name ) const

inline

                                                                          {
    // The list is unsorted, so just return the first matching name.
    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
      if (it->name == name) return it->arg;
    }
    return {};
  }

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp