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,                                             
    DEFAULT                                             
};
 
struct Settings {
    std::string backend = "yaml";                       
    std::vector<std::string> serializers;               
    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);
 
enum class CamelCase {
    LOWER,                                              
    UPPER,                                              
    UNCHANGED                                           
};
 
std::string camelCase(const std::string&, CamelCase = CamelCase::LOWER);
 
std::string pascalCase(const std::string&);
 
std::string cEscape(char ch, char context = '\'');
std::string cEscape(const std::string&, char context = '"');
std::string bourneEscape(const std::string&);
 
std::string withLeadSpace(const std::string&);
 
// C++ code generation
 
std::string accessSpecifier(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