Trie

//.h

#pragma once
#include <iostream>
#include <map>

//template <typename T>
class Trie
{

protected:

    struct Node{

        //T * value;
        std::map<char, Node*> next;
        bool isEnd;

        Node() : /*value(nullptr),*/ isEnd(false) {};

    };

    Node* root;


public:

    Trie() { root = new Node(); };
    //~Trie();

    void add(std::string str, int value);
    /*void deleteWord(std::string word);
    void clear();*/
    void print();
    bool count(std::string str);
    void deleteWord(std::string);

private:

    void _add(Node* ptr, std::string str, int value);
    /*void _deleteWord(std::string word);
    void _clear();*/
    void _print(Node* ptr, std::string str);
    bool _count(Node* ptr, std::string str);
    void _deleteWord(Node* ptr, std::string str, int level);

    //additional funcs
    bool hasChild(Node*);

    /*void callback(int e);
    void callback(std::string str);*/

};

//.cpp

#include "Trie.h"

void Trie::add(std::string str, int value)
{

    _add(root, str, value);

}

void Trie::_add(Node* ptr, std::string str, int value)
{

    for (int i = 0; i < str.length(); i++) {

        if (ptr->next.count(str[i]) == 0) {

            ptr->next[str[i]] = new Node();

        }

        ptr = ptr->next[str[i]];

    }

    ptr->isEnd = true;

}

//function to check if there a child of ptr pointer
bool Trie::hasChild(Node* ptr)
{

    bool result = false;

    for (std::map<char, Node*>::iterator it = ptr->next.begin(); it != ptr->next.end(); it++) {

        result = (it->second != nullptr);

    }

    return result;
}

//void Trie::callback(int e)
//{
//
//  switch (e) {
//
//  case 0:
//
//      std::cout << "Слово не было найдено" << std::endl;
//
//  break;
//
//  case 1:
//
//
//
//  break;
//
//  }
//
//}
//
//void Trie::callback(std::string str)
//{
//
//  std::cout << str << std::endl;
//
//}

void Trie::print()
{

    _print(root, "");

}

void Trie::_print(Node* ptr, std::string str)
{
    int i;

    if (ptr->isEnd) {

        str.push_back('\0');
        std::cout << str << std::endl;

    }

    if (hasChild(ptr)) {

        for (auto& it : ptr->next) {

            str.push_back(it.first);
            _print(it.second, str);

        }

    }

}

bool Trie::count(std::string str)
{

    return _count(root, str);

}

bool Trie::_count(Node* ptr, std::string str)
{

    for (int i = 0; i < str.length(); i++) {

        if (ptr->next.count(str[i]) != 0) {

            ptr = ptr->next[str[i]];

        }
        else
            return false;

    }

    return true;

}

void Trie::deleteWord(std::string str)
{

    _deleteWord(root, str, 0);

}


void Trie::_deleteWord(Node* ptr, std::string str, int level)
{

    if (level < str.length()) {

        if (!hasChild(ptr->next[str[level]]) && ptr->next.size() == 1){

            ptr->next.clear();
            delete ptr;

        }
        else {

            _deleteWord(ptr->next[str[level]], str, level + 1);

        }

    }

}