void printReversed(const string &line) {
size_t position = 0;
Printer p;
unsigned int number;
static vector<int> values;
values.clear();
while (line[position] != ';') {
getUnsignedInteger(line, position, number);
values.push_back(number);
}
getUnsignedInteger(line, position, number);
if (number > values.size() ) {
number = values.size();
}
int start = number - 1;
while (start < values.size() ) {
for (int i = start; i > start - (int)number; --i) {
p.print(values[i]);
}
start += number;
}
for (int i = start - number + 1; i < values.size(); i++) {
p.print(values[i]);
}
cout << endl;
}
void stackPrintAlternate(const string &line) {
int end;
int start;
char *data = const_cast<char*>(line.c_str());
Printer p;
end = line.length() - 1;
back(data, start, end);
p.print(&( data[start] ));
while (true) {
end = start - 1;
back(data, start, end);
if (start <= 0) {
break;
}
end = start - 1;
back(data, start, end);
data[end + 1] = 0;
if (end < 0) {
break;
}
p.print(&( data[start] ));
}
cout << endl;
}
void separateContent(const string &line) {
size_t start = 0;
size_t length = 0;
size_t end;
list<string> words;
list<string> numbers;
Printer linePrinter;
while (start < line.length()) {
end = start + 1;
while (end < line.length()) {
if (line[end] == ',') {
break;
}
end++;
}
length = end - start;
if (line[start] >= '0' && line[start] <= '9') {
numbers.emplace_back(line, start, length);
} else {
words.emplace_back(line, start, length);
}
start = end + 1;
}
if (!words.empty()) {
for(auto&& word : words) {
linePrinter.print(word);
}
if (!numbers.empty()) {
cout << '|';
linePrinter.reset();
}
}
if (!numbers.empty()) {
for(auto&& number : numbers) {
linePrinter.print(number);
}
}
cout << endl;
}
void printCash(const string &line) {
size_t position = 0;
unsigned int price;
unsigned int amount;
Printer cashier;
price = getPrice(line, position);
amount = getPrice(line, position);
if (price == amount) {
cout << "ZERO" << endl;
return;
}
if (price > amount) {
cout << "ERROR" << endl;
return;
}
amount -= price;
for (auto i = cash.rbegin(); i != cash.rend() && amount != 0; ++i) {
while (amount >= i->second) {
cashier.print(i->first);
amount -= i->second;
}
}
cout << endl;
}
int main(int argc, char* argv[])
{
Printer* printer = NULL;
Printer* console_printer = console_printer_create();
Printer* file_printer = file_printer_create("./log.txt");
printer = console_printer;
printer->print(printer, "hello world!\n");
printer->destroy(printer);
printer = file_printer;
printer->print(printer, "hello world!\n");
printer->destroy(printer);
return 0;
}
int main(int argc, char* argv[]){
// c++11 initializer_list constructor
Printer obj = {10};
std::cout << obj() << std::endl;
obj.print("obj.print");
// mem_fn 转换
auto func = std::mem_fn(&Printer::print);
obj.data = 100;
func(obj, "mem_fun");
// bind 绑定
auto func2 = std::bind(&Printer::print, &obj, _1);
func2("bind");
// bind操作符函数绑定
auto func3 = std::bind(&Printer::operator(), &obj);
std::cout << "bind operator() " << func3() << std::endl;
// mem_fn 操作符转换为普通函数
auto func4 = std::mem_fn(&Printer::operator());
std::cout << "mem_fun operator() " << func4(obj) << std::endl;
return 0;
}
void IncLit::accept(::Printer *v)
{
if(type_ == VOLATILE)
{
Printer *printer = v->output()->printer<Printer>();
printer->print(vol_window_);
}
}
void print() const {
Printer p;
for (auto it = m_data.rbegin(); it != m_data.rend(); ++it) {
p.print(*it);
}
cout << endl;
}
bool Display::grounded(Grounder *g)
{
head_->grounded(g);
Printer *printer = g->output()->printer<Printer>();
printer->show(show_);
printer->print(head_.get());
return true;
}
void print_backtrace(std::size_t frames = 32)
{
using namespace backward;
StackTrace stackTrace;
Printer printer;
stackTrace.load_here(frames);
printer.object = true;
printer.color = true;
printer.print(stackTrace, stdout);
}
int main() {
std::vector<int> container;
for (int i = 0; i < 5; ++i) {
container.push_back(i);
}
Printer<Out, Out, Out> printer;
printer.print(container);
return 0;
}
void Ram::set(vector<bool> adr, vector<bool> wordIn) {
int address = Util::getInt(adr);
// Save word
if (address < RAM_SIZE) {
for (int i = 0; i < WORD_SIZE; i++) {
state[address][i] = wordIn[i];
}
// Send word to printer
} else {
char formatedInt [4];
sprintf(formatedInt, "%3d", Util::getInt(wordIn));
string outputLine = Util::getString(wordIn) + " " + formatedInt + "\n";
printer.print(outputLine);
}
}
void printIntersection(const string &line) {
size_t first_position;
size_t second_position;
size_t delimiter_position;
Printer printer;
for (delimiter_position=0; delimiter_position < line.length(); delimiter_position++) {
if (line[delimiter_position] == ';' ) {
break;
}
}
first_position = 0;
second_position = delimiter_position + 1;
unsigned int first = getUnsignedInteger(line, first_position);
unsigned int second = getUnsignedInteger(line, second_position);
while (true) {
if (first == second) {
printer.print(first);
if (first_position >= delimiter_position) {
break;
}
first = getUnsignedInteger(line, first_position);
if (second_position >= line.length()) {
break;
}
second = getUnsignedInteger(line, second_position);
} else if ( first < second) {
if (first_position >= delimiter_position) {
break;
}
first = getUnsignedInteger(line, first_position);
} else {
if (second_position >= line.length()) {
break;
}
second = getUnsignedInteger(line, second_position);
}
}
cout << endl;
}
void run() {
if (executionCounter > 0) {
printer.print(" \n");
}
savedRam = ram.state;
cpu.exec();
// if 'esc' was pressed then it doesn't wait for keypress at the end
if (executionCanceled) {
executionCanceled = false;
} else {
getc(stdin);
}
ram = Ram();
ram.state = savedRam;
cpu = Cpu();
redrawScreen();
executionCounter++;
}
int main(int argc, char * argv[])
{
int c;
int option_index = 0;
string truth_file="";
string result_file="";
string gene_file="";
string output_file="";
string rule_file="";
int base_resolution=1;
int max_diff=20;
string pseudo_counts="0,0,0,0,0,0";
int print_num=0;
static struct option long_options[] = {
{"truth-file", required_argument, 0, 't' },
{"result-file", required_argument, 0, 'r' },
{"gene-annotation-file", required_argument, 0, 'g' },
{"output-file", required_argument, 0, 'o' },
{"subsetting-rule-file", required_argument, 0, 's' },
{"base-resolution", required_argument, 0, 'b' },
{"max-diff", required_argument, 0, 'm' },
{"pseudo-counts", required_argument, 0, 'p' },
{"use-number", no_argument, 0, 'u' },
{"help", no_argument, 0, 'h' },
{0, 0, 0, 0}
};
while(1)
{
c = getopt_long(argc, argv, "t:r:g:o:s:b:m:p:uh",
long_options, &option_index);
if (c==-1)
{
break;
}
switch(c)
{
case 'h':
usage();
exit(0);
case 't':
truth_file=optarg;
break;
case 'r':
result_file=optarg;
break;
case 'g':
gene_file=optarg;
break;
case 'o':
output_file=optarg;
break;
case 's':
rule_file=optarg;
break;
case 'b':
base_resolution=atoi(optarg);
break;
case 'm':
max_diff=atoi(optarg);
break;
case 'p':
pseudo_counts=optarg;
break;
case 'u':
print_num=1;
break;
default:
break;
}
}
if(truth_file.compare("")==0 || result_file.compare("")==0 || gene_file.compare("")==0 || output_file.compare("")==0|| rule_file.compare("")==0)
{
usage();
exit(0);
}
pseudo_counts_t pct;
get_pseudo_counts(pseudo_counts, pct);
cerr<<"loading gene annotation file..."<<endl;
Gene g;
g.loadGenesFromFile((char*)gene_file.c_str());
g.setGene();
cerr<<"loading result file..."<<endl;
Bedpe res;
res.loadFromFile((char *)result_file.c_str());
cerr<<"removing duplicate results..."<<endl;
res.uniq();
cerr<<"loading truth file..."<<endl;
Bedpe truth;
truth.loadFromFile((char*)truth_file.c_str());
vector<evaluate_t> evaluates;
cerr<<"comparing by subsetting rules..."<<endl;
ExecuteByRule exe;
exe.execute(res, truth, (char*)output_file.c_str(), (char*)rule_file.c_str(), evaluates, g, base_resolution, max_diff, pct, print_num);
cerr<<"printing evaluation results..."<<endl;
Printer per;
per.print(evaluates, (char*)output_file.c_str(), gene_file, base_resolution, max_diff, pseudo_counts, version);
return 0;
}
void print_dot(hls::Program *program)
{
static Printer printer;
printer.print(program);
}