217 lines
6.9 KiB
C++
217 lines
6.9 KiB
C++
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* 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 FORMATTER_H_
|
|
|
|
#define FORMATTER_H_
|
|
|
|
#include <functional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace android {
|
|
|
|
struct Formatter;
|
|
|
|
struct WrappedOutput {
|
|
WrappedOutput(size_t lineLength);
|
|
|
|
void group(const std::function<void(void)>& block);
|
|
WrappedOutput& operator<<(const std::string& str);
|
|
WrappedOutput& printUnlessWrapped(const std::string& str);
|
|
|
|
private:
|
|
struct Block {
|
|
Block(const std::string& content, Block* const parent);
|
|
|
|
// populated helps indicate if we are done filling up the Block.
|
|
// this allows WrappedOutput to keep adding content to this block
|
|
// till it is determined that it is full.
|
|
bool populated = false;
|
|
bool printUnlessWrapped = false;
|
|
|
|
// Only one of content or blocks can have content.
|
|
std::string content;
|
|
std::vector<Block> blocks;
|
|
|
|
Block* const parent;
|
|
|
|
size_t computeSize(bool wrapped) const;
|
|
void print(Formatter& out, bool wrapped) const;
|
|
};
|
|
|
|
size_t mLineLength;
|
|
|
|
Block mRootBlock;
|
|
Block* mCurrentBlock;
|
|
|
|
friend struct Formatter;
|
|
};
|
|
|
|
// Two styles to use a Formatter.
|
|
// One is with .indent() calls and operator<<.
|
|
// out << "if (good) {\n"; out.indent(); out << "blah\nblah\n"; out.unindent(); out << "}\n";
|
|
// The other is with chain calls and lambda functions
|
|
// out.sIf("good", [&] { out("blah").endl()("blah").endl(); }).endl();
|
|
struct Formatter {
|
|
static Formatter invalid() { return Formatter(); }
|
|
|
|
// Assumes ownership of file. Directed to stdout if file == NULL.
|
|
Formatter(FILE* file, size_t spacesPerIndent = 4);
|
|
Formatter(Formatter&&) = default;
|
|
~Formatter();
|
|
|
|
void indent(size_t level = 1);
|
|
void unindent(size_t level = 1);
|
|
|
|
// Note that The last \n after the last line is NOT added automatically.
|
|
// out.indent(2, [&] {
|
|
// out << "Meow\n";
|
|
// });
|
|
Formatter& indent(size_t level, const std::function<void(void)>& func);
|
|
|
|
// Note that The last \n after the last line is NOT added automatically.
|
|
// out.indent([&] {
|
|
// out << "Meow\n";
|
|
// });
|
|
Formatter& indent(const std::function<void(void)>& func);
|
|
|
|
// A block inside braces.
|
|
// * No space will be added before the opening brace.
|
|
// * The last \n before the closing brace is added automatically.
|
|
// * There will NOT be a \n after the closing brace.
|
|
// out.block([&] {
|
|
// out << "one();\n"
|
|
// << "two();\n";
|
|
// });
|
|
// is equivalent to
|
|
// out << "{\n"
|
|
// << "one();\ntwo();\n" // func()
|
|
// << "}";
|
|
Formatter& block(const std::function<void(void)>& func);
|
|
|
|
// A synonym to (*this) << "\n";
|
|
Formatter &endl();
|
|
|
|
// out.sIf("z == 1", [&] {
|
|
// out << "doGoodStuff();\n";
|
|
// }).sElseIf("z == 2", [&] {
|
|
// out << "doBadStuff();\n";
|
|
// }).sElse([&] {
|
|
// out << "logFatal();\n";
|
|
// }).endl();
|
|
// note that there will be a space before the "else"-s.
|
|
Formatter& sIf(const std::string& cond, const std::function<void(void)>& block);
|
|
Formatter& sElseIf(const std::string& cond, const std::function<void(void)>& block);
|
|
Formatter& sElse(const std::function<void(void)>& block);
|
|
|
|
// out.sFor("int i = 0; i < 10; i++", [&] {
|
|
// out << "printf(\"%d\", i);\n";
|
|
// }).endl();
|
|
Formatter& sFor(const std::string& stmts, const std::function<void(void)>& block);
|
|
|
|
// out.sTry([&] {
|
|
// out << "throw RemoteException();\n"
|
|
// }).sCatch("RemoteException ex", [&] {
|
|
// out << "ex.printStackTrace();\n"
|
|
// }).sFinally([&] {
|
|
// // cleanup
|
|
// }).endl();
|
|
// note that there will be a space before the "catch"-s.
|
|
Formatter& sTry(const std::function<void(void)>& block);
|
|
Formatter& sCatch(const std::string& exception, const std::function<void(void)>& block);
|
|
Formatter& sFinally(const std::function<void(void)>& block);
|
|
|
|
// out.sWhile("z < 10", [&] {
|
|
// out << "z++;\n";
|
|
// }).endl();
|
|
Formatter& sWhile(const std::string& cond, const std::function<void(void)>& block);
|
|
|
|
// out.join(v.begin(), v.end(), ",", [&](const auto &e) {
|
|
// out << toString(e);
|
|
// });
|
|
template <typename I>
|
|
Formatter& join(
|
|
const I begin, const I end, const std::string& separator,
|
|
const std::function<void(const typename std::iterator_traits<I>::value_type&)>& func);
|
|
|
|
Formatter &operator<<(const std::string &out);
|
|
|
|
Formatter &operator<<(char c);
|
|
Formatter &operator<<(signed char c);
|
|
Formatter &operator<<(unsigned char c);
|
|
|
|
Formatter &operator<<(short c);
|
|
Formatter &operator<<(unsigned short c);
|
|
Formatter &operator<<(int c);
|
|
Formatter &operator<<(unsigned int c);
|
|
Formatter &operator<<(long c);
|
|
Formatter &operator<<(unsigned long c);
|
|
Formatter &operator<<(long long c);
|
|
Formatter &operator<<(unsigned long long c);
|
|
Formatter &operator<<(float c);
|
|
Formatter &operator<<(double c);
|
|
Formatter &operator<<(long double c);
|
|
Formatter& operator<<(const WrappedOutput& wrappedOutput);
|
|
|
|
// Puts a prefix before each line. This is useful if
|
|
// you want to start a // comment block, for example.
|
|
// The prefix will be put before the indentation.
|
|
// Will be effective the next time cursor is at the start of line.
|
|
// Adding two prefixes will output them in the order they were added
|
|
void pushLinePrefix(const std::string& prefix);
|
|
// Remove the last line prefix.
|
|
void popLinePrefix();
|
|
|
|
bool isValid() const;
|
|
size_t getIndentation() const;
|
|
|
|
private:
|
|
// Creates an invalid formatter object.
|
|
Formatter();
|
|
|
|
FILE* mFile; // invalid if nullptr
|
|
size_t mIndentDepth;
|
|
size_t mSpacesPerIndent;
|
|
size_t mCurrentPosition;
|
|
|
|
std::vector<std::string> mLinePrefix;
|
|
|
|
void printBlock(const WrappedOutput::Block& block, size_t lineLength);
|
|
void output(const std::string &text) const;
|
|
|
|
Formatter(const Formatter&) = delete;
|
|
void operator=(const Formatter&) = delete;
|
|
};
|
|
|
|
template <typename I>
|
|
Formatter& Formatter::join(
|
|
const I begin, const I end, const std::string& separator,
|
|
const std::function<void(const typename std::iterator_traits<I>::value_type&)>& func) {
|
|
for (I iter = begin; iter != end; ++iter) {
|
|
if (iter != begin) {
|
|
(*this) << separator;
|
|
}
|
|
func(*iter);
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
} // namespace android
|
|
|
|
#endif // FORMATTER_H_
|
|
|