Femboy_GP/include/lilfbtf/tree.h

169 lines
5.3 KiB
C
Raw Normal View History

2024-03-11 17:59:08 -04:00
#pragma once
/*
* Copyright (C) 2024 Brett Terpstra
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef LILFBTF5_TREE_H
#define LILFBTF5_TREE_H
2024-03-11 19:21:38 -04:00
#include <blt/std/any.h>
#include <functional>
#include "blt/std/ranges.h"
#include "blt/std/allocator.h"
2024-03-14 08:36:06 -04:00
#include "type.h"
2024-03-11 19:21:38 -04:00
#include <lilfbtf/fwddecl.h>
2024-03-14 15:13:30 -04:00
#include <lilfbtf/random.h>
2024-03-11 19:21:38 -04:00
2024-03-11 17:59:08 -04:00
namespace fb
{
2024-03-11 19:21:38 -04:00
class func_t
{
private:
2024-03-13 12:16:25 -04:00
arg_c_t argc_ = 0;
2024-03-12 16:53:27 -04:00
type_id type;
2024-03-13 12:16:25 -04:00
function_id function;
2024-03-11 19:21:38 -04:00
const func_t_call_t& func;
protected:
blt::unsafe::any_t value;
public:
2024-03-13 12:16:25 -04:00
explicit func_t(arg_c_t argc, const func_t_call_t& func, type_id output_type, function_id function_type);
2024-03-11 19:21:38 -04:00
2024-03-13 12:16:25 -04:00
[[nodiscard]] inline arg_c_t argc() const
2024-03-11 19:21:38 -04:00
{ return argc_; }
[[nodiscard]] inline blt::unsafe::any_t getValue() const
2024-03-13 12:16:25 -04:00
{ return value; }
2024-03-11 19:21:38 -04:00
inline func_t& setValue(blt::unsafe::any_t val)
{
this->value = val;
return *this;
}
2024-03-13 12:16:25 -04:00
/**
* @return the type_id that this function container will output
*/
2024-03-12 16:53:27 -04:00
[[nodiscard]] inline type_id getType() const
2024-03-13 12:16:25 -04:00
{ return type; }
/**
* @return the function id of this function container
*/
2024-03-14 15:13:30 -04:00
[[nodiscard]] inline function_id getFunction() const
2024-03-13 12:16:25 -04:00
{ return function; }
2024-03-11 19:21:38 -04:00
inline void call(blt::span<detail::node_t*> args)
2024-03-13 12:16:25 -04:00
{ func(*this, args); };
2024-03-11 19:21:38 -04:00
~func_t() = default;
};
enum class tree_init_t
{
// standard grow method
GROW,
// standard full method
FULL,
// standard ramped half-and-half method
RAMPED_HALF_HALF,
// variant of grow/full method where at each level a choice is made between using only non-terminals or terminals
BRETT_HALF_HALF
};
2024-03-11 19:21:38 -04:00
namespace detail
{
class node_t
{
friend tree_t;
private:
blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc;
func_t type;
node_t** children = nullptr;
public:
explicit node_t(const func_t& type, blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc): alloc(alloc), type(type)
{
children = alloc.emplace_many<node_t*>(this->type.argc());
for (blt::size_t i = 0; i < this->type.argc(); i++)
children[i] = nullptr;
}
inline void evaluate()
{
type.call(blt::span<node_t*>{children, type.argc()});
}
2024-03-14 08:47:14 -04:00
inline blt::unsafe::any_t value()
{
return type.getValue();
}
2024-03-11 19:21:38 -04:00
~node_t()
{
for (blt::size_t i = 0; i < type.argc(); i++)
{
alloc.destroy(children[i]);
alloc.deallocate(children[i]);
}
alloc.deallocate(children, type.argc());
}
};
2024-03-15 12:06:47 -04:00
struct node_construction_info_t
2024-03-15 12:06:47 -04:00
{
blt::bump_allocator<blt::BLT_2MB_SIZE, false>& alloc;
random& engine;
type_engine_t& types;
};
struct tree_construction_info_t
{
tree_init_t tree_type;
random& engine;
type_engine_t& types;
};
2024-03-11 19:21:38 -04:00
}
class tree_t
{
private:
2024-03-14 15:13:30 -04:00
blt::bump_allocator<blt::BLT_2MB_SIZE, false> alloc;
2024-03-14 08:36:06 -04:00
type_engine_t& types;
2024-03-14 15:13:30 -04:00
detail::node_t* root = nullptr;
inline blt::bump_allocator<blt::BLT_2MB_SIZE, false>& get_allocator()
{ return alloc; }
2024-03-15 12:06:47 -04:00
static detail::node_t* allocate_non_terminal(detail::node_construction_info_t info, type_id type);
static detail::node_t* allocate_non_terminal_restricted(detail::node_construction_info_t info, type_id type);
static detail::node_t* allocate_terminal(detail::node_construction_info_t info, type_id type);
2024-03-15 12:06:47 -04:00
2024-03-11 19:21:38 -04:00
public:
2024-03-14 15:13:30 -04:00
explicit tree_t(type_engine_t& types);
2024-03-14 08:36:06 -04:00
static tree_t make_tree(detail::tree_construction_info_t tree_info, blt::size_t min_depth, blt::size_t max_depth,
2024-03-15 12:06:47 -04:00
std::optional<type_id> starting_type = {});
2024-03-14 15:39:14 -04:00
std::pair<blt::unsafe::any_t, type_id> evaluate();
2024-03-11 19:21:38 -04:00
};
2024-03-11 17:59:08 -04:00
}
#endif //LILFBTF5_TREE_H