blob: 88a08da80571d24e6741d6f44d75dae7f8f7de68 [file] [log] [blame]
// Copyright 2020 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef SRC_TINT_UTILS_SYMBOL_SYMBOL_TABLE_H_
#define SRC_TINT_UTILS_SYMBOL_SYMBOL_TABLE_H_
#include <string>
#include "src/tint/utils/containers/hashmap.h"
#include "src/tint/utils/memory/bump_allocator.h"
#include "src/tint/utils/symbol/symbol.h"
namespace tint {
/// Holds mappings from symbols to their associated string names
class SymbolTable {
public:
/// Constructor
/// @param generation_id the identifier of the program that owns this symbol
/// table
explicit SymbolTable(tint::GenerationID generation_id);
/// Move Constructor
SymbolTable(SymbolTable&&);
/// Destructor
~SymbolTable();
/// Move assignment
/// @param other the symbol table to move
/// @returns the symbol table
SymbolTable& operator=(SymbolTable&& other);
/// Wrap sets this symbol table to hold symbols which point to the allocated names in @p o.
/// The symbol table after Wrap is intended to temporarily extend the objects
/// of an existing immutable SymbolTable
/// As the copied objects are owned by @p o, @p o must not be destructed
/// or assigned while using this symbol table.
/// @param o the immutable SymbolTable to extend
void Wrap(const SymbolTable& o) {
next_symbol_ = o.next_symbol_;
name_to_symbol_ = o.name_to_symbol_;
last_prefix_to_index_ = o.last_prefix_to_index_;
generation_id_ = o.generation_id_;
}
/// Registers a name into the symbol table, returning the Symbol.
/// @param name the name to register
/// @returns the symbol representing the given name
Symbol Register(std::string_view name);
/// Returns the symbol for the given `name`
/// @param name the name to lookup
/// @returns the symbol for the name or Symbol() if not found.
Symbol Get(std::string_view name) const;
/// Returns a new unique symbol with the given name, possibly suffixed with a
/// unique number.
/// @param name the symbol name
/// @returns a new, unnamed symbol with the given name. If the name is already
/// taken then this will be suffixed with an underscore and a unique numerical
/// value
Symbol New(std::string_view name = "");
/// Foreach calls the callback function `F` for each symbol in the table.
/// @param callback must be a function or function-like object with the
/// signature: `void(Symbol)`
template <typename F>
void Foreach(F&& callback) const {
for (auto it : name_to_symbol_) {
callback(it.value);
}
}
/// @returns the identifier of the Program that owns this symbol table.
tint::GenerationID GenerationID() const { return generation_id_; }
private:
SymbolTable(const SymbolTable&) = delete;
SymbolTable& operator=(const SymbolTable& other) = delete;
Symbol RegisterInternal(std::string_view name);
// The value to be associated to the next registered symbol table entry.
uint32_t next_symbol_ = 1;
Hashmap<std::string_view, Symbol, 0> name_to_symbol_;
Hashmap<std::string, size_t, 0> last_prefix_to_index_;
tint::GenerationID generation_id_;
tint::BumpAllocator name_allocator_;
};
/// @param symbol_table the SymbolTable
/// @returns the GenerationID that owns the given SymbolTable
inline GenerationID GenerationIDOf(const SymbolTable& symbol_table) {
return symbol_table.GenerationID();
}
} // namespace tint
#endif // SRC_TINT_UTILS_SYMBOL_SYMBOL_TABLE_H_