std::hive<T,Allocator>::is_within_hard_limits

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::hive

Member types
Member functions
hive::hive hive::~hive hive::operator= hive::assign hive::assign_range hive::get_allocator      Operations hive::splice hive::unique hive::sort hive::get_iterator Modifiers hive::emplacehive::emplace_hint hive::insert hive::insert_range hive::erase hive::swap hive::clear	Iterators hive::beginhive::cbegin hive::endhive::cend hive::rbeginhive::crbegin hive::rendhive::crend Capacity hive::empty hive::size hive::max_size hive::capacity hive::reserve hive::shrink_to_fit hive::trim_capacity hive::block_capacity_limits hive::block_capacity_default_limits hive::block_capacity_hard_limits hive::is_within_hard_limits hive::reshape
Non-member functions
erase(std::hive)erase_if(std::hive)	swap(std::hive)
Helper classes
hive_limits
Deduction guides

 

static constexpr bool is_within_hard_limits( std::hive_limits limits ) noexcept;		(since C++26)

Checks if given block capacity limits is within block capacity hard limits. Equivalent to

constexpr auto hard{block_capacity_hard_limits()};
return hard.min <= limits.min and limits.min <= limits.max and limits.max <= hard.max;

Return value

true if limits is within block capacity hard limits.

Complexity

Constant.

Example

Run this code

#include <hive>
#include <iostream>

using Garage = std::hive<int>;

static_assert(
    Garage::is_within_hard_limits(Garage::block_capacity_hard_limits()) &&
    Garage::is_within_hard_limits(Garage::block_capacity_default_limits())
);

int main()
{
    auto limits{std::hive<int>::block_capacity_hard_limits()};

    auto print = [](std::hive_limits limits)
    {
        std::cout << "Limits {min: " << limits.min << ", max: " << limits.max << "} is ";
        std::cout << (Garage::is_within_hard_limits(limits) ? "within" : "without")
                  << " block capacity hard limits\n";
    };
    print(limits);
    limits.min = 0;
    print(limits);
}

Possible output:

Limits {min: 3, max: 255} is within block capacity hard limits
Limits {min: 0, max: 255} is without block capacity hard limits

See also

capacity	returns the number of elements that can be held in currently allocated storage (public member function)
reserve	reserves storage (public member function)
shrink_to_fit	reduces memory usage by freeing unused memory (public member function)
trim_capacity	deallocates reserved blocks and reduces capacity accordingly (public member function)
block_capacity_limits	returns current block capacity limits (public member function)
block_capacity_default_limits [static]	returns block capacity default limits (public static member function)
block_capacity_hard_limits [static]	returns block capacity hard limits (public static member function)