ud/Utility.h

#ifndef Rosebud_Utility_H
#define Rosebud_Utility_H
#include <Rosebud/Ast.h>

#include <Sawyer/Graph.h>
#include <Sawyer/Message.h>
#include <Sawyer/Optional.h>

#include <boost/filesystem.hpp>

#include <regex>
#include <string>
#include <vector>

#define THIS_LOCATION locationDirective(__LINE__, __FILE__)

namespace Rosebud {

enum class Access {
    PRIVATE,                                            
    PROTECTED,                                          
    PUBLIC                                              
};

struct Settings {
    std::string backend = "yaml";                       
    std::string serializer = "boost";                   
    bool showingWarnings = true;                        
    bool showingLocations = true;                       
    bool debugging = false;                             
    When usingColor = When::AUTO;                       
};

extern Settings settings;

// String utilities

std::string matching(const std::string&);
char matching(char);
std::vector<std::string> splitIntoLines(const std::string&);

void eraseBlankLines(std::vector<std::string>&);

void trimBlankLines(std::vector<std::string>&);

std::string prefixLines(const std::string &s, const std::string &prefix);
void prefixLines(std::vector<std::string> &lines, const std::string &prefix);
size_t editDistance(const std::string &src, const std::string &tgt);

double relativeDifference(const std::string &src, const std::string &tgt);

std::string bestMatch(const std::vector<std::string> &candidates, const std::string &sample);

std::string toString(Access);

// Filesystem utilities

boost::filesystem::path findRoseRootDir(const boost::filesystem::path&);

boost::filesystem::path relativeToRoseSource(const boost::filesystem::path&);

boost::filesystem::path toPath(const std::string &symbol, const std::string &extension);

// Comment utilities

std::string makeBlockComment(const std::string &text, const std::string &opening);
std::vector<std::string> makeBlockComment(const std::vector<std::string> &textLines, const std::string &opening);
std::string makeTitleComment(const std::string &multiLine, const std::string &prefix, char bar, size_t width);
std::vector<std::string> makeTitleComment(const std::vector<std::string> &lines, const std::string &prefix, char bar, size_t width);
std::string appendToDoxygen(const std::string &existingComment, const std::string &newText);

// Diagnostic messages

extern size_t nErrors;

bool usingColor();

std::string messageString(Sawyer::Message::Importance, const std::string &mesg);

void message(Sawyer::Message::Importance, const Ast::FilePtr&, const Token&, const std::string &mesg);
void message(Sawyer::Message::Importance, const Ast::FilePtr&, const Token &begin, const Token &focus,
             const Token &end, const std::string &mesg);
void message(Sawyer::Message::Importance, const Ast::FilePtr&, const std::vector<Token>&, const std::string &mesg);
void message(Sawyer::Message::Importance, const std::string &mesg);
void message(Sawyer::Message::Importance, const Ast::FilePtr&, const std::string &mesg);
// Class hierarchy utilities

struct HierarchyKey {
    std::string s;

    HierarchyKey(const Ast::ClassPtr &c) /*implicit*/
        : s(c->name) {}

    HierarchyKey(const std::string &s) /*implicit*/
        : s(s) {}

    bool operator<(const HierarchyKey &other) const {
        return s < other.s;
    }
};

using Hierarchy = Sawyer::Container::Graph<Ast::ClassPtr, Sawyer::Nothing, HierarchyKey>;

using Classes = std::vector<Ast::ClassPtr>;

Hierarchy classHierarchy(const Classes&);

void checkClassHierarchy(Hierarchy&);

Classes topDown(Hierarchy&);

Classes bottomUp(Hierarchy&);

Classes derivedClasses(const Ast::ClassPtr&, const Hierarchy&);

bool isBaseClass(const Ast::ClassPtr&, const Hierarchy&);

std::vector<Ast::PropertyPtr> allConstructorArguments(const Ast::ClassPtr&, const Hierarchy&);

std::string firstPublicBaseClass(const Ast::ClassPtr&);

// Type utilities

std::string constRef(const std::string &type);

std::string removeVolatileMutable(const std::string &type);

// C preprocessor utilities

std::string locationDirective(size_t line, const std::string &file);
std::string locationDirective(const Ast::NodePtr&, const Token&);
std::string toCppSymbol(const std::string&);

std::vector<std::string> extractCpp(std::string&, const std::regex&, size_t capture);

} // namespace
#endif