文字列アトムのコンテナ [詳解]

#include <wordring/string/atom.hpp>

公開型
using	allocator_type = Allocator

using	key_type = String

using	value_type = detail::basic_atom< key_type >

using	label_type = typename String::value_type

公開メンバ関数
	basic_atom_set ()
	空のコンテナを構築する [詳解]

	basic_atom_set (allocator_type const &alloc)
	アロケータを指定して空のコンテナを構築する [詳解]

template<typename InputIterator , typename std::enable_if_t< std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>
	basic_atom_set (InputIterator first, InputIterator last, allocator_type const &alloc=allocator_type())
	直列化データからの構築 [詳解]

template<typename InputIterator , typename std::enable_if_t< std::negation_v< std::is_integral< typename std::iterator_traits< InputIterator >::value_type >>, std::nullptr_t > = nullptr>
	basic_atom_set (InputIterator first, InputIterator last, allocator_type const &alloc=allocator_type())
	文字列リストからの構築 [詳解]

	basic_atom_set (std::initializer_list< detail::trie_node > il, allocator_type const &alloc=allocator_type())
	初期化子リストから構築する [詳解]

template<typename InputIterator , typename std::enable_if_t< std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>
void	assign (InputIterator first, InputIterator last)
	直列化データからの割り当て [詳解]

template<typename InputIterator , typename std::enable_if_t< std::negation_v< std::is_integral< typename std::iterator_traits< InputIterator >::value_type >>, std::nullptr_t > = nullptr>
void	assign (InputIterator first, InputIterator last)
	文字列リストからの割り当て [詳解]

value_type	at (std::uint32_t id) const
	IDからアトムを返す [詳解]

template<typename InputIterator >
value_type	at (InputIterator first, InputIterator last) const
	文字列からアトムを返す [詳解]

value_type	at (std::basic_string_view< label_type > sv) const
	文字列からアトムを返す [詳解]

value_type	operator[] (std::basic_string_view< label_type > sv)
	文字列からアトムを返す [詳解]

template<typename InputIterator >
value_type	insert (InputIterator first, InputIterator last)
	文字列を挿入する [詳解]

value_type	insert (std::basic_string_view< label_type > sv)
	文字列を挿入する [詳解]

void	erase (std::uint32_t id)
	アトムを削除する [詳解]

template<typename InputIterator >
void	erase (InputIterator first, InputIterator last)
	アトムを削除する [詳解]

void	erase (std::basic_string_view< label_type > sv)
	アトムを削除する [詳解]

template<typename InputIterator >
bool	contains (InputIterator first, InputIterator last) const
	文字列が格納されているか調べる [詳解]

bool	contains (std::basic_string_view< label_type > sv) const
	文字列が格納されているか調べる [詳解]

size_type	size () const noexcept
	格納しているキー文字列数を調べる [詳解]

限定公開型
using	base_type = stable_trie< typename String::value_type >

詳解

文字列アトムのコンテナ

単語に番号を割り当てる辞書のようなクラス。

文字列から整数値への変換、整数値から文字列の変換が出来る。整数値は、文字列に対して自動的に割り当てられるため、変更できない。

直列化

直列化には ibegin(), iend() を使う。

ibegin() の逆参照は32ビット整数値を返す。ファイルへ保存するためにバイト列を必要とする場合、直列化イテレータを使う。

wordring::serialize_iterator

構築子と解体子

◆ basic_atom_set() [1/5]

wordring::basic_atom_set::basic_atom_set ( )

inline

空のコンテナを構築する

例: // 空のコンテナを構築する

basic_atom_set<std::string> as;

◆ basic_atom_set() [2/5]

wordring::basic_atom_set::basic_atom_set ( allocator_type const & alloc )

inlineexplicit

アロケータを指定して空のコンテナを構築する

引数

[in] alloc アロケータ

例: // アロケータを指定して空のコンテナを構築する

basic_atom_set<std::string> as(std::allocator<detail::trie_node>{});

◆ basic_atom_set() [3/5]

template<typename InputIterator , typename std::enable_if_t< std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>

wordring::basic_atom_set::basic_atom_set	(	InputIterator	first,
		InputIterator	last,
		allocator_type const &	alloc = `allocator_type()`
	)

inline

直列化データからの構築

引数

[in]	first	直列化データの先頭を指すイテレータ
[in]	last	直列化データの終端を指すイテレータ
[in]	alloc	アロケータ

参照: assign(InputIterator first, InputIterator last)

例: // 元となるコンテナを作成

std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

basic_atom_set<std::u32string> as1(v1.begin(), v1.end());

//直列化データを作成

auto v2 = std::vector<std::uint32_t>(as1.ibegin(), as1.iend());

// 直列化データから構築

auto as2 = basic_atom_set<std::u32string>(v2.begin(), v2.end());

// 検証

assert(as2.size() == 5);

◆ basic_atom_set() [4/5]

template<typename InputIterator , typename std::enable_if_t< std::negation_v< std::is_integral< typename std::iterator_traits< InputIterator >::value_type >>, std::nullptr_t > = nullptr>

wordring::basic_atom_set::basic_atom_set	(	InputIterator	first,
		InputIterator	last,
		allocator_type const &	alloc = `allocator_type()`
	)

inline

文字列リストからの構築

引数

[in]	first	文字列リストの先頭を指すイテレータ
[in]	last	文字列リストの終端を指すイテレータ
[in]	alloc	アロケータ

例: // 文字列リスト

std::vector<std::u32string> v{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

// 文字列リストから構築

auto as = basic_atom_set<std::u32string>(v.begin(), v.end());

// 検証

assert(as.size() == 5);

◆ basic_atom_set() [5/5]

wordring::basic_atom_set::basic_atom_set	(	std::initializer_list< detail::trie_node >	il,
		allocator_type const &	alloc = `allocator_type()`
	)

inline

初期化子リストから構築する

引数

[in]	il	ノード・データの初期化子リスト
[in]	alloc	アロケータ

参照: detail::trie_heap::trie_heap(std::initializer_list<trie_node>, allocator_type const&)

関数詳解

◆ assign() [1/2]

template<typename InputIterator , typename std::enable_if_t< std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>

void wordring::basic_atom_set::assign	(	InputIterator	first,
		InputIterator	last
	)

inline

直列化データからの割り当て

引数

[in]	first	直列化データの先頭を指すイテレータ
[in]	last	直列化データの終端を指すイテレータ

例: // 元となるコンテナを作成

std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

basic_atom_set<std::u32string> as1(v1.begin(), v1.end());

//直列化データを作成

auto v2 = std::vector<std::uint32_t>(as1.ibegin(), as1.iend());

// 直列化データから割り当て

auto as2 = basic_atom_set<std::u32string>(v2.begin(), v2.end());

// 検証

assert(as2.size() == 5);

◆ assign() [2/2]

template<typename InputIterator , typename std::enable_if_t< std::negation_v< std::is_integral< typename std::iterator_traits< InputIterator >::value_type >>, std::nullptr_t > = nullptr>

void wordring::basic_atom_set::assign	(	InputIterator	first,
		InputIterator	last
	)

inline

文字列リストからの割り当て

引数

[in]	first	文字列リストの先頭を指すイテレータ
[in]	last	文字列リストの終端を指すイテレータ

例: // 文字列リスト

std::vector<std::u32string> v{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

basic_atom_set<std::u32string> as;

// 文字列リストから割り当て

as.assign(v.begin(), v.end());

// 検証

assert(as.size() == 5);

◆ at() [1/3]

value_type wordring::basic_atom_set::at ( std::uint32_t id ) const

inline

IDからアトムを返す

引数

[in] id アトムID

戻り値: 文字列アトム

id と対応するアトムが格納されていない場合、空のアトムを返す

例: // コンテナを作成

std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

// アトムIDを取得

std::uint32_t id = as.at(std::u32string(U"あう"));

// IDからアトムを取得する

auto a = as.at(id);

// 検証

assert(static_cast<std::u32string>(a) == U"あう");

◆ at() [2/3]

template<typename InputIterator >

value_type wordring::basic_atom_set::at	(	InputIterator	first,
		InputIterator	last
	)		const

inline

文字列からアトムを返す

引数

[in]	first	文字列の先頭を指すイテレータ
[in]	last	文字列の終端を指すイテレータ

戻り値: 文字列アトム

文字列と対応するアトムが格納されていない場合、空のアトムを返す

例: // コンテナを作成

std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

auto s = std::u32string(U"あう");

// 文字列からアトムを取得する

auto a = as.at(s.begin(), s.end());

// 検証

assert(static_cast<std::u32string>(a) == U"あう");

◆ at() [3/3]

value_type wordring::basic_atom_set::at ( std::basic_string_view< label_type > sv ) const

inline

文字列からアトムを返す

引数

[in] sv 文字列

戻り値: 文字列アトム

文字列と対応するアトムが格納されていない場合、空のアトムを返す

例: // コンテナを作成

std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

// 文字列からアトムを取得する

auto a = as.at(U"あう");

// 検証

assert(static_cast<std::u32string>(a) == U"あう");

◆ operator[]()

value_type wordring::basic_atom_set::operator[] ( std::basic_string_view< label_type > sv )

inline

文字列からアトムを返す

引数

[in] sv 文字列

戻り値: 文字列アトム

例: // コンテナを作成

std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

// 文字列からアトムを取得する

auto a = as[U"え"];

// 検証

assert(static_cast<std::u32string>(a) == U"え");

◆ insert() [1/2]

template<typename InputIterator >

value_type wordring::basic_atom_set::insert	(	InputIterator	first,
		InputIterator	last
	)

inline

文字列を挿入する

引数

[in]	first	文字列の先頭を指すイテレータ
[in]	last	文字列の終端を指すイテレータ

戻り値: 文字列アトム

例: // 空のコンテナを作成

basic_atom_set<std::u32string> as;

std::u32string s(U"あ");

// 文字列を挿入する

auto a = as.insert(s.begin(), s.end());

// 検証

assert(static_cast<std::u32string>(a) == U"あ");

assert(as.size() == 1);

◆ insert() [2/2]

value_type wordring::basic_atom_set::insert ( std::basic_string_view< label_type > sv )

inline

文字列を挿入する

引数

[in] sv 文字列

戻り値: 文字列アトム

例: // 空のコンテナを作成

basic_atom_set<std::u32string> as;

// 文字列を挿入する

auto a = as.insert(U"あ");

// 検証

assert(static_cast<std::u32string>(a) == U"あ");

assert(as.size() == 1);

◆ erase() [1/3]

void wordring::basic_atom_set::erase ( std::uint32_t id )

inline

アトムを削除する

引数

[in] id 削除するアトムID

例: std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

// コンテナを構築する

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

// IDを取得する

std::uint32_t id = as.at(U"い");

// アトムを削除する

as.erase(id);

// 検証

assert(as.contains(U"い") == false);

assert(as.size() == 4);

◆ erase() [2/3]

template<typename InputIterator >

void wordring::basic_atom_set::erase	(	InputIterator	first,
		InputIterator	last
	)

inline

アトムを削除する

引数

[in]	first	文字列の先頭を指すイテレータ
[in]	last	文字列の終端を指すイテレータ

例: std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

// コンテナを構築する

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

auto s = std::u32string(U"うあい");

// アトムを削除する

as.erase(s.begin(), s.end());

// 検証

assert(as.contains(U"うあい") == false);

assert(as.size() == 4);

◆ erase() [3/3]

void wordring::basic_atom_set::erase ( std::basic_string_view< label_type > sv )

inline

アトムを削除する

引数

[in] sv 文字列

例: std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

// コンテナを構築する

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

// アトムを削除する

as.erase(U"うあい");

// 検証

assert(as.contains(U"うあい") == false);

assert(as.size() == 4);

◆ contains() [1/2]

template<typename InputIterator >

bool wordring::basic_atom_set::contains	(	InputIterator	first,
		InputIterator	last
	)		const

inline

文字列が格納されているか調べる

引数

[in]	first	文字列の先頭を指すイテレータ
[in]	last	文字列の終端を指すイテレータ

戻り値: 格納されている場合 true 、それ以外の場合 false

◆ contains() [2/2]

bool wordring::basic_atom_set::contains ( std::basic_string_view< label_type > sv ) const

inline

文字列が格納されているか調べる

引数

[in] sv 文字列

戻り値: 格納されている場合 true 、それ以外の場合 false

例: std::vector<std::u32string> v1{ U"あ", U"あう", U"い", U"うあい", U"うえ" };

// コンテナを構築する

auto as = basic_atom_set<std::u32string>(v1.begin(), v1.end());

// 文字列が格納されているか調べる

bool b = as.contains(U"あ");

// 検証

assert(b == true);

◆ size()

size_type wordring::basic_trie< Label, Base >::size

inlinenoexcept

格納しているキー文字列数を調べる

戻り値: コンテナに格納されているキー文字列の数

このクラス詳解は次のファイルから抽出されました:

atom.hpp

公開型

公開メンバ関数

限定公開型

詳解

構築子と解体子

◆ basic_atom_set() [1/5]

◆ basic_atom_set() [2/5]

◆ basic_atom_set() [3/5]

◆ basic_atom_set() [4/5]

◆ basic_atom_set() [5/5]

関数詳解

◆ assign() [1/2]

◆ assign() [2/2]

◆ at() [1/3]

◆ at() [2/3]

◆ at() [3/3]

◆ operator[]()

◆ insert() [1/2]

◆ insert() [2/2]

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ contains() [1/2]

◆ contains() [2/2]

◆ size()