Traits usage sketch!

[the-moisrex]

I'm using here as an sketch to see which way is the best way to implement.

Example codes of possible implementations:

  // global (not really)
  allocator_pack<stl::pmr::allocator_pack> alloc_pack();
  alloc_pack.set_upstream(...);

  void local_function() {
      stack_allocator<1024> arena(alloc_pack); // a resource
      for (auto long_str: long_strings) {
         resource<basic_string<...>> str(arena, long_str);
         str += "; not that long";
      }
  }

  // global or in main
  int main() {
     allocator_pack<stl::pmr::allocator_pack> alloc_pack();
     memory_buffer buff;
     pmr::monotonic_buffer_resource mbr(buff.data(), buff.size());
     alloc_pack.template set_upstream<pmr::monotonic_buffer_resource>(mbr);
     auto str = do(alloc_pack);
     cout << str << endl;
  }

  template <typename T>
  auto do(allocator_pack<T> &alloc_pack) {
     stack_allocator<1024> arena(alloc_pack);
     object<string> res(arena);
     for (auto str : strs) {
         res += str;
     }
     return heap(res, alloc_pack); // copy from stack to heap
  }

  template <typename T>
  auto do2(allocator_pack<T> &alloc_pack) {
     auto res = make_object<string>(alloc_pack, alloc::unsync, alloc::high_utilization);
     // fill res
     return res;
  }

  template <typename T>
  auto do3(allocator_pack<T> &alloc_pack) {
     auto res = alloc_pack.template make_object<string>();
     // ...
     return res;
  }

  auto do(allocator_pack<T> &alloc_pack) {
     auto res = make<std::basic_string,
                     char,
                     std::char_traits<char>,
                     alloc_placeholder>(alloc_pack, alloc_placeholder{});
     // ...
     return res;
  }

  auto do2(allocator_pack<T>&alloc_pack) {
     auto res = make<std::string>(alloc_pack, alloc::placeholder());
     // ...
     return res;
  }

Ideas about using Traits in a class

The goal here is to see which way is the best way to get a string type out of traits type. I think all of them are implementable but which one is the best way? String type is just an example, but other types like Logger and others that will be added later should also be considered.

the type itself chooses the allocator type

  template <Traits TraitsType>
  struct some_type {
     static constexpr features_pack allocator_features = features_pack{
         alloc::unsync, alloc::noop_dealloc, stateful
     };
     using traits_type = TraitsType;
     using allocator_type = traits::allocator<traits_type, allocator_features>;
     using string_type = traits::string<traits_type, allocator_type>;
     using string_allocator_type = typename string_type::allocator_type;

     string_type str;

     some_type(AllocatorPack auto& alloc_pack) : str{make<string_type>(alloc_pack)} {}
  };

using a traits feature type (overkill or necessary??)

  template <Traits TraitsType, TraitsFeatures TFeatures>
  struct another_type {
     using traits_features = TFeatures;
     using allocator_features = typename traits_features::allocator_features;
     using traits_type = TraitsType;
     using allocator_type = traits::allocator<traits_type, allocator_features>
     using string_type = traits::string<traits_type, allocator_type>;

     string_type str;

     another_type(AllocatorPack auto& alloc_pack) : str{alloc_pack.template get<allocator_type>()} {}
  };

minimal type with no traits; this is the perfect choice when possible

  template <istl::String StringType>
  struct minimal_type {
     using string_type = StringType;
     using allocator_type = typename string_type::StringType;

     string_type str;

     minimal_type (allocator_type const &alloc) : str{alloc} {}
  };

using a daddy type which solves all of these issues and more

  template <Traits TraitsType>
  struct has_daddy : public enabled_traits<TraitsType> {
     using etraits = enabled_traits<TraitsType>;
     using string_type = typename etraits::string_type;
  };

using a special parent for each type (also we would need enabled_allocator, enabled_logger, ...):

  template <Traits TraitsType>
  struct has_special_daddy : public enabled_string<TraitsType> {
     using etraits = enabled_string<TraitsType>;
     using string_type = typename etraits::string_type;
  };