text
stringlengths 54
60.6k
|
|---|
<commit_before>/*
* yosys -- Yosys Open SYnthesis Suite
*
* Copyright (C) 2012 Clifford Wolf <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#include "kernel/register.h"
#include "kernel/rtlil.h"
#include "kernel/log.h"
USING_YOSYS_NAMESPACE
PRIVATE_NAMESPACE_BEGIN
struct setunset_t
{
RTLIL::IdString name;
RTLIL::Const value;
bool unset;
setunset_t(std::string unset_name) : name(RTLIL::escape_id(unset_name)), value(), unset(true) { }
setunset_t(std::string set_name, std::vector<std::string> args, size_t &argidx) : name(RTLIL::escape_id(set_name)), value(), unset(false)
{
if (!args[argidx].empty() && args[argidx][0] == '"') {
std::string str = args[argidx++].substr(1);
while (str.size() != 0 && str[str.size()-1] != '"' && argidx < args.size())
str += args[argidx++];
if (str.size() != 0 && str[str.size()-1] == '"')
str = str.substr(0, str.size()-1);
value = RTLIL::Const(str);
} else {
RTLIL::SigSpec sig_value;
if (!RTLIL::SigSpec::parse(sig_value, NULL, args[argidx++]))
log_cmd_error("Can't decode value '%s'!\n", args[argidx-1].c_str());
value = sig_value.as_const();
}
}
};
static void do_setunset(dict<RTLIL::IdString, RTLIL::Const> &attrs, std::vector<setunset_t> &list)
{
for (auto &item : list)
if (item.unset)
attrs.erase(item.name);
else
attrs[item.name] = item.value;
}
struct SetattrPass : public Pass {
SetattrPass() : Pass("setattr", "set/unset attributes on objects") { }
virtual void help()
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" setattr [ -mod ] [ -set name value | -unset name ]... [selection]\n");
log("\n");
log("Set/unset the given attributes on the selected objects. String values must be\n");
log("passed in double quotes (\").\n");
log("\n");
log("When called with -mod, this command will set and unset attributes on modules\n");
log("instead of objects within modules.\n");
log("\n");
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
std::vector<setunset_t> setunset_list;
bool flag_mod = false;
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
std::string arg = args[argidx];
if (arg == "-set" && argidx+2 < args.size()) {
argidx += 2;
setunset_list.push_back(setunset_t(args[argidx-1], args, argidx));
argidx--;
continue;
}
if (arg == "-unset" && argidx+1 < args.size()) {
setunset_list.push_back(setunset_t(args[++argidx]));
continue;
}
if (arg == "-mod") {
flag_mod = true;
continue;
}
break;
}
extra_args(args, argidx, design);
for (auto &mod : design->modules_)
{
RTLIL::Module *module = mod.second;
if (flag_mod) {
if (design->selected_whole_module(module->name))
do_setunset(module->attributes, setunset_list);
continue;
}
if (!design->selected(module))
continue;
for (auto &it : module->wires_)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
for (auto &it : module->memories)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
for (auto &it : module->cells_)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
for (auto &it : module->processes)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
}
}
} SetattrPass;
struct SetparamPass : public Pass {
SetparamPass() : Pass("setparam", "set/unset parameters on objects") { }
virtual void help()
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" setparam [ -set name value | -unset name ]... [selection]\n");
log("\n");
log("Set/unset the given parameters on the selected cells. String values must be\n");
log("passed in double quotes (\").\n");
log("\n");
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
std::vector<setunset_t> setunset_list;
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
std::string arg = args[argidx];
if (arg == "-set" && argidx+2 < args.size()) {
argidx += 2;
setunset_list.push_back(setunset_t(args[argidx-1], args, argidx));
argidx--;
continue;
}
if (arg == "-unset" && argidx+1 < args.size()) {
setunset_list.push_back(setunset_t(args[++argidx]));
continue;
}
break;
}
extra_args(args, argidx, design);
for (auto &mod : design->modules_)
{
RTLIL::Module *module = mod.second;
if (!design->selected(module))
continue;
for (auto &it : module->cells_)
if (design->selected(module, it.second))
do_setunset(it.second->parameters, setunset_list);
}
}
} SetparamPass;
struct ChparamPass : public Pass {
ChparamPass() : Pass("chparam", "re-evaluate modules with new parameters") { }
virtual void help()
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" chparam [ -set name value ]... [selection]\n");
log("\n");
log("Re-evaluate the selected modules with new parameters. String values must be\n");
log("passed in double quotes (\").\n");
log("\n");
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
std::vector<setunset_t> setunset_list;
dict<RTLIL::IdString, RTLIL::Const> new_parameters;
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
std::string arg = args[argidx];
if (arg == "-set" && argidx+2 < args.size()) {
argidx += 2;
setunset_t new_param(args[argidx-1], args, argidx);
new_parameters[new_param.name] = new_param.value;
argidx--;
continue;
}
break;
}
extra_args(args, argidx, design);
pool<IdString> modnames, old_modnames;
for (auto module : design->selected_modules()) {
if (design->selected_whole_module(module))
modnames.insert(module->name);
else
log_warning("Ignoring partially selecedted module %s.\n", log_id(module));
old_modnames.insert(module->name);
}
modnames.sort();
for (auto modname : modnames) {
Module *module = design->module(modname);
Module *new_module = design->module(module->derive(design, new_parameters));
if (module != new_module) {
Module *m = new_module->clone();
m->name = module->name;
design->remove(module);
design->add(m);
}
if (old_modnames.count(new_module->name) == 0)
design->remove(new_module);
}
}
} ChparamPass;
PRIVATE_NAMESPACE_END
<commit_msg>typo fix<commit_after>/*
* yosys -- Yosys Open SYnthesis Suite
*
* Copyright (C) 2012 Clifford Wolf <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#include "kernel/register.h"
#include "kernel/rtlil.h"
#include "kernel/log.h"
USING_YOSYS_NAMESPACE
PRIVATE_NAMESPACE_BEGIN
struct setunset_t
{
RTLIL::IdString name;
RTLIL::Const value;
bool unset;
setunset_t(std::string unset_name) : name(RTLIL::escape_id(unset_name)), value(), unset(true) { }
setunset_t(std::string set_name, std::vector<std::string> args, size_t &argidx) : name(RTLIL::escape_id(set_name)), value(), unset(false)
{
if (!args[argidx].empty() && args[argidx][0] == '"') {
std::string str = args[argidx++].substr(1);
while (str.size() != 0 && str[str.size()-1] != '"' && argidx < args.size())
str += args[argidx++];
if (str.size() != 0 && str[str.size()-1] == '"')
str = str.substr(0, str.size()-1);
value = RTLIL::Const(str);
} else {
RTLIL::SigSpec sig_value;
if (!RTLIL::SigSpec::parse(sig_value, NULL, args[argidx++]))
log_cmd_error("Can't decode value '%s'!\n", args[argidx-1].c_str());
value = sig_value.as_const();
}
}
};
static void do_setunset(dict<RTLIL::IdString, RTLIL::Const> &attrs, std::vector<setunset_t> &list)
{
for (auto &item : list)
if (item.unset)
attrs.erase(item.name);
else
attrs[item.name] = item.value;
}
struct SetattrPass : public Pass {
SetattrPass() : Pass("setattr", "set/unset attributes on objects") { }
virtual void help()
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" setattr [ -mod ] [ -set name value | -unset name ]... [selection]\n");
log("\n");
log("Set/unset the given attributes on the selected objects. String values must be\n");
log("passed in double quotes (\").\n");
log("\n");
log("When called with -mod, this command will set and unset attributes on modules\n");
log("instead of objects within modules.\n");
log("\n");
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
std::vector<setunset_t> setunset_list;
bool flag_mod = false;
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
std::string arg = args[argidx];
if (arg == "-set" && argidx+2 < args.size()) {
argidx += 2;
setunset_list.push_back(setunset_t(args[argidx-1], args, argidx));
argidx--;
continue;
}
if (arg == "-unset" && argidx+1 < args.size()) {
setunset_list.push_back(setunset_t(args[++argidx]));
continue;
}
if (arg == "-mod") {
flag_mod = true;
continue;
}
break;
}
extra_args(args, argidx, design);
for (auto &mod : design->modules_)
{
RTLIL::Module *module = mod.second;
if (flag_mod) {
if (design->selected_whole_module(module->name))
do_setunset(module->attributes, setunset_list);
continue;
}
if (!design->selected(module))
continue;
for (auto &it : module->wires_)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
for (auto &it : module->memories)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
for (auto &it : module->cells_)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
for (auto &it : module->processes)
if (design->selected(module, it.second))
do_setunset(it.second->attributes, setunset_list);
}
}
} SetattrPass;
struct SetparamPass : public Pass {
SetparamPass() : Pass("setparam", "set/unset parameters on objects") { }
virtual void help()
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" setparam [ -set name value | -unset name ]... [selection]\n");
log("\n");
log("Set/unset the given parameters on the selected cells. String values must be\n");
log("passed in double quotes (\").\n");
log("\n");
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
std::vector<setunset_t> setunset_list;
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
std::string arg = args[argidx];
if (arg == "-set" && argidx+2 < args.size()) {
argidx += 2;
setunset_list.push_back(setunset_t(args[argidx-1], args, argidx));
argidx--;
continue;
}
if (arg == "-unset" && argidx+1 < args.size()) {
setunset_list.push_back(setunset_t(args[++argidx]));
continue;
}
break;
}
extra_args(args, argidx, design);
for (auto &mod : design->modules_)
{
RTLIL::Module *module = mod.second;
if (!design->selected(module))
continue;
for (auto &it : module->cells_)
if (design->selected(module, it.second))
do_setunset(it.second->parameters, setunset_list);
}
}
} SetparamPass;
struct ChparamPass : public Pass {
ChparamPass() : Pass("chparam", "re-evaluate modules with new parameters") { }
virtual void help()
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" chparam [ -set name value ]... [selection]\n");
log("\n");
log("Re-evaluate the selected modules with new parameters. String values must be\n");
log("passed in double quotes (\").\n");
log("\n");
}
virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{
std::vector<setunset_t> setunset_list;
dict<RTLIL::IdString, RTLIL::Const> new_parameters;
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
std::string arg = args[argidx];
if (arg == "-set" && argidx+2 < args.size()) {
argidx += 2;
setunset_t new_param(args[argidx-1], args, argidx);
new_parameters[new_param.name] = new_param.value;
argidx--;
continue;
}
break;
}
extra_args(args, argidx, design);
pool<IdString> modnames, old_modnames;
for (auto module : design->selected_modules()) {
if (design->selected_whole_module(module))
modnames.insert(module->name);
else
log_warning("Ignoring partially selected module %s.\n", log_id(module));
old_modnames.insert(module->name);
}
modnames.sort();
for (auto modname : modnames) {
Module *module = design->module(modname);
Module *new_module = design->module(module->derive(design, new_parameters));
if (module != new_module) {
Module *m = new_module->clone();
m->name = module->name;
design->remove(module);
design->add(m);
}
if (old_modnames.count(new_module->name) == 0)
design->remove(new_module);
}
}
} ChparamPass;
PRIVATE_NAMESPACE_END
<|endoftext|> |
<commit_before>/*
* yosys -- Yosys Open SYnthesis Suite
*
* Copyright (C) 2018 whitequark <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#include "kernel/yosys.h"
#include "kernel/sigtools.h"
#include "kernel/modtools.h"
USING_YOSYS_NAMESPACE
PRIVATE_NAMESPACE_BEGIN
struct OptLutWorker
{
RTLIL::Module *module;
ModIndex index;
SigMap sigmap;
pool<RTLIL::Cell*> luts;
dict<RTLIL::Cell*, int> luts_arity;
int combined_count = 0;
bool evaluate_lut(RTLIL::Cell *lut, dict<SigBit, bool> inputs)
{
SigSpec lut_input = sigmap(lut->getPort("\\A"));
int lut_width = lut->getParam("\\WIDTH").as_int();
Const lut_table = lut->getParam("\\LUT");
int lut_index = 0;
for (int i = 0; i < lut_width; i++)
{
SigBit input = sigmap(lut_input[i]);
if (inputs.count(input))
{
lut_index |= inputs[input] << i;
}
else
{
lut_index |= SigSpec(lut_input[i]).as_bool() << i;
}
}
return lut_table.extract(lut_index).as_int();
}
void show_stats_by_arity()
{
dict<int, int> arity_counts;
int max_arity = 0;
for (auto lut_arity : luts_arity)
{
max_arity = max(max_arity, lut_arity.second);
arity_counts[lut_arity.second]++;
}
log("Number of LUTs: %6zu\n", luts.size());
for (int arity = 1; arity <= max_arity; arity++)
{
if (arity_counts[arity])
log(" %d-LUT: %13d\n", arity, arity_counts[arity]);
}
}
OptLutWorker(RTLIL::Module *module) :
module(module), index(module), sigmap(module)
{
log("Discovering LUTs.\n");
for (auto cell : module->selected_cells())
{
if (cell->type == "$lut")
{
int lut_width = cell->getParam("\\WIDTH").as_int();
SigSpec lut_input = cell->getPort("\\A");
int lut_arity = 0;
for (auto &bit : lut_input)
{
if (bit.wire)
lut_arity++;
}
log("Found $lut cell %s.%s with WIDTH=%d implementing %d-LUT.\n", log_id(module), log_id(cell), lut_width, lut_arity);
luts.insert(cell);
luts_arity[cell] = lut_arity;
}
}
show_stats_by_arity();
log("\n");
log("Combining LUTs.\n");
pool<RTLIL::Cell*> worklist = luts;
while (worklist.size())
{
auto lutA = worklist.pop();
SigSpec lutA_input = sigmap(lutA->getPort("\\A"));
SigSpec lutA_output = sigmap(lutA->getPort("\\Y")[0]);
int lutA_width = lutA->getParam("\\WIDTH").as_int();
int lutA_arity = luts_arity[lutA];
auto lutA_output_ports = index.query_ports(lutA->getPort("\\Y"));
if (lutA_output_ports.size() != 2)
continue;
for (auto port : lutA_output_ports)
{
if (port.cell == lutA)
continue;
if (luts.count(port.cell))
{
auto lutB = port.cell;
SigSpec lutB_input = sigmap(lutB->getPort("\\A"));
SigSpec lutB_output = sigmap(lutB->getPort("\\Y")[0]);
int lutB_width = lutB->getParam("\\WIDTH").as_int();
int lutB_arity = luts_arity[lutB];
log("Found %s.%s (cell A) feeding %s.%s (cell B).\n", log_id(module), log_id(lutA), log_id(module), log_id(lutB));
pool<SigBit> lutA_inputs;
pool<SigBit> lutB_inputs;
for (auto &bit : lutA_input)
{
if (bit.wire)
lutA_inputs.insert(sigmap(bit));
}
for (auto &bit : lutB_input)
{
if(bit.wire)
lutB_inputs.insert(sigmap(bit));
}
pool<SigBit> common_inputs;
for (auto &bit : lutA_inputs)
{
if (lutB_inputs.count(bit))
common_inputs.insert(bit);
}
int lutM_arity = lutA_arity + lutB_arity - 1 - common_inputs.size();
log(" Cell A is a %d-LUT. Cell B is a %d-LUT. Cells share %zu input(s) and can be merged into one %d-LUT.\n", lutA_arity, lutB_arity, common_inputs.size(), lutM_arity);
int combine = -1;
if (combine == -1)
{
if (lutM_arity > lutA_width)
{
log(" Not combining LUTs into cell A (combined LUT too wide).\n");
}
else if (lutB->get_bool_attribute("\\lut_keep"))
{
log(" Not combining LUTs into cell A (cell B has attribute \\lut_keep).\n");
}
else combine = 0;
}
if (combine == -1)
{
if (lutM_arity > lutB_width)
{
log(" Not combining LUTs into cell B (combined LUT too wide).\n");
}
else if (lutA->get_bool_attribute("\\lut_keep"))
{
log(" Not combining LUTs into cell B (cell A has attribute \\lut_keep).\n");
}
else combine = 1;
}
RTLIL::Cell *lutM, *lutR;
pool<SigBit> lutM_inputs, lutR_inputs;
if (combine == 0)
{
log(" Combining LUTs into cell A.\n");
lutM = lutA;
lutM_inputs = lutA_inputs;
lutR = lutB;
lutR_inputs = lutB_inputs;
}
else if (combine == 1)
{
log(" Combining LUTs into cell B.\n");
lutM = lutB;
lutM_inputs = lutB_inputs;
lutR = lutA;
lutR_inputs = lutA_inputs;
}
else
{
log(" Cannot combine LUTs.\n");
continue;
}
pool<SigBit> lutR_unique;
for (auto &bit : lutR_inputs)
{
if (!common_inputs.count(bit) && bit != lutA_output)
lutR_unique.insert(bit);
}
int lutM_width = lutM->getParam("\\WIDTH").as_int();
SigSpec lutM_input = sigmap(lutM->getPort("\\A"));
std::vector<SigBit> lutM_new_inputs;
for (int i = 0; i < lutM_width; i++)
{
if ((!lutM_input[i].wire || sigmap(lutM_input[i]) == lutA_output) && lutR_unique.size())
{
SigBit new_input = lutR_unique.pop();
log(" Connecting input %d as %s.\n", i, log_signal(new_input));
lutM_new_inputs.push_back(new_input);
}
else if (sigmap(lutM_input[i]) == lutA_output)
{
log(" Disconnecting input %d.\n", i);
lutM_new_inputs.push_back(SigBit());
}
else
{
log(" Leaving input %d as %s.\n", i, log_signal(lutM_input[i]));
lutM_new_inputs.push_back(lutM_input[i]);
}
}
log_assert(lutR_unique.size() == 0);
RTLIL::Const lutM_new_table(State::Sx, 1 << lutM_width);
for (int eval = 0; eval < 1 << lutM_width; eval++)
{
dict<SigBit, bool> eval_inputs;
for (size_t i = 0; i < lutM_new_inputs.size(); i++)
{
eval_inputs[lutM_new_inputs[i]] = (eval >> i) & 1;
}
eval_inputs[lutA_output] = evaluate_lut(lutA, eval_inputs);
lutM_new_table[eval] = (RTLIL::State) evaluate_lut(lutB, eval_inputs);
}
log(" Old truth table: %s.\n", lutM->getParam("\\LUT").as_string().c_str());
log(" New truth table: %s.\n", lutM_new_table.as_string().c_str());
lutM->setParam("\\LUT", lutM_new_table);
lutM->setPort("\\A", lutM_new_inputs);
lutM->setPort("\\Y", lutB_output);
luts_arity[lutM] = lutM_arity;
luts.erase(lutR);
luts_arity.erase(lutR);
lutR->module->remove(lutR);
worklist.insert(lutM);
worklist.erase(lutR);
combined_count++;
}
}
}
show_stats_by_arity();
}
};
struct OptLutPass : public Pass {
OptLutPass() : Pass("opt_lut", "optimize LUT cells") { }
void help() YS_OVERRIDE
{
log("\n");
log(" opt_lut [options] [selection]\n");
log("\n");
log("This pass combines cascaded $lut cells with unused inputs.\n");
log("\n");
}
void execute(std::vector<std::string> args, RTLIL::Design *design) YS_OVERRIDE
{
log_header(design, "Executing OPT_LUT pass (optimize LUTs).\n");
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
// if (args[argidx] == "-???") {
// continue;
// }
break;
}
extra_args(args, argidx, design);
int total_count = 0;
for (auto module : design->selected_modules())
{
OptLutWorker worker(module);
total_count += worker.combined_count;
}
if (total_count)
design->scratchpad_set_bool("opt.did_something", true);
log("\n");
log("Combined %d LUTs.\n", total_count);
}
} OptLutPass;
PRIVATE_NAMESPACE_END
<commit_msg>opt_lut: always prefer to eliminate 1-LUTs.<commit_after>/*
* yosys -- Yosys Open SYnthesis Suite
*
* Copyright (C) 2018 whitequark <[email protected]>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#include "kernel/yosys.h"
#include "kernel/sigtools.h"
#include "kernel/modtools.h"
USING_YOSYS_NAMESPACE
PRIVATE_NAMESPACE_BEGIN
struct OptLutWorker
{
RTLIL::Module *module;
ModIndex index;
SigMap sigmap;
pool<RTLIL::Cell*> luts;
dict<RTLIL::Cell*, int> luts_arity;
int combined_count = 0;
bool evaluate_lut(RTLIL::Cell *lut, dict<SigBit, bool> inputs)
{
SigSpec lut_input = sigmap(lut->getPort("\\A"));
int lut_width = lut->getParam("\\WIDTH").as_int();
Const lut_table = lut->getParam("\\LUT");
int lut_index = 0;
for (int i = 0; i < lut_width; i++)
{
SigBit input = sigmap(lut_input[i]);
if (inputs.count(input))
{
lut_index |= inputs[input] << i;
}
else
{
lut_index |= SigSpec(lut_input[i]).as_bool() << i;
}
}
return lut_table.extract(lut_index).as_int();
}
void show_stats_by_arity()
{
dict<int, int> arity_counts;
int max_arity = 0;
for (auto lut_arity : luts_arity)
{
max_arity = max(max_arity, lut_arity.second);
arity_counts[lut_arity.second]++;
}
log("Number of LUTs: %6zu\n", luts.size());
for (int arity = 1; arity <= max_arity; arity++)
{
if (arity_counts[arity])
log(" %d-LUT: %13d\n", arity, arity_counts[arity]);
}
}
OptLutWorker(RTLIL::Module *module) :
module(module), index(module), sigmap(module)
{
log("Discovering LUTs.\n");
for (auto cell : module->selected_cells())
{
if (cell->type == "$lut")
{
int lut_width = cell->getParam("\\WIDTH").as_int();
SigSpec lut_input = cell->getPort("\\A");
int lut_arity = 0;
for (auto &bit : lut_input)
{
if (bit.wire)
lut_arity++;
}
log("Found $lut cell %s.%s with WIDTH=%d implementing %d-LUT.\n", log_id(module), log_id(cell), lut_width, lut_arity);
luts.insert(cell);
luts_arity[cell] = lut_arity;
}
}
show_stats_by_arity();
log("\n");
log("Combining LUTs.\n");
pool<RTLIL::Cell*> worklist = luts;
while (worklist.size())
{
auto lutA = worklist.pop();
SigSpec lutA_input = sigmap(lutA->getPort("\\A"));
SigSpec lutA_output = sigmap(lutA->getPort("\\Y")[0]);
int lutA_width = lutA->getParam("\\WIDTH").as_int();
int lutA_arity = luts_arity[lutA];
auto lutA_output_ports = index.query_ports(lutA->getPort("\\Y"));
if (lutA_output_ports.size() != 2)
continue;
for (auto port : lutA_output_ports)
{
if (port.cell == lutA)
continue;
if (luts.count(port.cell))
{
auto lutB = port.cell;
SigSpec lutB_input = sigmap(lutB->getPort("\\A"));
SigSpec lutB_output = sigmap(lutB->getPort("\\Y")[0]);
int lutB_width = lutB->getParam("\\WIDTH").as_int();
int lutB_arity = luts_arity[lutB];
log("Found %s.%s (cell A) feeding %s.%s (cell B).\n", log_id(module), log_id(lutA), log_id(module), log_id(lutB));
pool<SigBit> lutA_inputs;
pool<SigBit> lutB_inputs;
for (auto &bit : lutA_input)
{
if (bit.wire)
lutA_inputs.insert(sigmap(bit));
}
for (auto &bit : lutB_input)
{
if(bit.wire)
lutB_inputs.insert(sigmap(bit));
}
pool<SigBit> common_inputs;
for (auto &bit : lutA_inputs)
{
if (lutB_inputs.count(bit))
common_inputs.insert(bit);
}
int lutM_arity = lutA_arity + lutB_arity - 1 - common_inputs.size();
log(" Cell A is a %d-LUT. Cell B is a %d-LUT. Cells share %zu input(s) and can be merged into one %d-LUT.\n", lutA_arity, lutB_arity, common_inputs.size(), lutM_arity);
const int COMBINE_A = 1, COMBINE_B = 2, COMBINE_EITHER = COMBINE_A | COMBINE_B;
int combine_mask = 0;
if (lutM_arity > lutA_width)
{
log(" Not combining LUTs into cell A (combined LUT wider than cell A).\n");
}
else if (lutB->get_bool_attribute("\\lut_keep"))
{
log(" Not combining LUTs into cell A (cell B has attribute \\lut_keep).\n");
}
else
{
combine_mask |= COMBINE_A;
}
if (lutM_arity > lutB_width)
{
log(" Not combining LUTs into cell B (combined LUT wider than cell B).\n");
}
else if (lutA->get_bool_attribute("\\lut_keep"))
{
log(" Not combining LUTs into cell B (cell A has attribute \\lut_keep).\n");
}
else
{
combine_mask |= COMBINE_B;
}
int combine = combine_mask;
if (combine == COMBINE_EITHER)
{
log(" Can combine into either cell.\n");
if (lutA_arity == 1)
{
log(" Cell A is a buffer or inverter, combining into cell B.\n");
combine = COMBINE_B;
}
else if (lutB_arity == 1)
{
log(" Cell B is a buffer or inverter, combining into cell A.\n");
combine = COMBINE_A;
}
else
{
log(" Arbitrarily combining into cell A.\n");
combine = COMBINE_A;
}
}
RTLIL::Cell *lutM, *lutR;
pool<SigBit> lutM_inputs, lutR_inputs;
if (combine == COMBINE_A)
{
log(" Combining LUTs into cell A.\n");
lutM = lutA;
lutM_inputs = lutA_inputs;
lutR = lutB;
lutR_inputs = lutB_inputs;
}
else if (combine == COMBINE_B)
{
log(" Combining LUTs into cell B.\n");
lutM = lutB;
lutM_inputs = lutB_inputs;
lutR = lutA;
lutR_inputs = lutA_inputs;
}
else
{
log(" Cannot combine LUTs.\n");
continue;
}
pool<SigBit> lutR_unique;
for (auto &bit : lutR_inputs)
{
if (!common_inputs.count(bit) && bit != lutA_output)
lutR_unique.insert(bit);
}
int lutM_width = lutM->getParam("\\WIDTH").as_int();
SigSpec lutM_input = sigmap(lutM->getPort("\\A"));
std::vector<SigBit> lutM_new_inputs;
for (int i = 0; i < lutM_width; i++)
{
if ((!lutM_input[i].wire || sigmap(lutM_input[i]) == lutA_output) && lutR_unique.size())
{
SigBit new_input = lutR_unique.pop();
log(" Connecting input %d as %s.\n", i, log_signal(new_input));
lutM_new_inputs.push_back(new_input);
}
else if (sigmap(lutM_input[i]) == lutA_output)
{
log(" Disconnecting input %d.\n", i);
lutM_new_inputs.push_back(SigBit());
}
else
{
log(" Leaving input %d as %s.\n", i, log_signal(lutM_input[i]));
lutM_new_inputs.push_back(lutM_input[i]);
}
}
log_assert(lutR_unique.size() == 0);
RTLIL::Const lutM_new_table(State::Sx, 1 << lutM_width);
for (int eval = 0; eval < 1 << lutM_width; eval++)
{
dict<SigBit, bool> eval_inputs;
for (size_t i = 0; i < lutM_new_inputs.size(); i++)
{
eval_inputs[lutM_new_inputs[i]] = (eval >> i) & 1;
}
eval_inputs[lutA_output] = evaluate_lut(lutA, eval_inputs);
lutM_new_table[eval] = (RTLIL::State) evaluate_lut(lutB, eval_inputs);
}
log(" Old truth table: %s.\n", lutM->getParam("\\LUT").as_string().c_str());
log(" New truth table: %s.\n", lutM_new_table.as_string().c_str());
lutM->setParam("\\LUT", lutM_new_table);
lutM->setPort("\\A", lutM_new_inputs);
lutM->setPort("\\Y", lutB_output);
luts_arity[lutM] = lutM_arity;
luts.erase(lutR);
luts_arity.erase(lutR);
lutR->module->remove(lutR);
worklist.insert(lutM);
worklist.erase(lutR);
combined_count++;
}
}
}
show_stats_by_arity();
}
};
struct OptLutPass : public Pass {
OptLutPass() : Pass("opt_lut", "optimize LUT cells") { }
void help() YS_OVERRIDE
{
log("\n");
log(" opt_lut [options] [selection]\n");
log("\n");
log("This pass combines cascaded $lut cells with unused inputs.\n");
log("\n");
}
void execute(std::vector<std::string> args, RTLIL::Design *design) YS_OVERRIDE
{
log_header(design, "Executing OPT_LUT pass (optimize LUTs).\n");
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++)
{
// if (args[argidx] == "-???") {
// continue;
// }
break;
}
extra_args(args, argidx, design);
int total_count = 0;
for (auto module : design->selected_modules())
{
OptLutWorker worker(module);
total_count += worker.combined_count;
}
if (total_count)
design->scratchpad_set_bool("opt.did_something", true);
log("\n");
log("Combined %d LUTs.\n", total_count);
}
} OptLutPass;
PRIVATE_NAMESPACE_END
<|endoftext|> |
<commit_before>////////////////////////////////////////////////////////////////////////////////
// taskd - Task Server
//
// Copyright 2010 - 2012, Göteborg Bit Factory.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#include <taskd.h>
#include <text.h>
////////////////////////////////////////////////////////////////////////////////
int command_init (Config& config, const std::vector <std::string>& args)
{
int status = 0;
// Standard argument processing.
bool verbose = true;
bool debug = false;
std::string root = "";
std::vector <std::string>::const_iterator i;
for (i = ++(args.begin ()); i != args.end (); ++i)
{
if (closeEnough ("--quiet", *i, 3)) verbose = false;
else if (closeEnough ("--debug", *i, 3)) debug = true;
else if (closeEnough ("--data", *i, 3)) root = *(++i);
else if (taskd_applyOverride (config, *i)) ;
else
throw std::string ("ERROR: Unrecognized argument '") + *i + "'";
// Verify that root exists.
if (root == "")
throw std::string ("The '--data' option is required.");
Directory root_dir (root);
if (!root_dir.exists ())
throw std::string ("The '--data' path does not exist.");
if (!root_dir.is_directory ())
throw std::string ("The '--data' path is not a directory.");
if (!root_dir.readable ())
throw std::string ("The '--data' directory is not readable.");
if (!root_dir.writable ())
throw std::string ("The '--data' directory is not writable.");
if (!root_dir.executable ())
throw std::string ("The '--data' directory is not executable.");
// Create the data structure.
Directory sub (root_dir);
sub.cd ();
sub += "orgs";
if (!sub.create ())
throw std::string ("Could not create '") + sub._data + "'.";
// TODO Dump the config file?
}
return status;
}
////////////////////////////////////////////////////////////////////////////////
<commit_msg>Bug<commit_after>////////////////////////////////////////////////////////////////////////////////
// taskd - Task Server
//
// Copyright 2010 - 2012, Göteborg Bit Factory.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#include <taskd.h>
#include <text.h>
////////////////////////////////////////////////////////////////////////////////
int command_init (Config& config, const std::vector <std::string>& args)
{
int status = 0;
// Standard argument processing.
bool verbose = true;
bool debug = false;
std::string root = "";
std::vector <std::string>::const_iterator i;
for (i = ++(args.begin ()); i != args.end (); ++i)
{
if (closeEnough ("--quiet", *i, 3)) verbose = false;
else if (closeEnough ("--debug", *i, 3)) debug = true;
else if (closeEnough ("--data", *i, 3)) root = *(++i);
else if (taskd_applyOverride (config, *i)) ;
else
throw std::string ("ERROR: Unrecognized argument '") + *i + "'";
}
// Verify that root exists.
if (root == "")
throw std::string ("The '--data' option is required.");
Directory root_dir (root);
if (!root_dir.exists ())
throw std::string ("The '--data' path does not exist.");
if (!root_dir.is_directory ())
throw std::string ("The '--data' path is not a directory.");
if (!root_dir.readable ())
throw std::string ("The '--data' directory is not readable.");
if (!root_dir.writable ())
throw std::string ("The '--data' directory is not writable.");
if (!root_dir.executable ())
throw std::string ("The '--data' directory is not executable.");
// Create the data structure.
Directory sub (root_dir);
sub.cd ();
sub += "orgs";
if (!sub.create ())
throw std::string ("Could not create '") + sub._data + "'.";
// TODO Dump the config file?
return status;
}
////////////////////////////////////////////////////////////////////////////////
<|endoftext|> |
<commit_before>#include "proc.h"
#include "serv.h"
struct BytesEqual{
bool operator()(const Bytes &s1, const Bytes &s2) const {
return (bool)(s1.compare(s2) == 0);
}
};
struct BytesHash{
size_t operator()(const Bytes &s1) const {
unsigned long __h = 0;
const char *p = s1.data();
for (int i=0 ; i<s1.size(); i++)
__h = 5*__h + p[i];
return size_t(__h);
}
};
#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#if GCC_VERSION >= 403
#include <tr1/unordered_map>
typedef std::tr1::unordered_map<Bytes, Command *, BytesHash, BytesEqual> proc_map_t;
#else
#ifdef NEW_MAC
#include <unordered_map>
typedef std::unordered_map<Bytes, Command *, BytesHash, BytesEqual> proc_map_t;
#else
#include <ext/hash_map>
typedef __gnu_cxx::hash_map<Bytes, Command *, BytesHash, BytesEqual> proc_map_t;
#endif
#endif
#define DEF_PROC(f) int proc_##f(Server *serv, Link *link, const Request &req, Response *resp)
DEF_PROC(get);
DEF_PROC(set);
DEF_PROC(setx);
DEF_PROC(setnx);
DEF_PROC(getset);
DEF_PROC(getbit);
DEF_PROC(setbit);
DEF_PROC(countbit);
DEF_PROC(substr);
DEF_PROC(getrange);
DEF_PROC(strlen);
DEF_PROC(redis_bitcount);
DEF_PROC(del);
DEF_PROC(incr);
DEF_PROC(decr);
DEF_PROC(scan);
DEF_PROC(rscan);
DEF_PROC(keys);
DEF_PROC(exists);
DEF_PROC(multi_exists);
DEF_PROC(multi_get);
DEF_PROC(multi_set);
DEF_PROC(multi_del);
DEF_PROC(hsize);
DEF_PROC(hget);
DEF_PROC(hset);
DEF_PROC(hdel);
DEF_PROC(hincr);
DEF_PROC(hdecr);
DEF_PROC(hclear);
DEF_PROC(hgetall);
DEF_PROC(hscan);
DEF_PROC(hrscan);
DEF_PROC(hkeys);
DEF_PROC(hvals);
DEF_PROC(hlist);
DEF_PROC(hrlist);
DEF_PROC(hexists);
DEF_PROC(multi_hexists);
DEF_PROC(multi_hsize);
DEF_PROC(multi_hget);
DEF_PROC(multi_hset);
DEF_PROC(multi_hdel);
DEF_PROC(zrank);
DEF_PROC(zrrank);
DEF_PROC(zrange);
DEF_PROC(zrrange);
DEF_PROC(zsize);
DEF_PROC(zget);
DEF_PROC(zset);
DEF_PROC(zdel);
DEF_PROC(zincr);
DEF_PROC(zdecr);
DEF_PROC(zclear);
DEF_PROC(zscan);
DEF_PROC(zrscan);
DEF_PROC(zkeys);
DEF_PROC(zlist);
DEF_PROC(zrlist);
DEF_PROC(zcount);
DEF_PROC(zsum);
DEF_PROC(zavg);
DEF_PROC(zexists);
DEF_PROC(zremrangebyrank);
DEF_PROC(zremrangebyscore);
DEF_PROC(multi_zexists);
DEF_PROC(multi_zsize);
DEF_PROC(multi_zget);
DEF_PROC(multi_zset);
DEF_PROC(multi_zdel);
DEF_PROC(qsize);
DEF_PROC(qfront);
DEF_PROC(qback);
DEF_PROC(qpush);
DEF_PROC(qpush_front);
DEF_PROC(qpush_back);
DEF_PROC(qpop);
DEF_PROC(qpop_front);
DEF_PROC(qpop_back);
DEF_PROC(qtrim_front);
DEF_PROC(qtrim_back);
DEF_PROC(qfix);
DEF_PROC(qclear);
DEF_PROC(qlist);
DEF_PROC(qrlist);
DEF_PROC(qslice);
DEF_PROC(qrange);
DEF_PROC(qget);
DEF_PROC(qset);
DEF_PROC(dump);
DEF_PROC(sync140);
DEF_PROC(info);
DEF_PROC(compact);
DEF_PROC(key_range);
DEF_PROC(set_key_range);
DEF_PROC(ttl);
DEF_PROC(expire);
DEF_PROC(clear_binlog);
DEF_PROC(ping);
DEF_PROC(auth);
#undef DEF_PROC
#define PROC(c, f) {#c, f, 0, proc_##c, 0, 0, 0, 0}
#define PROC_KP1(c, f) {#c, f, 0, proc_##c, 0, 0, 0, 1}
static Command commands[] = {
PROC_KP1(get, "r"),
PROC_KP1(set, "wt"),
PROC(setx, "wt"),
PROC(setnx, "wt"),
PROC(getset, "wt"),
PROC(getbit, "r"),
PROC(setbit, "wt"),
PROC(countbit, "r"),
PROC(substr, "r"),
PROC(getrange, "r"),
PROC(strlen, "r"),
PROC(redis_bitcount, "r"),
PROC(del, "wt"),
PROC(incr, "wt"),
PROC(decr, "wt"),
PROC(scan, "rt"),
PROC(rscan, "rt"),
PROC(keys, "rt"),
PROC(exists, "r"),
PROC(multi_exists, "r"),
PROC(multi_get, "rt"),
PROC(multi_set, "wt"),
PROC(multi_del, "wt"),
PROC(hsize, "r"),
PROC(hget, "r"),
PROC(hset, "wt"),
PROC(hdel, "wt"),
PROC(hincr, "wt"),
PROC(hdecr, "wt"),
PROC(hclear, "wt"),
PROC(hgetall, "rt"),
PROC(hscan, "rt"),
PROC(hrscan, "rt"),
PROC(hkeys, "rt"),
PROC(hvals, "rt"),
PROC(hlist, "rt"),
PROC(hrlist, "rt"),
PROC(hexists, "r"),
PROC(multi_hexists, "r"),
PROC(multi_hsize, "r"),
PROC(multi_hget, "rt"),
PROC(multi_hset, "wt"),
PROC(multi_hdel, "wt"),
// because zrank may be extremly slow, execute in a seperate thread
PROC(zrank, "rt"),
PROC(zrrank, "rt"),
PROC(zrange, "rt"),
PROC(zrrange, "rt"),
PROC(zsize, "r"),
PROC(zget, "rt"),
PROC(zset, "wt"),
PROC(zdel, "wt"),
PROC(zincr, "wt"),
PROC(zdecr, "wt"),
PROC(zclear, "wt"),
PROC(zscan, "rt"),
PROC(zrscan, "rt"),
PROC(zkeys, "rt"),
PROC(zlist, "rt"),
PROC(zrlist, "rt"),
PROC(zcount, "rt"),
PROC(zsum, "rt"),
PROC(zavg, "rt"),
PROC(zremrangebyrank, "wt"),
PROC(zremrangebyscore, "wt"),
PROC(zexists, "r"),
PROC(multi_zexists, "r"),
PROC(multi_zsize, "r"),
PROC(multi_zget, "rt"),
PROC(multi_zset, "wt"),
PROC(multi_zdel, "wt"),
PROC(qsize, "r"),
PROC(qfront, "r"),
PROC(qback, "r"),
PROC(qpush, "wt"),
PROC(qpush_front, "wt"),
PROC(qpush_back, "wt"),
PROC(qpop, "wt"),
PROC(qpop_front, "wt"),
PROC(qpop_back, "wt"),
PROC(qtrim_front, "wt"),
PROC(qtrim_back, "wt"),
PROC(qfix, "wt"),
PROC(qclear, "wt"),
PROC(qlist, "rt"),
PROC(qrlist, "rt"),
PROC(qslice, "rt"),
PROC(qrange, "rt"),
PROC(qget, "r"),
PROC(qset, "wt"),
PROC(clear_binlog, "wt"),
PROC(dump, "b"),
PROC(sync140, "b"),
PROC(info, "r"),
// doing compaction in a reader thread, because we have only one
// writer thread(for performance reason), we don't want to block writes
PROC(compact, "rt"),
PROC(key_range, "r"),
PROC(set_key_range, "w"),
PROC(ttl, "r"),
PROC(expire, "wt"),
PROC(ping, "r"),
PROC(auth, "r"),
{NULL, NULL, 0, NULL}
};
#undef PROC
static proc_map_t proc_map;
ProcMap::ProcMap(){
for(Command *cmd=commands; cmd->name; cmd++){
for(const char *p=cmd->sflags; *p!='\0'; p++){
switch(*p){
case 'r':
cmd->flags |= Command::FLAG_READ;
break;
case 'w':
cmd->flags |= Command::FLAG_WRITE;
break;
case 'b':
cmd->flags |= Command::FLAG_BACKEND;
break;
case 't':
cmd->flags |= Command::FLAG_THREAD;
break;
}
}
proc_map[cmd->name] = cmd;
}
// for k-v data, list === keys
proc_map["list"] = proc_map["keys"];
}
ProcMap::~ProcMap(){
}
Command* ProcMap::find(const Bytes &str){
proc_map_t::iterator it = proc_map.find(str);
if(it != proc_map.end()){
return it->second;
}
return NULL;
}
int proc_info(Server *serv, Link *link, const Request &req, Response *resp){
resp->push_back("ok");
resp->push_back("ssdb-server");
resp->push_back("version");
resp->push_back(SSDB_VERSION);
{
resp->push_back("links");
resp->add(serv->link_count);
}
{
int64_t calls = 0;
for(Command *cmd=commands; cmd->name; cmd++){
calls += cmd->calls;
}
resp->push_back("total_calls");
resp->add(calls);
}
if(req.size() > 1 && req[1] == "cmd"){
for(Command *cmd=commands; cmd->name; cmd++){
char buf[128];
snprintf(buf, sizeof(buf), "cmd.%s", cmd->name);
resp->push_back(buf);
snprintf(buf, sizeof(buf), "calls: %" PRIu64 "\ttime_wait: %.0f\ttime_proc: %.0f",
cmd->calls, cmd->time_wait, cmd->time_proc);
resp->push_back(buf);
}
}
if(req.size() == 1 || req[1] == "range"){
std::vector<std::string> tmp;
int ret = serv->ssdb->key_range(&tmp);
if(ret == 0){
char buf[512];
resp->push_back("key_range.kv");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[0].data(), tmp[0].size()).c_str(),
hexmem(tmp[1].data(), tmp[1].size()).c_str()
);
resp->push_back(buf);
resp->push_back("key_range.hash");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[2].data(), tmp[2].size()).c_str(),
hexmem(tmp[3].data(), tmp[3].size()).c_str()
);
resp->push_back(buf);
resp->push_back("key_range.zset");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[4].data(), tmp[4].size()).c_str(),
hexmem(tmp[5].data(), tmp[5].size()).c_str()
);
resp->push_back(buf);
resp->push_back("key_range.list");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[6].data(), tmp[6].size()).c_str(),
hexmem(tmp[7].data(), tmp[7].size()).c_str()
);
resp->push_back(buf);
}
}
if(req.size() == 1 || req[1] == "leveldb"){
std::vector<std::string> tmp = serv->ssdb->info();
for(int i=0; i<(int)tmp.size(); i++){
std::string block = tmp[i];
resp->push_back(block);
}
}
return 0;
}
<commit_msg>udpate<commit_after>#include "proc.h"
#include "serv.h"
struct BytesEqual{
bool operator()(const Bytes &s1, const Bytes &s2) const {
return (bool)(s1.compare(s2) == 0);
}
};
struct BytesHash{
size_t operator()(const Bytes &s1) const {
unsigned long __h = 0;
const char *p = s1.data();
for (int i=0 ; i<s1.size(); i++)
__h = 5*__h + p[i];
return size_t(__h);
}
};
#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#if GCC_VERSION >= 403
#include <tr1/unordered_map>
typedef std::tr1::unordered_map<Bytes, Command *, BytesHash, BytesEqual> proc_map_t;
#else
#ifdef NEW_MAC
#include <unordered_map>
typedef std::unordered_map<Bytes, Command *, BytesHash, BytesEqual> proc_map_t;
#else
#include <ext/hash_map>
typedef __gnu_cxx::hash_map<Bytes, Command *, BytesHash, BytesEqual> proc_map_t;
#endif
#endif
#define DEF_PROC(f) int proc_##f(Server *serv, Link *link, const Request &req, Response *resp)
DEF_PROC(get);
DEF_PROC(set);
DEF_PROC(setx);
DEF_PROC(setnx);
DEF_PROC(getset);
DEF_PROC(getbit);
DEF_PROC(setbit);
DEF_PROC(countbit);
DEF_PROC(substr);
DEF_PROC(getrange);
DEF_PROC(strlen);
DEF_PROC(redis_bitcount);
DEF_PROC(del);
DEF_PROC(incr);
DEF_PROC(decr);
DEF_PROC(scan);
DEF_PROC(rscan);
DEF_PROC(keys);
DEF_PROC(exists);
DEF_PROC(multi_exists);
DEF_PROC(multi_get);
DEF_PROC(multi_set);
DEF_PROC(multi_del);
DEF_PROC(hsize);
DEF_PROC(hget);
DEF_PROC(hset);
DEF_PROC(hdel);
DEF_PROC(hincr);
DEF_PROC(hdecr);
DEF_PROC(hclear);
DEF_PROC(hgetall);
DEF_PROC(hscan);
DEF_PROC(hrscan);
DEF_PROC(hkeys);
DEF_PROC(hvals);
DEF_PROC(hlist);
DEF_PROC(hrlist);
DEF_PROC(hexists);
DEF_PROC(multi_hexists);
DEF_PROC(multi_hsize);
DEF_PROC(multi_hget);
DEF_PROC(multi_hset);
DEF_PROC(multi_hdel);
DEF_PROC(zrank);
DEF_PROC(zrrank);
DEF_PROC(zrange);
DEF_PROC(zrrange);
DEF_PROC(zsize);
DEF_PROC(zget);
DEF_PROC(zset);
DEF_PROC(zdel);
DEF_PROC(zincr);
DEF_PROC(zdecr);
DEF_PROC(zclear);
DEF_PROC(zscan);
DEF_PROC(zrscan);
DEF_PROC(zkeys);
DEF_PROC(zlist);
DEF_PROC(zrlist);
DEF_PROC(zcount);
DEF_PROC(zsum);
DEF_PROC(zavg);
DEF_PROC(zexists);
DEF_PROC(zremrangebyrank);
DEF_PROC(zremrangebyscore);
DEF_PROC(multi_zexists);
DEF_PROC(multi_zsize);
DEF_PROC(multi_zget);
DEF_PROC(multi_zset);
DEF_PROC(multi_zdel);
DEF_PROC(qsize);
DEF_PROC(qfront);
DEF_PROC(qback);
DEF_PROC(qpush);
DEF_PROC(qpush_front);
DEF_PROC(qpush_back);
DEF_PROC(qpop);
DEF_PROC(qpop_front);
DEF_PROC(qpop_back);
DEF_PROC(qtrim_front);
DEF_PROC(qtrim_back);
DEF_PROC(qfix);
DEF_PROC(qclear);
DEF_PROC(qlist);
DEF_PROC(qrlist);
DEF_PROC(qslice);
DEF_PROC(qrange);
DEF_PROC(qget);
DEF_PROC(qset);
DEF_PROC(dump);
DEF_PROC(sync140);
DEF_PROC(info);
DEF_PROC(compact);
DEF_PROC(key_range);
DEF_PROC(set_key_range);
DEF_PROC(ttl);
DEF_PROC(expire);
DEF_PROC(clear_binlog);
DEF_PROC(ping);
DEF_PROC(auth);
#undef DEF_PROC
#define PROC(c, f) {#c, f, 0, proc_##c, 0, 0, 0, 0}
#define PROC_KP1(c, f) {#c, f, 0, proc_##c, 0, 0, 0, 1}
static Command commands[] = {
PROC_KP1(get, "r"),
PROC_KP1(set, "wt"),
PROC(setx, "wt"),
PROC(setnx, "wt"),
PROC(getset, "wt"),
PROC(getbit, "r"),
PROC(setbit, "wt"),
PROC(countbit, "r"),
PROC(substr, "r"),
PROC(getrange, "r"),
PROC(strlen, "r"),
PROC(redis_bitcount, "r"),
PROC(del, "wt"),
PROC(incr, "wt"),
PROC(decr, "wt"),
PROC(scan, "rt"),
PROC(rscan, "rt"),
PROC(keys, "rt"),
PROC(exists, "r"),
PROC(multi_exists, "r"),
PROC(multi_get, "rt"),
PROC(multi_set, "wt"),
PROC(multi_del, "wt"),
PROC(hsize, "r"),
PROC(hget, "r"),
PROC(hset, "wt"),
PROC(hdel, "wt"),
PROC(hincr, "wt"),
PROC(hdecr, "wt"),
PROC(hclear, "wt"),
PROC(hgetall, "rt"),
PROC(hscan, "rt"),
PROC(hrscan, "rt"),
PROC(hkeys, "rt"),
PROC(hvals, "rt"),
PROC(hlist, "rt"),
PROC(hrlist, "rt"),
PROC(hexists, "r"),
PROC(multi_hexists, "r"),
PROC(multi_hsize, "r"),
PROC(multi_hget, "rt"),
PROC(multi_hset, "wt"),
PROC(multi_hdel, "wt"),
// because zrank may be extremly slow, execute in a seperate thread
PROC(zrank, "rt"),
PROC(zrrank, "rt"),
PROC(zrange, "rt"),
PROC(zrrange, "rt"),
PROC(zsize, "r"),
PROC(zget, "rt"),
PROC(zset, "wt"),
PROC(zdel, "wt"),
PROC(zincr, "wt"),
PROC(zdecr, "wt"),
PROC(zclear, "wt"),
PROC(zscan, "rt"),
PROC(zrscan, "rt"),
PROC(zkeys, "rt"),
PROC(zlist, "rt"),
PROC(zrlist, "rt"),
PROC(zcount, "rt"),
PROC(zsum, "rt"),
PROC(zavg, "rt"),
PROC(zremrangebyrank, "wt"),
PROC(zremrangebyscore, "wt"),
PROC(zexists, "r"),
PROC(multi_zexists, "r"),
PROC(multi_zsize, "r"),
PROC(multi_zget, "rt"),
PROC(multi_zset, "wt"),
PROC(multi_zdel, "wt"),
PROC(qsize, "r"),
PROC(qfront, "r"),
PROC(qback, "r"),
PROC(qpush, "wt"),
PROC(qpush_front, "wt"),
PROC(qpush_back, "wt"),
PROC(qpop, "wt"),
PROC(qpop_front, "wt"),
PROC(qpop_back, "wt"),
PROC(qtrim_front, "wt"),
PROC(qtrim_back, "wt"),
PROC(qfix, "wt"),
PROC(qclear, "wt"),
PROC(qlist, "rt"),
PROC(qrlist, "rt"),
PROC(qslice, "rt"),
PROC(qrange, "rt"),
PROC(qget, "r"),
PROC(qset, "wt"),
PROC(clear_binlog, "wt"),
PROC(dump, "b"),
PROC(sync140, "b"),
PROC(info, "r"),
// doing compaction in a reader thread, because we have only one
// writer thread(for performance reason), we don't want to block writes
PROC(compact, "rt"),
PROC(key_range, "r"),
// set_key_range must run in the main thread
PROC(set_key_range, "r"),
PROC(ttl, "r"),
PROC(expire, "wt"),
PROC(ping, "r"),
PROC(auth, "r"),
{NULL, NULL, 0, NULL}
};
#undef PROC
static proc_map_t proc_map;
ProcMap::ProcMap(){
for(Command *cmd=commands; cmd->name; cmd++){
for(const char *p=cmd->sflags; *p!='\0'; p++){
switch(*p){
case 'r':
cmd->flags |= Command::FLAG_READ;
break;
case 'w':
cmd->flags |= Command::FLAG_WRITE;
break;
case 'b':
cmd->flags |= Command::FLAG_BACKEND;
break;
case 't':
cmd->flags |= Command::FLAG_THREAD;
break;
}
}
proc_map[cmd->name] = cmd;
}
// for k-v data, list === keys
proc_map["list"] = proc_map["keys"];
}
ProcMap::~ProcMap(){
}
Command* ProcMap::find(const Bytes &str){
proc_map_t::iterator it = proc_map.find(str);
if(it != proc_map.end()){
return it->second;
}
return NULL;
}
int proc_info(Server *serv, Link *link, const Request &req, Response *resp){
resp->push_back("ok");
resp->push_back("ssdb-server");
resp->push_back("version");
resp->push_back(SSDB_VERSION);
{
resp->push_back("links");
resp->add(serv->link_count);
}
{
int64_t calls = 0;
for(Command *cmd=commands; cmd->name; cmd++){
calls += cmd->calls;
}
resp->push_back("total_calls");
resp->add(calls);
}
if(req.size() > 1 && req[1] == "cmd"){
for(Command *cmd=commands; cmd->name; cmd++){
char buf[128];
snprintf(buf, sizeof(buf), "cmd.%s", cmd->name);
resp->push_back(buf);
snprintf(buf, sizeof(buf), "calls: %" PRIu64 "\ttime_wait: %.0f\ttime_proc: %.0f",
cmd->calls, cmd->time_wait, cmd->time_proc);
resp->push_back(buf);
}
}
if(req.size() == 1 || req[1] == "range"){
std::vector<std::string> tmp;
int ret = serv->ssdb->key_range(&tmp);
if(ret == 0){
char buf[512];
resp->push_back("key_range.kv");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[0].data(), tmp[0].size()).c_str(),
hexmem(tmp[1].data(), tmp[1].size()).c_str()
);
resp->push_back(buf);
resp->push_back("key_range.hash");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[2].data(), tmp[2].size()).c_str(),
hexmem(tmp[3].data(), tmp[3].size()).c_str()
);
resp->push_back(buf);
resp->push_back("key_range.zset");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[4].data(), tmp[4].size()).c_str(),
hexmem(tmp[5].data(), tmp[5].size()).c_str()
);
resp->push_back(buf);
resp->push_back("key_range.list");
snprintf(buf, sizeof(buf), "\"%s\" - \"%s\"",
hexmem(tmp[6].data(), tmp[6].size()).c_str(),
hexmem(tmp[7].data(), tmp[7].size()).c_str()
);
resp->push_back(buf);
}
}
if(req.size() == 1 || req[1] == "leveldb"){
std::vector<std::string> tmp = serv->ssdb->info();
for(int i=0; i<(int)tmp.size(); i++){
std::string block = tmp[i];
resp->push_back(block);
}
}
return 0;
}
<|endoftext|> |
<commit_before>/* This file is part of the KDE project
Copyright (C) 2005-2006 Matthias Kretz <[email protected]>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), Trolltech ASA
(or its successors, if any) and the KDE Free Qt Foundation, which shall
act as a proxy defined in Section 6 of version 3 of the license.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "audiooutput.h"
#include "audiooutput_p.h"
#include "factory_p.h"
#include "objectdescription.h"
#include "audiooutputadaptor_p.h"
#include "globalconfig_p.h"
#include "audiooutputinterface.h"
#include "phononnamespace_p.h"
#include "platform_p.h"
#include <qmath.h>
#define PHONON_CLASSNAME AudioOutput
#define IFACES2 AudioOutputInterface42
#define IFACES1 IFACES2
#define IFACES0 AudioOutputInterface40, IFACES1
#define PHONON_INTERFACENAME IFACES0
QT_BEGIN_NAMESPACE
namespace Phonon
{
static inline bool callSetOutputDevice(MediaNodePrivate *const d, int index)
{
Iface<IFACES2> iface(d);
if (iface) {
return iface->setOutputDevice(AudioOutputDevice::fromIndex(index));
}
return Iface<IFACES0>::cast(d)->setOutputDevice(index);
}
static inline bool callSetOutputDevice(MediaNodePrivate *const d, const AudioOutputDevice &dev)
{
Iface<IFACES2> iface(d);
if (iface) {
return iface->setOutputDevice(dev);
}
return Iface<IFACES0>::cast(d)->setOutputDevice(dev.index());
}
AudioOutput::AudioOutput(Phonon::Category category, QObject *parent)
: AbstractAudioOutput(*new AudioOutputPrivate, parent)
{
K_D(AudioOutput);
d->init(category);
}
AudioOutput::AudioOutput(QObject *parent)
: AbstractAudioOutput(*new AudioOutputPrivate, parent)
{
K_D(AudioOutput);
d->init(NoCategory);
}
void AudioOutputPrivate::init(Phonon::Category c)
{
Q_Q(AudioOutput);
category = c;
// select hardware device according to the category
device = AudioOutputDevice::fromIndex(GlobalConfig().audioOutputDeviceFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices));
createBackendObject();
#ifndef QT_NO_DBUS
adaptor = new AudioOutputAdaptor(q);
static unsigned int number = 0;
const QString &path = QLatin1String("/AudioOutputs/") + QString::number(number++);
QDBusConnection con = QDBusConnection::sessionBus();
con.registerObject(path, q);
emit adaptor->newOutputAvailable(con.baseService(), path);
q->connect(q, SIGNAL(volumeChanged(qreal)), adaptor, SIGNAL(volumeChanged(qreal)));
q->connect(q, SIGNAL(mutedChanged(bool)), adaptor, SIGNAL(mutedChanged(bool)));
#endif
q->connect(Factory::sender(), SIGNAL(availableAudioOutputDevicesChanged()), SLOT(_k_deviceListChanged()));
}
void AudioOutputPrivate::createBackendObject()
{
if (m_backendObject)
return;
Q_Q(AudioOutput);
m_backendObject = Factory::createAudioOutput(q);
if (m_backendObject) {
setupBackendObject();
}
}
QString AudioOutput::name() const
{
K_D(const AudioOutput);
return d->name;
}
void AudioOutput::setName(const QString &newName)
{
K_D(AudioOutput);
if (d->name == newName) {
return;
}
d->name = newName;
setVolume(Platform::loadVolume(newName));
#ifndef QT_NO_DBUS
emit d->adaptor->nameChanged(newName);
#endif
}
static const qreal LOUDNESS_TO_VOLTAGE_EXPONENT = qreal(0.67);
static const qreal VOLTAGE_TO_LOUDNESS_EXPONENT = qreal(1.0/LOUDNESS_TO_VOLTAGE_EXPONENT);
void AudioOutput::setVolume(qreal volume)
{
K_D(AudioOutput);
d->volume = volume;
if (k_ptr->backendObject() && !d->muted) {
// using Stevens' power law loudness is proportional to (sound pressure)^0.67
// sound pressure is proportional to voltage:
// p² \prop P \prop V²
// => if a factor for loudness of x is requested
INTERFACE_CALL(setVolume(pow(volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
} else {
emit volumeChanged(volume);
}
Platform::saveVolume(d->name, volume);
}
qreal AudioOutput::volume() const
{
K_D(const AudioOutput);
if (d->muted || !d->m_backendObject) {
return d->volume;
}
return pow(INTERFACE_CALL(volume()), LOUDNESS_TO_VOLTAGE_EXPONENT);
}
#ifndef PHONON_LOG10OVER20
#define PHONON_LOG10OVER20
static const qreal log10over20 = qreal(0.1151292546497022842); // ln(10) / 20
#endif // PHONON_LOG10OVER20
qreal AudioOutput::volumeDecibel() const
{
K_D(const AudioOutput);
if (d->muted || !d->m_backendObject) {
return log(d->volume) / log10over20;
}
return 0.67 * log(INTERFACE_CALL(volume())) / log10over20;
}
void AudioOutput::setVolumeDecibel(qreal newVolumeDecibel)
{
setVolume(exp(newVolumeDecibel * log10over20));
}
bool AudioOutput::isMuted() const
{
K_D(const AudioOutput);
return d->muted;
}
void AudioOutput::setMuted(bool mute)
{
K_D(AudioOutput);
if (d->muted != mute) {
if (mute) {
d->muted = mute;
if (k_ptr->backendObject()) {
INTERFACE_CALL(setVolume(0.0));
}
} else {
if (k_ptr->backendObject()) {
INTERFACE_CALL(setVolume(pow(d->volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
}
d->muted = mute;
}
emit mutedChanged(mute);
}
}
Category AudioOutput::category() const
{
K_D(const AudioOutput);
return d->category;
}
AudioOutputDevice AudioOutput::outputDevice() const
{
K_D(const AudioOutput);
return d->device;
}
bool AudioOutput::setOutputDevice(const AudioOutputDevice &newAudioOutputDevice)
{
K_D(AudioOutput);
if (!newAudioOutputDevice.isValid()) {
d->outputDeviceOverridden = false;
const int newIndex = GlobalConfig().audioOutputDeviceFor(d->category);
if (newIndex == d->device.index()) {
return true;
}
d->device = AudioOutputDevice::fromIndex(newIndex);
} else {
d->outputDeviceOverridden = true;
if (d->device == newAudioOutputDevice) {
return true;
}
d->device = newAudioOutputDevice;
}
if (k_ptr->backendObject()) {
return callSetOutputDevice(k_ptr, d->device.index());
}
return true;
}
bool AudioOutputPrivate::aboutToDeleteBackendObject()
{
if (m_backendObject) {
volume = pINTERFACE_CALL(volume());
}
return AbstractAudioOutputPrivate::aboutToDeleteBackendObject();
}
void AudioOutputPrivate::setupBackendObject()
{
Q_Q(AudioOutput);
Q_ASSERT(m_backendObject);
AbstractAudioOutputPrivate::setupBackendObject();
QObject::connect(m_backendObject, SIGNAL(volumeChanged(qreal)), q, SLOT(_k_volumeChanged(qreal)));
QObject::connect(m_backendObject, SIGNAL(audioDeviceFailed()), q, SLOT(_k_audioDeviceFailed()));
// set up attributes
pINTERFACE_CALL(setVolume(pow(volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
// if the output device is not available and the device was not explicitly set
if (!callSetOutputDevice(this, device) && !outputDeviceOverridden) {
// fall back in the preference list of output devices
QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices);
if (deviceList.isEmpty()) {
return;
}
foreach (int devIndex, deviceList) {
const AudioOutputDevice &dev = AudioOutputDevice::fromIndex(devIndex);
if (callSetOutputDevice(this, dev)) {
handleAutomaticDeviceChange(dev, AudioOutputPrivate::FallbackChange);
return; // found one that works
}
}
// if we get here there is no working output device. Tell the backend.
const AudioOutputDevice none;
callSetOutputDevice(this, none);
handleAutomaticDeviceChange(none, FallbackChange);
}
}
void AudioOutputPrivate::_k_volumeChanged(qreal newVolume)
{
if (!muted) {
Q_Q(AudioOutput);
emit q->volumeChanged(pow(newVolume, qreal(0.67)));
}
}
void AudioOutputPrivate::_k_revertFallback()
{
if (deviceBeforeFallback == -1) {
return;
}
device = AudioOutputDevice::fromIndex(deviceBeforeFallback);
callSetOutputDevice(this, device);
Q_Q(AudioOutput);
emit q->outputDeviceChanged(device);
#ifndef QT_NO_DBUS
emit adaptor->outputDeviceIndexChanged(device.index());
#endif
}
void AudioOutputPrivate::_k_audioDeviceFailed()
{
pDebug() << Q_FUNC_INFO;
// outputDeviceIndex identifies a failing device
// fall back in the preference list of output devices
QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices);
foreach (int devIndex, deviceList) {
// if it's the same device as the one that failed, ignore it
if (device.index() != devIndex) {
const AudioOutputDevice &info = AudioOutputDevice::fromIndex(devIndex);
if (callSetOutputDevice(this, info)) {
handleAutomaticDeviceChange(info, FallbackChange);
return; // found one that works
}
}
}
// if we get here there is no working output device. Tell the backend.
const AudioOutputDevice none;
callSetOutputDevice(this, none);
handleAutomaticDeviceChange(none, FallbackChange);
}
void AudioOutputPrivate::_k_deviceListChanged()
{
pDebug() << Q_FUNC_INFO;
// let's see if there's a usable device higher in the preference list
QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings);
DeviceChangeType changeType = HigherPreferenceChange;
foreach (int devIndex, deviceList) {
const AudioOutputDevice &info = AudioOutputDevice::fromIndex(devIndex);
if (!info.property("available").toBool()) {
if (device.index() == devIndex) {
// we've reached the currently used device and it's not available anymore, so we
// fallback to the next available device
changeType = FallbackChange;
}
pDebug() << devIndex << "is not available";
continue;
}
pDebug() << devIndex << "is available";
if (device.index() == devIndex) {
// we've reached the currently used device, nothing to change
break;
}
if (callSetOutputDevice(this, info)) {
handleAutomaticDeviceChange(info, changeType);
break; // found one with higher preference that works
}
}
}
static struct
{
int first;
int second;
} g_lastFallback = { 0, 0 };
void AudioOutputPrivate::handleAutomaticDeviceChange(const AudioOutputDevice &device2, DeviceChangeType type)
{
Q_Q(AudioOutput);
deviceBeforeFallback = device.index();
device = device2;
emit q->outputDeviceChanged(device2);
#ifndef QT_NO_DBUS
emit adaptor->outputDeviceIndexChanged(device.index());
#endif
const AudioOutputDevice &device1 = AudioOutputDevice::fromIndex(deviceBeforeFallback);
switch (type) {
case FallbackChange:
if (g_lastFallback.first != device1.index() || g_lastFallback.second != device2.index()) {
#ifndef QT_NO_PHONON_PLATFORMPLUGIN
const QString &text = //device2.isValid() ?
AudioOutput::tr("<html>The audio playback device <b>%1</b> does not work.<br/>"
"Falling back to <b>%2</b>.</html>").arg(device1.name()).arg(device2.name()) /*:
AudioOutput::tr("<html>The audio playback device <b>%1</b> does not work.<br/>"
"No other device available.</html>").arg(device1.name())*/;
Platform::notification("AudioDeviceFallback", text);
#endif //QT_NO_PHONON_PLATFORMPLUGIN
g_lastFallback.first = device1.index();
g_lastFallback.second = device2.index();
}
break;
case HigherPreferenceChange:
{
#ifndef QT_NO_PHONON_PLATFORMPLUGIN
const QString text = AudioOutput::tr("<html>Switching to the audio playback device <b>%1</b><br/>"
"which just became available and has higher preference.</html>").arg(device2.name());
Platform::notification("AudioDeviceFallback", text,
QStringList(AudioOutput::tr("Revert back to device '%1'").arg(device1.name())),
q, SLOT(_k_revertFallback()));
#endif //QT_NO_PHONON_PLATFORMPLUGIN
g_lastFallback.first = 0;
g_lastFallback.second = 0;
}
break;
}
}
AudioOutputPrivate::~AudioOutputPrivate()
{
#ifndef QT_NO_DBUS
emit adaptor->outputDestroyed();
#endif
}
} //namespace Phonon
QT_END_NAMESPACE
#include "moc_audiooutput.cpp"
#undef PHONON_CLASSNAME
#undef PHONON_INTERFACENAME
#undef IFACES2
#undef IFACES1
#undef IFACES0
<commit_msg>Fixes: Crash in Amarok<commit_after>/* This file is part of the KDE project
Copyright (C) 2005-2006 Matthias Kretz <[email protected]>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) version 3, or any
later version accepted by the membership of KDE e.V. (or its
successor approved by the membership of KDE e.V.), Trolltech ASA
(or its successors, if any) and the KDE Free Qt Foundation, which shall
act as a proxy defined in Section 6 of version 3 of the license.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "audiooutput.h"
#include "audiooutput_p.h"
#include "factory_p.h"
#include "objectdescription.h"
#include "audiooutputadaptor_p.h"
#include "globalconfig_p.h"
#include "audiooutputinterface.h"
#include "phononnamespace_p.h"
#include "platform_p.h"
#include <qmath.h>
#define PHONON_CLASSNAME AudioOutput
#define IFACES2 AudioOutputInterface42
#define IFACES1 IFACES2
#define IFACES0 AudioOutputInterface40, IFACES1
#define PHONON_INTERFACENAME IFACES0
QT_BEGIN_NAMESPACE
namespace Phonon
{
static inline bool callSetOutputDevice(MediaNodePrivate *const d, int index)
{
Iface<IFACES2> iface(d);
if (iface) {
return iface->setOutputDevice(AudioOutputDevice::fromIndex(index));
}
return Iface<IFACES0>::cast(d)->setOutputDevice(index);
}
static inline bool callSetOutputDevice(MediaNodePrivate *const d, const AudioOutputDevice &dev)
{
Iface<IFACES2> iface(d);
if (iface) {
return iface->setOutputDevice(dev);
}
return Iface<IFACES0>::cast(d)->setOutputDevice(dev.index());
}
AudioOutput::AudioOutput(Phonon::Category category, QObject *parent)
: AbstractAudioOutput(*new AudioOutputPrivate, parent)
{
K_D(AudioOutput);
d->init(category);
}
AudioOutput::AudioOutput(QObject *parent)
: AbstractAudioOutput(*new AudioOutputPrivate, parent)
{
K_D(AudioOutput);
d->init(NoCategory);
}
void AudioOutputPrivate::init(Phonon::Category c)
{
Q_Q(AudioOutput);
#ifndef QT_NO_DBUS
adaptor = new AudioOutputAdaptor(q);
static unsigned int number = 0;
const QString &path = QLatin1String("/AudioOutputs/") + QString::number(number++);
QDBusConnection con = QDBusConnection::sessionBus();
con.registerObject(path, q);
emit adaptor->newOutputAvailable(con.baseService(), path);
q->connect(q, SIGNAL(volumeChanged(qreal)), adaptor, SIGNAL(volumeChanged(qreal)));
q->connect(q, SIGNAL(mutedChanged(bool)), adaptor, SIGNAL(mutedChanged(bool)));
#endif
category = c;
// select hardware device according to the category
device = AudioOutputDevice::fromIndex(GlobalConfig().audioOutputDeviceFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices));
createBackendObject();
q->connect(Factory::sender(), SIGNAL(availableAudioOutputDevicesChanged()), SLOT(_k_deviceListChanged()));
}
void AudioOutputPrivate::createBackendObject()
{
if (m_backendObject)
return;
Q_Q(AudioOutput);
m_backendObject = Factory::createAudioOutput(q);
if (m_backendObject) {
setupBackendObject();
}
}
QString AudioOutput::name() const
{
K_D(const AudioOutput);
return d->name;
}
void AudioOutput::setName(const QString &newName)
{
K_D(AudioOutput);
if (d->name == newName) {
return;
}
d->name = newName;
setVolume(Platform::loadVolume(newName));
#ifndef QT_NO_DBUS
emit d->adaptor->nameChanged(newName);
#endif
}
static const qreal LOUDNESS_TO_VOLTAGE_EXPONENT = qreal(0.67);
static const qreal VOLTAGE_TO_LOUDNESS_EXPONENT = qreal(1.0/LOUDNESS_TO_VOLTAGE_EXPONENT);
void AudioOutput::setVolume(qreal volume)
{
K_D(AudioOutput);
d->volume = volume;
if (k_ptr->backendObject() && !d->muted) {
// using Stevens' power law loudness is proportional to (sound pressure)^0.67
// sound pressure is proportional to voltage:
// p² \prop P \prop V²
// => if a factor for loudness of x is requested
INTERFACE_CALL(setVolume(pow(volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
} else {
emit volumeChanged(volume);
}
Platform::saveVolume(d->name, volume);
}
qreal AudioOutput::volume() const
{
K_D(const AudioOutput);
if (d->muted || !d->m_backendObject) {
return d->volume;
}
return pow(INTERFACE_CALL(volume()), LOUDNESS_TO_VOLTAGE_EXPONENT);
}
#ifndef PHONON_LOG10OVER20
#define PHONON_LOG10OVER20
static const qreal log10over20 = qreal(0.1151292546497022842); // ln(10) / 20
#endif // PHONON_LOG10OVER20
qreal AudioOutput::volumeDecibel() const
{
K_D(const AudioOutput);
if (d->muted || !d->m_backendObject) {
return log(d->volume) / log10over20;
}
return 0.67 * log(INTERFACE_CALL(volume())) / log10over20;
}
void AudioOutput::setVolumeDecibel(qreal newVolumeDecibel)
{
setVolume(exp(newVolumeDecibel * log10over20));
}
bool AudioOutput::isMuted() const
{
K_D(const AudioOutput);
return d->muted;
}
void AudioOutput::setMuted(bool mute)
{
K_D(AudioOutput);
if (d->muted != mute) {
if (mute) {
d->muted = mute;
if (k_ptr->backendObject()) {
INTERFACE_CALL(setVolume(0.0));
}
} else {
if (k_ptr->backendObject()) {
INTERFACE_CALL(setVolume(pow(d->volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
}
d->muted = mute;
}
emit mutedChanged(mute);
}
}
Category AudioOutput::category() const
{
K_D(const AudioOutput);
return d->category;
}
AudioOutputDevice AudioOutput::outputDevice() const
{
K_D(const AudioOutput);
return d->device;
}
bool AudioOutput::setOutputDevice(const AudioOutputDevice &newAudioOutputDevice)
{
K_D(AudioOutput);
if (!newAudioOutputDevice.isValid()) {
d->outputDeviceOverridden = false;
const int newIndex = GlobalConfig().audioOutputDeviceFor(d->category);
if (newIndex == d->device.index()) {
return true;
}
d->device = AudioOutputDevice::fromIndex(newIndex);
} else {
d->outputDeviceOverridden = true;
if (d->device == newAudioOutputDevice) {
return true;
}
d->device = newAudioOutputDevice;
}
if (k_ptr->backendObject()) {
return callSetOutputDevice(k_ptr, d->device.index());
}
return true;
}
bool AudioOutputPrivate::aboutToDeleteBackendObject()
{
if (m_backendObject) {
volume = pINTERFACE_CALL(volume());
}
return AbstractAudioOutputPrivate::aboutToDeleteBackendObject();
}
void AudioOutputPrivate::setupBackendObject()
{
Q_Q(AudioOutput);
Q_ASSERT(m_backendObject);
AbstractAudioOutputPrivate::setupBackendObject();
QObject::connect(m_backendObject, SIGNAL(volumeChanged(qreal)), q, SLOT(_k_volumeChanged(qreal)));
QObject::connect(m_backendObject, SIGNAL(audioDeviceFailed()), q, SLOT(_k_audioDeviceFailed()));
// set up attributes
pINTERFACE_CALL(setVolume(pow(volume, VOLTAGE_TO_LOUDNESS_EXPONENT)));
// if the output device is not available and the device was not explicitly set
if (!callSetOutputDevice(this, device) && !outputDeviceOverridden) {
// fall back in the preference list of output devices
QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices);
if (deviceList.isEmpty()) {
return;
}
foreach (int devIndex, deviceList) {
const AudioOutputDevice &dev = AudioOutputDevice::fromIndex(devIndex);
if (callSetOutputDevice(this, dev)) {
handleAutomaticDeviceChange(dev, AudioOutputPrivate::FallbackChange);
return; // found one that works
}
}
// if we get here there is no working output device. Tell the backend.
const AudioOutputDevice none;
callSetOutputDevice(this, none);
handleAutomaticDeviceChange(none, FallbackChange);
}
}
void AudioOutputPrivate::_k_volumeChanged(qreal newVolume)
{
if (!muted) {
Q_Q(AudioOutput);
emit q->volumeChanged(pow(newVolume, qreal(0.67)));
}
}
void AudioOutputPrivate::_k_revertFallback()
{
if (deviceBeforeFallback == -1) {
return;
}
device = AudioOutputDevice::fromIndex(deviceBeforeFallback);
callSetOutputDevice(this, device);
Q_Q(AudioOutput);
emit q->outputDeviceChanged(device);
#ifndef QT_NO_DBUS
emit adaptor->outputDeviceIndexChanged(device.index());
#endif
}
void AudioOutputPrivate::_k_audioDeviceFailed()
{
pDebug() << Q_FUNC_INFO;
// outputDeviceIndex identifies a failing device
// fall back in the preference list of output devices
QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings | GlobalConfig::HideUnavailableDevices);
foreach (int devIndex, deviceList) {
// if it's the same device as the one that failed, ignore it
if (device.index() != devIndex) {
const AudioOutputDevice &info = AudioOutputDevice::fromIndex(devIndex);
if (callSetOutputDevice(this, info)) {
handleAutomaticDeviceChange(info, FallbackChange);
return; // found one that works
}
}
}
// if we get here there is no working output device. Tell the backend.
const AudioOutputDevice none;
callSetOutputDevice(this, none);
handleAutomaticDeviceChange(none, FallbackChange);
}
void AudioOutputPrivate::_k_deviceListChanged()
{
pDebug() << Q_FUNC_INFO;
// let's see if there's a usable device higher in the preference list
QList<int> deviceList = GlobalConfig().audioOutputDeviceListFor(category, GlobalConfig::AdvancedDevicesFromSettings);
DeviceChangeType changeType = HigherPreferenceChange;
foreach (int devIndex, deviceList) {
const AudioOutputDevice &info = AudioOutputDevice::fromIndex(devIndex);
if (!info.property("available").toBool()) {
if (device.index() == devIndex) {
// we've reached the currently used device and it's not available anymore, so we
// fallback to the next available device
changeType = FallbackChange;
}
pDebug() << devIndex << "is not available";
continue;
}
pDebug() << devIndex << "is available";
if (device.index() == devIndex) {
// we've reached the currently used device, nothing to change
break;
}
if (callSetOutputDevice(this, info)) {
handleAutomaticDeviceChange(info, changeType);
break; // found one with higher preference that works
}
}
}
static struct
{
int first;
int second;
} g_lastFallback = { 0, 0 };
void AudioOutputPrivate::handleAutomaticDeviceChange(const AudioOutputDevice &device2, DeviceChangeType type)
{
Q_Q(AudioOutput);
deviceBeforeFallback = device.index();
device = device2;
emit q->outputDeviceChanged(device2);
#ifndef QT_NO_DBUS
emit adaptor->outputDeviceIndexChanged(device.index());
#endif
const AudioOutputDevice &device1 = AudioOutputDevice::fromIndex(deviceBeforeFallback);
switch (type) {
case FallbackChange:
if (g_lastFallback.first != device1.index() || g_lastFallback.second != device2.index()) {
#ifndef QT_NO_PHONON_PLATFORMPLUGIN
const QString &text = //device2.isValid() ?
AudioOutput::tr("<html>The audio playback device <b>%1</b> does not work.<br/>"
"Falling back to <b>%2</b>.</html>").arg(device1.name()).arg(device2.name()) /*:
AudioOutput::tr("<html>The audio playback device <b>%1</b> does not work.<br/>"
"No other device available.</html>").arg(device1.name())*/;
Platform::notification("AudioDeviceFallback", text);
#endif //QT_NO_PHONON_PLATFORMPLUGIN
g_lastFallback.first = device1.index();
g_lastFallback.second = device2.index();
}
break;
case HigherPreferenceChange:
{
#ifndef QT_NO_PHONON_PLATFORMPLUGIN
const QString text = AudioOutput::tr("<html>Switching to the audio playback device <b>%1</b><br/>"
"which just became available and has higher preference.</html>").arg(device2.name());
Platform::notification("AudioDeviceFallback", text,
QStringList(AudioOutput::tr("Revert back to device '%1'").arg(device1.name())),
q, SLOT(_k_revertFallback()));
#endif //QT_NO_PHONON_PLATFORMPLUGIN
g_lastFallback.first = 0;
g_lastFallback.second = 0;
}
break;
}
}
AudioOutputPrivate::~AudioOutputPrivate()
{
#ifndef QT_NO_DBUS
emit adaptor->outputDestroyed();
#endif
}
} //namespace Phonon
QT_END_NAMESPACE
#include "moc_audiooutput.cpp"
#undef PHONON_CLASSNAME
#undef PHONON_INTERFACENAME
#undef IFACES2
#undef IFACES1
#undef IFACES0
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: deferredview.hxx,v $
*
* $Revision: 1.3 $
*
* last change: $Author: rt $ $Date: 2005-09-08 04:28:45 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef CONFIGMGR_DEFERREDVIEW_HXX_
#define CONFIGMGR_DEFERREDVIEW_HXX_
#ifndef CONFIGMGR_VIEWBEHAVIOR_HXX_
#include "viewstrategy.hxx"
#endif
namespace configmgr
{
namespace view
{
//-----------------------------------------------------------------------------
// View behavior for direct data access
//-----------------------------------------------------------------------------
class DeferredViewStrategy : public ViewStrategy
{
memory::Segment const * m_pSegment;
public:
explicit
DeferredViewStrategy(memory::Segment const * _pSegment)
: m_pSegment(_pSegment)
{}
// ViewStrategy implementation
private:
// change handling -required
virtual bool doHasChanges(Node const& _aNode) const;
virtual void doMarkChanged(Node const& _aNode);
// change handling
virtual void doCollectChanges(Node const& _aNode, configuration::NodeChanges& rChanges) const;
// commit protocol
virtual std::auto_ptr<SubtreeChange> doPreCommitChanges(Tree const& _aTree, configuration::ElementList& _rRemovedElements);
virtual void doFailedCommit(Tree const& _aTree, SubtreeChange& rChanges);
virtual void doFinishCommit(Tree const& _aTree, SubtreeChange& rChanges);
virtual void doRevertCommit(Tree const& _aTree, SubtreeChange& rChanges);
// notification protocol
virtual configuration::ValueChangeImpl* doAdjustToValueChange(GroupNode const& _aGroupNode, Name const& aName, ValueChange const& rExternalChange);
// virtual void doAdjustToElementChanges(configuration::NodeChangesInformation& rLocalChanges, SetNode const& _aNode, SubtreeChange const& rExternalChanges, TreeDepth nDepth);
// common attributes
virtual node::Attributes doAdjustAttributes(node::Attributes const& _aAttributes) const;
// group member access
virtual configuration::ValueMemberNode doGetValueMember(GroupNode const& _aNode, Name const& _aName, bool _bForUpdate) const;
// set element access
virtual void doInsertElement(SetNode const& _aNode, Name const& aName, configuration::SetEntry const& aNewEntry);
virtual void doRemoveElement(SetNode const& _aNode, Name const& aName);
virtual void doReleaseDataSegment() { m_pSegment = NULL; }
virtual memory::Segment const * doGetDataSegment() const { return m_pSegment; }
virtual NodeFactory& doGetNodeFactory();
private:
void implCollectChangesIn(Node const& _aNode, NodeChanges& rChanges) const;
// commit protocol
std::auto_ptr<SubtreeChange> implPreCommitChanges(Node const& _aNode, configuration::ElementList& _rRemovedElements);
void implFailedCommit(Node const& _aNode, SubtreeChange& rChanges);
void implFinishCommit(Node const& _aNode, SubtreeChange& rChanges);
void implRevertCommit(Node const& _aNode, SubtreeChange& rChanges);
void implPreCommitSubChanges(GroupNode const & _aGroup, configuration::ElementList& _rRemovedElements, SubtreeChange& _rParentChange);
void implFailedSubCommitted(GroupNode const & _aGroup, SubtreeChange& rChanges);
void implFinishSubCommitted(GroupNode const & _aGroup, SubtreeChange& rChanges);
void implRevertSubCommitted(GroupNode const & _aGroup, SubtreeChange& rChanges);
};
//-----------------------------------------------------------------------------
}
}
#endif // CONFIGMGR_DEFERREDVIEW_HXX_
<commit_msg>INTEGRATION: CWS configrefactor01 (1.3.84); FILE MERGED 2007/01/16 12:18:25 mmeeks 1.3.84.1: Submitted by: mmeeks Kill 'memory::Segment' - no longer needed. Bin some other (empty / redundant) headers.<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: deferredview.hxx,v $
*
* $Revision: 1.4 $
*
* last change: $Author: ihi $ $Date: 2007-11-23 14:41:40 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef CONFIGMGR_DEFERREDVIEW_HXX_
#define CONFIGMGR_DEFERREDVIEW_HXX_
#ifndef CONFIGMGR_VIEWBEHAVIOR_HXX_
#include "viewstrategy.hxx"
#endif
namespace configmgr
{
namespace view
{
//-----------------------------------------------------------------------------
// View behavior for direct data access
//-----------------------------------------------------------------------------
class DeferredViewStrategy : public ViewStrategy
{
public:
explicit
DeferredViewStrategy() {}
// ViewStrategy implementation
private:
// change handling -required
virtual bool doHasChanges(Node const& _aNode) const;
virtual void doMarkChanged(Node const& _aNode);
// change handling
virtual void doCollectChanges(Node const& _aNode, configuration::NodeChanges& rChanges) const;
// commit protocol
virtual std::auto_ptr<SubtreeChange> doPreCommitChanges(Tree const& _aTree, configuration::ElementList& _rRemovedElements);
virtual void doFailedCommit(Tree const& _aTree, SubtreeChange& rChanges);
virtual void doFinishCommit(Tree const& _aTree, SubtreeChange& rChanges);
virtual void doRevertCommit(Tree const& _aTree, SubtreeChange& rChanges);
// notification protocol
virtual configuration::ValueChangeImpl* doAdjustToValueChange(GroupNode const& _aGroupNode, Name const& aName, ValueChange const& rExternalChange);
// virtual void doAdjustToElementChanges(configuration::NodeChangesInformation& rLocalChanges, SetNode const& _aNode, SubtreeChange const& rExternalChanges, TreeDepth nDepth);
// common attributes
virtual node::Attributes doAdjustAttributes(node::Attributes const& _aAttributes) const;
// group member access
virtual configuration::ValueMemberNode doGetValueMember(GroupNode const& _aNode, Name const& _aName, bool _bForUpdate) const;
// set element access
virtual void doInsertElement(SetNode const& _aNode, Name const& aName, configuration::SetEntry const& aNewEntry);
virtual void doRemoveElement(SetNode const& _aNode, Name const& aName);
virtual NodeFactory& doGetNodeFactory();
private:
void implCollectChangesIn(Node const& _aNode, NodeChanges& rChanges) const;
// commit protocol
std::auto_ptr<SubtreeChange> implPreCommitChanges(Node const& _aNode, configuration::ElementList& _rRemovedElements);
void implFailedCommit(Node const& _aNode, SubtreeChange& rChanges);
void implFinishCommit(Node const& _aNode, SubtreeChange& rChanges);
void implRevertCommit(Node const& _aNode, SubtreeChange& rChanges);
void implPreCommitSubChanges(GroupNode const & _aGroup, configuration::ElementList& _rRemovedElements, SubtreeChange& _rParentChange);
void implFailedSubCommitted(GroupNode const & _aGroup, SubtreeChange& rChanges);
void implFinishSubCommitted(GroupNode const & _aGroup, SubtreeChange& rChanges);
void implRevertSubCommitted(GroupNode const & _aGroup, SubtreeChange& rChanges);
};
//-----------------------------------------------------------------------------
}
}
#endif // CONFIGMGR_DEFERREDVIEW_HXX_
<|endoftext|> |
<commit_before>// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/defaults.h>
#include <iostream>
#include <lib/modelinspect.h>
#include <vespa/vespalib/text/stringtokenizer.h>
#include <vespa/fastos/app.h>
#include <vespa/log/log.h>
LOG_SETUP("vespa-model-inspect");
class Application : public FastOS_Application
{
ModelInspect::Flags _flags;
vespalib::string _cfgId;
vespalib::string _specString;
int parseOpts();
vespalib::string getSources();
config::ConfigUri getConfigUri();
public:
void usage();
int Main() override;
Application();
~Application();
};
Application::Application() : _flags(), _cfgId("admin/model"), _specString("") {}
Application::~Application() { }
int
Application::parseOpts()
{
char c = '?';
const char *optArg = NULL;
int optInd = 0;
while ((c = GetOpt("hvut:c:C:", optArg, optInd)) != -1) {
switch (c) {
case 'v':
_flags.verbose = true;
break;
case 'u':
_flags.makeuri = true;
break;
case 't':
_flags.tagFilter.push_back(optArg);
_flags.tagfilt = true;
break;
case 'C':
_cfgId = optArg;
break;
case 'c':
_specString = optArg;
break;
case 'h':
return _argc;
default:
usage();
exit(1);
}
}
if (_specString.empty()) {
_specString = getSources();
}
return optInd;
}
vespalib::string
Application::getSources()
{
vespalib::string specs;
for (std::string v : vespa::Defaults::vespaConfigSourcesRpcAddrs()) {
if (! specs.empty()) specs += ",";
specs += v;
}
return specs;
}
config::ConfigUri
Application::getConfigUri()
{
try {
return config::ConfigUri::createFromSpec(_cfgId, config::ServerSpec(_specString));
}
catch (std::exception &e) {
LOG(fatal, "Failed to set up model configuration source, will exit: %s", e.what());
exit(1);
}
}
void
Application::usage()
{
std::cerr <<
"vespa-model-inspect version 2.0" << std::endl <<
"Usage: " << _argv[0] << " [options] <command> <options>" << std::endl <<
"options: [-u] for URLs, [-v] for verbose" << std::endl <<
" [-c host] or [-c host:port] to specify server" << std::endl <<
" [-t tag] to filter on a port tag" << std::endl <<
"Where command is:" << std::endl <<
" hosts - show all hosts" << std::endl <<
" services - show all services" << std::endl <<
" clusters - show all cluster names" << std::endl <<
" configids - show all config IDs" << std::endl <<
" filter:ports - list ports matching filter options" << std::endl <<
" host <hostname> - show services on a given host" << std::endl <<
" service [cluster:]<servicetype>" <<
" - show all instances of a given servicetype" << std::endl <<
" cluster <clustername>" <<
" - show all services associated with the cluster" << std::endl <<
" configid <configid>" <<
" - show service using configid" << std::endl <<
" get-index-of <servicetype> <host>" <<
" - show all indexes for instances of the servicetype on the host" << std::endl <<
std::endl;
}
int
Application::Main()
{
int cnt = parseOpts();
if (_argc == cnt) {
usage();
return 0;
}
config::ConfigUri uri = getConfigUri();
ModelInspect model(_flags, uri, std::cout);
return model.action(_argc - cnt, &_argv[cnt]);
}
int
main(int argc, char** argv)
{
vespa::Defaults::bootstrap(argv[0]);
Application app;
return app.Entry(argc, argv);
}
<commit_msg>Revert "Use LOG instead of cerr"<commit_after>// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/defaults.h>
#include <iostream>
#include <lib/modelinspect.h>
#include <vespa/vespalib/text/stringtokenizer.h>
#include <vespa/fastos/app.h>
#include <vespa/log/log.h>
LOG_SETUP("vespa-model-inspect");
class Application : public FastOS_Application
{
ModelInspect::Flags _flags;
vespalib::string _cfgId;
vespalib::string _specString;
int parseOpts();
vespalib::string getSources();
config::ConfigUri getConfigUri();
public:
void usage();
int Main() override;
Application();
~Application();
};
Application::Application() : _flags(), _cfgId("admin/model"), _specString("") {}
Application::~Application() { }
int
Application::parseOpts()
{
char c = '?';
const char *optArg = NULL;
int optInd = 0;
while ((c = GetOpt("hvut:c:C:", optArg, optInd)) != -1) {
switch (c) {
case 'v':
_flags.verbose = true;
break;
case 'u':
_flags.makeuri = true;
break;
case 't':
_flags.tagFilter.push_back(optArg);
_flags.tagfilt = true;
break;
case 'C':
_cfgId = optArg;
break;
case 'c':
_specString = optArg;
break;
case 'h':
return _argc;
default:
usage();
exit(1);
}
}
if (_specString.empty()) {
_specString = getSources();
}
return optInd;
}
vespalib::string
Application::getSources()
{
vespalib::string specs;
for (std::string v : vespa::Defaults::vespaConfigSourcesRpcAddrs()) {
if (! specs.empty()) specs += ",";
specs += v;
}
return specs;
}
config::ConfigUri
Application::getConfigUri()
{
try {
return config::ConfigUri::createFromSpec(_cfgId, config::ServerSpec(_specString));
}
catch (std::exception &e) {
std::cerr << "FATAL ERROR: failed to set up model configuration: " << e.what() << "\n";
exit(1);
}
}
void
Application::usage()
{
std::cerr <<
"vespa-model-inspect version 2.0" << std::endl <<
"Usage: " << _argv[0] << " [options] <command> <options>" << std::endl <<
"options: [-u] for URLs, [-v] for verbose" << std::endl <<
" [-c host] or [-c host:port] to specify server" << std::endl <<
" [-t tag] to filter on a port tag" << std::endl <<
"Where command is:" << std::endl <<
" hosts - show all hosts" << std::endl <<
" services - show all services" << std::endl <<
" clusters - show all cluster names" << std::endl <<
" configids - show all config IDs" << std::endl <<
" filter:ports - list ports matching filter options" << std::endl <<
" host <hostname> - show services on a given host" << std::endl <<
" service [cluster:]<servicetype>" <<
" - show all instances of a given servicetype" << std::endl <<
" cluster <clustername>" <<
" - show all services associated with the cluster" << std::endl <<
" configid <configid>" <<
" - show service using configid" << std::endl <<
" get-index-of <servicetype> <host>" <<
" - show all indexes for instances of the servicetype on the host" << std::endl <<
std::endl;
}
int
Application::Main()
{
int cnt = parseOpts();
if (_argc == cnt) {
usage();
return 0;
}
config::ConfigUri uri = getConfigUri();
ModelInspect model(_flags, uri, std::cout);
return model.action(_argc - cnt, &_argv[cnt]);
}
int
main(int argc, char** argv)
{
vespa::Defaults::bootstrap(argv[0]);
Application app;
return app.Entry(argc, argv);
}
<|endoftext|> |
<commit_before><commit_msg>wrong logic in comment<commit_after><|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: Clob.cxx,v $
*
* $Revision: 1.8 $
*
* last change: $Author: hr $ $Date: 2006-06-20 01:33:35 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _CONNECTIVITY_JAVA_SQL_CLOB_HXX_
#include "java/sql/Clob.hxx"
#endif
#ifndef _CONNECTIVITY_JAVA_TOOLS_HXX_
#include "java/tools.hxx"
#endif
#ifndef _CONNECTIVITY_JAVA_IO_READER_HXX_
#include "java/io/Reader.hxx"
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
using namespace connectivity;
//**************************************************************
//************ Class: java.sql.Clob
//**************************************************************
jclass java_sql_Clob::theClass = 0;
java_sql_Clob::java_sql_Clob( JNIEnv * pEnv, jobject myObj )
: java_lang_Object( pEnv, myObj )
{
SDBThreadAttach::addRef();
}
java_sql_Clob::~java_sql_Clob()
{
SDBThreadAttach::releaseRef();
}
jclass java_sql_Clob::getMyClass()
{
// die Klasse muss nur einmal geholt werden, daher statisch
if( !theClass ){
SDBThreadAttach t;
if( !t.pEnv ) return (jclass)NULL;
jclass tempClass = t.pEnv->FindClass( "java/sql/Clob" );
jclass globClass = (jclass)t.pEnv->NewGlobalRef( tempClass );
t.pEnv->DeleteLocalRef( tempClass );
saveClassRef( globClass );
}
return theClass;
}
void java_sql_Clob::saveClassRef( jclass pClass )
{
if( pClass==NULL )
return;
// der uebergebe Klassen-Handle ist schon global, daher einfach speichern
theClass = pClass;
}
sal_Int64 SAL_CALL java_sql_Clob::length( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
jlong out(0);
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
if( t.pEnv )
{
// temporaere Variable initialisieren
static const char * cSignature = "()J";
static const char * cMethodName = "length";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
out = t.pEnv->CallLongMethod( object, mID );
ThrowSQLException(t.pEnv,*this);
// und aufraeumen
} //mID
} //t.pEnv
return (sal_Int64)out;
}
::rtl::OUString SAL_CALL java_sql_Clob::getSubString( sal_Int64 pos, sal_Int32 subStringLength ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
::rtl::OUString aStr;
if( t.pEnv ){
// temporaere Variable initialisieren
static const char * cSignature = "(JI)Ljava/lang/String;";
static const char * cMethodName = "getSubString";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
jstring out = (jstring)t.pEnv->CallObjectMethod( object, mID,pos,subStringLength);
ThrowSQLException(t.pEnv,*this);
aStr = JavaString2String(t.pEnv,out);
// und aufraeumen
} //mID
} //t.pEnv
// ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
return aStr;
}
::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > SAL_CALL java_sql_Clob::getCharacterStream( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
jobject out(0);
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
if( t.pEnv ){
// temporaere Variable initialisieren
static const char * cSignature = "()Ljava/io/Reader;";
static const char * cMethodName = "getCharacterStream";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
out = t.pEnv->CallObjectMethod( object, mID);
ThrowSQLException(t.pEnv,*this);
} //mID
} //t.pEnv
// ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
return out==0 ? 0 : new java_io_Reader( t.pEnv, out );
}
sal_Int64 SAL_CALL java_sql_Clob::position( const ::rtl::OUString& searchstr, sal_Int32 start ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
jlong out(0);
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
if( t.pEnv )
{
jvalue args[1];
// Parameter konvertieren
args[0].l = convertwchar_tToJavaString(t.pEnv,searchstr);
// temporaere Variable initialisieren
static const char * cSignature = "(Ljava/lang/String;I)J";
static const char * cMethodName = "position";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
out = t.pEnv->CallLongMethod( object, mID, args[0].l,start );
ThrowSQLException(t.pEnv,*this);
t.pEnv->DeleteLocalRef((jstring)args[0].l);
// und aufraeumen
} //mID
} //t.pEnv
return (sal_Int64)out;
}
sal_Int64 SAL_CALL java_sql_Clob::positionOfClob( const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XClob >& /*pattern*/, sal_Int64 /*start*/ ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
::dbtools::throwFeatureNotImplementedException( "XClob::positionOfClob", *this );
// this was put here in CWS warnings01. The previous implementation was defective, as it did ignore
// the pattern parameter. Since the effort for proper implementation is rather high - we would need
// to translated patter into a byte[] -, we defer this functionality for the moment (hey, it was
// unusable, anyway)
// 2005-11-15 / #i57457# / [email protected]
return 0;
}
<commit_msg>INTEGRATION: CWS pchfix02 (1.8.60); FILE MERGED 2006/09/01 17:22:19 kaib 1.8.60.1: #i68856# Added header markers and pch files<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: Clob.cxx,v $
*
* $Revision: 1.9 $
*
* last change: $Author: obo $ $Date: 2006-09-17 02:45:13 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_connectivity.hxx"
#ifndef _CONNECTIVITY_JAVA_SQL_CLOB_HXX_
#include "java/sql/Clob.hxx"
#endif
#ifndef _CONNECTIVITY_JAVA_TOOLS_HXX_
#include "java/tools.hxx"
#endif
#ifndef _CONNECTIVITY_JAVA_IO_READER_HXX_
#include "java/io/Reader.hxx"
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
using namespace connectivity;
//**************************************************************
//************ Class: java.sql.Clob
//**************************************************************
jclass java_sql_Clob::theClass = 0;
java_sql_Clob::java_sql_Clob( JNIEnv * pEnv, jobject myObj )
: java_lang_Object( pEnv, myObj )
{
SDBThreadAttach::addRef();
}
java_sql_Clob::~java_sql_Clob()
{
SDBThreadAttach::releaseRef();
}
jclass java_sql_Clob::getMyClass()
{
// die Klasse muss nur einmal geholt werden, daher statisch
if( !theClass ){
SDBThreadAttach t;
if( !t.pEnv ) return (jclass)NULL;
jclass tempClass = t.pEnv->FindClass( "java/sql/Clob" );
jclass globClass = (jclass)t.pEnv->NewGlobalRef( tempClass );
t.pEnv->DeleteLocalRef( tempClass );
saveClassRef( globClass );
}
return theClass;
}
void java_sql_Clob::saveClassRef( jclass pClass )
{
if( pClass==NULL )
return;
// der uebergebe Klassen-Handle ist schon global, daher einfach speichern
theClass = pClass;
}
sal_Int64 SAL_CALL java_sql_Clob::length( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
jlong out(0);
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
if( t.pEnv )
{
// temporaere Variable initialisieren
static const char * cSignature = "()J";
static const char * cMethodName = "length";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
out = t.pEnv->CallLongMethod( object, mID );
ThrowSQLException(t.pEnv,*this);
// und aufraeumen
} //mID
} //t.pEnv
return (sal_Int64)out;
}
::rtl::OUString SAL_CALL java_sql_Clob::getSubString( sal_Int64 pos, sal_Int32 subStringLength ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
::rtl::OUString aStr;
if( t.pEnv ){
// temporaere Variable initialisieren
static const char * cSignature = "(JI)Ljava/lang/String;";
static const char * cMethodName = "getSubString";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
jstring out = (jstring)t.pEnv->CallObjectMethod( object, mID,pos,subStringLength);
ThrowSQLException(t.pEnv,*this);
aStr = JavaString2String(t.pEnv,out);
// und aufraeumen
} //mID
} //t.pEnv
// ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
return aStr;
}
::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream > SAL_CALL java_sql_Clob::getCharacterStream( ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
jobject out(0);
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
if( t.pEnv ){
// temporaere Variable initialisieren
static const char * cSignature = "()Ljava/io/Reader;";
static const char * cMethodName = "getCharacterStream";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
out = t.pEnv->CallObjectMethod( object, mID);
ThrowSQLException(t.pEnv,*this);
} //mID
} //t.pEnv
// ACHTUNG: der Aufrufer wird Eigentuemer des zurueckgelieferten Zeigers !!!
return out==0 ? 0 : new java_io_Reader( t.pEnv, out );
}
sal_Int64 SAL_CALL java_sql_Clob::position( const ::rtl::OUString& searchstr, sal_Int32 start ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
jlong out(0);
SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!");
if( t.pEnv )
{
jvalue args[1];
// Parameter konvertieren
args[0].l = convertwchar_tToJavaString(t.pEnv,searchstr);
// temporaere Variable initialisieren
static const char * cSignature = "(Ljava/lang/String;I)J";
static const char * cMethodName = "position";
// Java-Call absetzen
static jmethodID mID = NULL;
if ( !mID )
mID = t.pEnv->GetMethodID( getMyClass(), cMethodName, cSignature );OSL_ENSURE(mID,"Unknown method id!");
if( mID ){
out = t.pEnv->CallLongMethod( object, mID, args[0].l,start );
ThrowSQLException(t.pEnv,*this);
t.pEnv->DeleteLocalRef((jstring)args[0].l);
// und aufraeumen
} //mID
} //t.pEnv
return (sal_Int64)out;
}
sal_Int64 SAL_CALL java_sql_Clob::positionOfClob( const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XClob >& /*pattern*/, sal_Int64 /*start*/ ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException)
{
::dbtools::throwFeatureNotImplementedException( "XClob::positionOfClob", *this );
// this was put here in CWS warnings01. The previous implementation was defective, as it did ignore
// the pattern parameter. Since the effort for proper implementation is rather high - we would need
// to translated patter into a byte[] -, we defer this functionality for the moment (hey, it was
// unusable, anyway)
// 2005-11-15 / #i57457# / [email protected]
return 0;
}
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: ECatalog.hxx,v $
*
* $Revision: 1.2 $
*
* last change: $Author: rt $ $Date: 2005-09-08 07:11:11 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _CONNECTIVITY_FLAT_CATALOG_HXX_
#define _CONNECTIVITY_FLAT_CATALOG_HXX_
#ifndef _CONNECTIVITY_FILE_CATALOG_HXX_
#include "file/FCatalog.hxx"
#endif
namespace connectivity
{
namespace flat
{
class OFlatConnection;
class OFlatCatalog : public file::OFileCatalog
{
public:
virtual void refreshTables();
public:
OFlatCatalog(OFlatConnection* _pCon);
};
}
}
#endif // _CONNECTIVITY_FLAT_CATALOG_HXX_
<commit_msg>INTEGRATION: CWS changefileheader (1.2.372); FILE MERGED 2008/04/01 10:53:28 thb 1.2.372.2: #i85898# Stripping all external header guards 2008/03/28 15:24:21 rt 1.2.372.1: #i87441# Change license header to LPGL v3.<commit_after>/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: ECatalog.hxx,v $
* $Revision: 1.3 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef _CONNECTIVITY_FLAT_CATALOG_HXX_
#define _CONNECTIVITY_FLAT_CATALOG_HXX_
#include "file/FCatalog.hxx"
namespace connectivity
{
namespace flat
{
class OFlatConnection;
class OFlatCatalog : public file::OFileCatalog
{
public:
virtual void refreshTables();
public:
OFlatCatalog(OFlatConnection* _pCon);
};
}
}
#endif // _CONNECTIVITY_FLAT_CATALOG_HXX_
<|endoftext|> |
<commit_before>#include <string>
#include <vector>
#include "roaring.hh"
#ifndef JILL_QUERY_HEADER_INCLUDED
#define JILL_QUERY_HEADER_INCLUDED
using namespace std;
namespace jill {
namespace query {
enum FilterType {
EQUAL,
NOT_EQUAL
};
class Filter {
private:
string rval;
string lval;
FilterType op;
public:
Filter(string rval_, string lval, FilterType op_):
rval(rval_), lval(lval), op(op_) {}
};
class GroupBy {
string field;
};
class Aggeration {};
class PostAggregation {};
// QUERY RESULTS
class GroupByResult {
string key;
Roaring *bm;
};
class QueryResult {
private:
Roaring *filterResult;
GroupByResult groupByResult;
};
// / QUERY RESULTS
class Query {
private:
// filters
vector<Filter *> filters;
// groupings
vector<GroupBy> groupings;
// aggregations
vector<Aggeration> aggregations;
// post-aggregations
vector<PostAggregation> postAggregations;
// query result
QueryResult result;
public:
Query() {}
void addFilter(Filter *filter);
};
} // namespace query
} // namespace jill
#endif
<commit_msg>rename rval to field<commit_after>#include <string>
#include <vector>
#include "roaring.hh"
#ifndef JILL_QUERY_HEADER_INCLUDED
#define JILL_QUERY_HEADER_INCLUDED
using namespace std;
namespace jill {
namespace query {
enum FilterType {
EQUAL,
NOT_EQUAL
};
class Filter {
private:
string field;
string lval;
FilterType op;
public:
Filter(string field_, string lval, FilterType op_):
field(field_), lval(lval), op(op_) {}
};
class GroupBy {
string field;
};
class Aggeration {};
class PostAggregation {};
// QUERY RESULTS
class GroupByResult {
string key;
Roaring *bm;
};
class QueryResult {
private:
Roaring *filterResult;
GroupByResult groupByResult;
};
// / QUERY RESULTS
class Query {
private:
// filters
vector<Filter *> filters;
// groupings
vector<GroupBy> groupings;
// aggregations
vector<Aggeration> aggregations;
// post-aggregations
vector<PostAggregation> postAggregations;
// query result
QueryResult result;
public:
Query() {}
void addFilter(Filter *filter);
};
} // namespace query
} // namespace jill
#endif
<|endoftext|> |
<commit_before>#include "storage.hh"
#include "mp4file.hh"
#include "utility/reactor.hh"
#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <sstream>
#include <fstream>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
using namespace utility;
namespace fs = boost::filesystem;
namespace {
std::string manifest_name = "manifest.f4m";
std::string docroot = ".";
std::string basedir = ".";
std::string bootstrapinfo_name("bootstrap");
std::string fragments_dir("samples");
std::string video_id("some_video");
std::string srcfile;
}
void write16(std::streambuf& buf, uint16_t value) {
buf.sputc( (value >> 8) % 0xFF );
buf.sputc( value & 0xFF );
}
void write24(std::streambuf& buf, uint32_t value) {
buf.sputc( (value >> 16) % 0xFF );
buf.sputc( (value >> 8) % 0xFF );
buf.sputc( value & 0xFF );
}
void write32(std::streambuf& buf, uint32_t value) {
buf.sputc( (value >> 24) % 0xFF );
buf.sputc( (value >> 16) % 0xFF );
buf.sputc( (value >> 8) % 0xFF );
buf.sputc( value & 0xFF );
}
void write64(std::streambuf& buf, uint64_t value) {
buf.sputc( (value >> 56) % 0xFF );
buf.sputc( (value >> 48) % 0xFF );
buf.sputc( (value >> 40) % 0xFF );
buf.sputc( (value >> 32) % 0xFF );
buf.sputc( (value >> 24) % 0xFF );
buf.sputc( (value >> 16) % 0xFF );
buf.sputc( (value >> 8) % 0xFF );
buf.sputc( value & 0xFF );
}
void writebox(std::streambuf& buf, const char *name, const std::string& box) {
write32(buf, box.size() + 8);
buf.sputn(name, 4);
buf.sputn(box.c_str(), box.size());
}
void *mapping;
struct Fragment {
double _ts;
double _dur;
Fragment(unsigned ts, unsigned dur) : _ts(ts), _dur(dur) {}
};
void close_fragment(unsigned segment, unsigned fragment, const std::string& fragdata, std::vector<Fragment>& fragments, double ts, double duration) {
if ( fragdata.size() ) {
std::stringstream filename;
filename << docroot << '/' << basedir << '/' << fragments_dir << '/' << "Seg" << segment << "-Frag" << fragment;
size_t fragment_size = fragdata.size() + 8;
char prefix[8];
prefix[0] = (fragment_size >> 24) & 0xFF;
prefix[1] = (fragment_size >> 16) & 0xFF;
prefix[2] = (fragment_size >> 8) & 0xFF;
prefix[3] = fragment_size & 0xFF;
prefix[4] = 'm';
prefix[5] = 'd';
prefix[6] = 'a';
prefix[7] = 't';
std::ofstream out(filename.str().c_str());
std::cerr << filename.str() << std::endl;
assert (out);
out.write(prefix, 8);
out.write(fragdata.c_str(), fragdata.size());
out.close();
fragments.push_back(Fragment(ts, duration));
assert(duration != 0);
}
}
std::vector<Fragment> write_fragments(const ::boost::shared_ptr<mp4::Context>& ctx, double timelimit) {
unsigned segment = 1;
unsigned fragment = 1;
double limit_ts = timelimit;
double old_ts = 0;
double now;
unsigned nsample = 0;
std::vector<Fragment> fragments;
std::stringbuf sb;
if ( ctx->has_video() ) {
sb.sputc(9);
auto ve = ctx->videoextra();
write24(sb, ve.size() + 5);
write32(sb, 0);
write24(sb, 0);
sb.sputn("\x17\0\0\0\0", 5);
sb.sputn(ve.c_str(), ve.size());
write32(sb, ve.size() + 16);
}
if ( ctx->has_audio() ) {
sb.sputc(8);
auto ae = ctx->audioextra();
write24(sb, ae.size() + 2);
write32(sb, 0);
write24(sb, 0);
sb.sputn("\xaf\0", 2);
sb.sputn(ae.c_str(), ae.size());
write32(sb, ae.size() + 13);
}
while ( nsample < ctx->nsamples() ) {
std::cerr << "nsample=" << nsample << ", ";
mp4::SampleInfo *si = ctx->get_sample(nsample++);
now = si->timestamp();
std::cerr << "compos timestamp=" << now << "\n";
unsigned total = 11 + si->_sample_size;
if ( si->_video ) {
if ( si->_keyframe && now >= limit_ts ) {
std::cerr << "close: " << fragment << "\n";
close_fragment(segment, fragment++, sb.str(), fragments, old_ts, now - old_ts);
old_ts = now;
limit_ts = now + timelimit;
sb.str(std::string());
}
sb.sputc(9);
write24(sb, si->_sample_size + 5);
total += 5;
}
else {
sb.sputc(8);
write24(sb, si->_sample_size + 2);
total += 2;
}
unsigned uts = now * 1000;
write24(sb, uts); sb.sputc( (uts >> 24) & 0xff );
write24(sb, 0);
if ( si->_video ) {
if ( si->_keyframe ) {
sb.sputn("\x17\x1", 2);
}
else {
sb.sputn("\x27\x1", 2);
}
write24(sb, 0); // composition time offset
}
else {
sb.sputn("\xaf\x1", 2);
}
sb.sputn((char*)mapping + si->_offset, si->_sample_size);
write32(sb, total);
}
close_fragment(segment, fragment, sb.str(), fragments, now, ctx->duration() - now);
return fragments;
}
void ok(const ::boost::shared_ptr<mp4::Context>& ctx) {
std::cout << "ok.\n"; utility::reactor::stop();
std::cout << ctx->_samples.size() << " samples found.\n";
std::cout << "\nnsamples: " << ctx->nsamples()
<< "\nhas video: " << (ctx->has_video() ? "yes" : "no")
<< "\nhas audio: " << (ctx->has_audio() ? "yes" : "no")
<< "\nwidth: " << ctx->width()
<< "\nheight: " << ctx->height()
<< "\npwidth: " << ctx->pwidth()
<< "\npheight: " << ctx->pheight()
<< "\nbitrate: " << ctx->bitrate()
<< "\nduration: " << ctx->duration()
<< std::endl;
std::cout << "writing..." << std::endl;
std::vector<Fragment> fragments = write_fragments(ctx, 10);
std::stringbuf abst;
abst.sputc(0); // version
abst.sputn("\0\0", 3); // flags;
write32(abst, 14); // bootstrapinfoversion
abst.sputc(0); // profile, live, update
write32(abst, 1000); // timescale
write64(abst, ctx->duration() * 1000); // currentmediatime
write64(abst, 0); // smptetimecodeoffset
abst.sputc(0); // movieidentifier
abst.sputc(0); // serverentrycount
abst.sputc(0); // qualityentrycount
abst.sputc(0); // drmdata
abst.sputc(0); // metadata
abst.sputc(1); // segment run table count
std::stringbuf asrt;
asrt.sputc(0); // version
write24(asrt, 0); // flags
asrt.sputc(0); // qualityentrycount
write32(asrt, 1); // segmentrunentry count
write32(asrt, 1); // first segment
write32(asrt, fragments.size()); // fragments per segment
writebox(abst, "asrt", asrt.str());
abst.sputc(1); // fragment run table count
std::stringbuf afrt;
afrt.sputc(0); // version
write24(afrt, 0); // flags
write32(afrt, 1000); // timescale
afrt.sputc(0); // qualityentrycount
std::cerr << fragments.size() << " fragments\n";
write32(afrt, fragments.size()); // fragmentrunentrycount
for ( unsigned ifragment = 0; ifragment < fragments.size(); ++ifragment ) {
write32(afrt, ifragment + 1);
write64(afrt, uint64_t(fragments[ifragment]._ts * 1000));
write32(afrt, uint32_t(fragments[ifragment]._dur * 1000));
if ( fragments[ifragment]._dur == 0 ) {
assert ( ifragment == fragments.size() - 1 );
afrt.sputc(0);
}
}
writebox(abst, "afrt", afrt.str());
std::stringstream bootstrapname;
bootstrapname << docroot << '/' << basedir << '/' << bootstrapinfo_name;
std::string bootstrap_path = bootstrapname.str();
std::ofstream out(bootstrap_path.c_str());
assert ( out );
writebox(*out.rdbuf(), "abst", abst.str());
out.close();
std::stringstream manifestname;
manifestname << docroot << '/' << basedir << '/' << manifest_name;
std::ofstream manifest_out(manifestname.str().c_str());
manifest_out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<manifest xmlns=\"http://ns.adobe.com/f4m/1.0\">\n"
"<id>" << video_id << "</id>\n"
"<streamtype>recorded</streamtype>\n"
"<duration>" << ctx->duration() << "</duration>\n"
"<bootstrapinfo profile=\"named\" url=\"" << bootstrapinfo_name << """/>>\n"
"<media streamId=\"sample\" url=\"" << fragments_dir << '/' << """/>\n"
"</manifest>\n";
out.close();
}
void fail(const ::std::string& msg) {
std::cerr << "fail: " << msg << '\n'; utility::reactor::stop();
}
void parse_options(int argc, char **argv) {
namespace po = boost::program_options;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("src", po::value<std::string>(&srcfile), "source mp4 file name")
("docroot", po::value<std::string>(&docroot)->default_value("."), "docroot directory")
("basedir", po::value<std::string>(&basedir)->default_value("."), "base directory for manifest file")
("fragments", po::value<std::string>(&fragments_dir)->default_value("samples"), "directory for fragment files")
("video_id", po::value<std::string>(&video_id)->default_value("some_video"), "video id for manifest file")
("manifest", po::value<std::string>(&manifest_name)->default_value("manifest.f4m"), "manifest file name")
("bootstrapinfo", po::value<std::string>(&bootstrapinfo_name)->default_value("bootstrapinfo"), "bootstrapinfo file name")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help") || argc == 1 || srcfile.size() == 0) {
std::cerr << desc << "\n";
exit(1);
}
}
struct Callback : public mp4::ParseCallback {
::boost::shared_ptr<DataSource> src;
};
Callback ctx;
void run_parser(const std::string& filename) {
ctx._success = ok;
ctx._failure = fail;
ctx.src = get_source(filename);
mp4::a_parse_mp4(ctx.src, &ctx);
}
int main(int argc, char **argv) {
// reactor::set_timer(::boost::bind(run_parser, argv[1]), 1000);
parse_options(argc, argv);
struct stat st;
assert ( stat(srcfile.c_str(), &st) != -1 );
int fd = open(srcfile.c_str(), O_RDONLY);
mapping = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
assert ( mapping != (void*)(-1) );
run_parser(srcfile);
utility::reactor::run();
std::cerr << "That's all!\n";
}
<commit_msg>Исправлена опечатка в сериализации FLV.<commit_after>#include "storage.hh"
#include "mp4file.hh"
#include "utility/reactor.hh"
#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <sstream>
#include <fstream>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
using namespace utility;
namespace fs = boost::filesystem;
namespace {
std::string manifest_name = "manifest.f4m";
std::string docroot = ".";
std::string basedir = ".";
std::string bootstrapinfo_name("bootstrap");
std::string fragments_dir("samples");
std::string video_id("some_video");
std::string srcfile;
}
void write16(std::streambuf& buf, uint16_t value) {
buf.sputc( (value >> 8) & 0xFF );
buf.sputc( value & 0xFF );
}
void write24(std::streambuf& buf, uint32_t value) {
buf.sputc( (value >> 16) & 0xFF );
buf.sputc( (value >> 8) & 0xFF );
buf.sputc( value & 0xFF );
}
void write32(std::streambuf& buf, uint32_t value) {
buf.sputc( (value >> 24) & 0xFF );
buf.sputc( (value >> 16) & 0xFF );
buf.sputc( (value >> 8) & 0xFF );
buf.sputc( value & 0xFF );
}
void write64(std::streambuf& buf, uint64_t value) {
buf.sputc( (value >> 56) & 0xFF );
buf.sputc( (value >> 48) & 0xFF );
buf.sputc( (value >> 40) & 0xFF );
buf.sputc( (value >> 32) & 0xFF );
buf.sputc( (value >> 24) & 0xFF );
buf.sputc( (value >> 16) & 0xFF );
buf.sputc( (value >> 8) & 0xFF );
buf.sputc( value & 0xFF );
}
void writebox(std::streambuf& buf, const char *name, const std::string& box) {
write32(buf, box.size() + 8);
buf.sputn(name, 4);
buf.sputn(box.c_str(), box.size());
}
void *mapping;
struct Fragment {
double _ts;
double _dur;
Fragment(unsigned ts, unsigned dur) : _ts(ts), _dur(dur) {}
};
void close_fragment(unsigned segment, unsigned fragment, const std::string& fragdata, std::vector<Fragment>& fragments, double ts, double duration) {
if ( fragdata.size() ) {
std::stringstream filename;
filename << docroot << '/' << basedir << '/' << fragments_dir << '/' << "Seg" << segment << "-Frag" << fragment;
size_t fragment_size = fragdata.size() + 8;
char prefix[8];
prefix[0] = (fragment_size >> 24) & 0xFF;
prefix[1] = (fragment_size >> 16) & 0xFF;
prefix[2] = (fragment_size >> 8) & 0xFF;
prefix[3] = fragment_size & 0xFF;
prefix[4] = 'm';
prefix[5] = 'd';
prefix[6] = 'a';
prefix[7] = 't';
std::ofstream out(filename.str().c_str());
std::cerr << filename.str() << std::endl;
assert (out);
out.write(prefix, 8);
out.write(fragdata.c_str(), fragdata.size());
out.close();
fragments.push_back(Fragment(ts, duration));
assert(duration != 0);
}
}
std::vector<Fragment> write_fragments(const ::boost::shared_ptr<mp4::Context>& ctx, double timelimit) {
unsigned segment = 1;
unsigned fragment = 1;
double limit_ts = timelimit;
double old_ts = 0;
double now;
unsigned nsample = 0;
std::vector<Fragment> fragments;
std::stringbuf sb;
if ( ctx->has_video() ) {
sb.sputc(9);
auto ve = ctx->videoextra();
write24(sb, ve.size() + 5);
write32(sb, 0);
write24(sb, 0);
sb.sputn("\x17\0\0\0\0", 5);
sb.sputn(ve.c_str(), ve.size());
write32(sb, ve.size() + 16);
}
if ( ctx->has_audio() ) {
sb.sputc(8);
auto ae = ctx->audioextra();
write24(sb, ae.size() + 2);
write32(sb, 0);
write24(sb, 0);
sb.sputn("\xaf\0", 2);
sb.sputn(ae.c_str(), ae.size());
write32(sb, ae.size() + 13);
}
while ( nsample < ctx->nsamples() ) {
std::cerr << "nsample=" << nsample << ", ";
mp4::SampleInfo *si = ctx->get_sample(nsample++);
now = si->timestamp();
std::cerr << "timestamp=" << now << ", ";
unsigned total = 11 + si->_sample_size;
if ( si->_video ) {
if ( si->_keyframe && now >= limit_ts ) {
std::cerr << "close: " << fragment << "\n";
close_fragment(segment, fragment++, sb.str(), fragments, old_ts, now - old_ts);
old_ts = now;
limit_ts = now + timelimit;
sb.str(std::string());
}
sb.sputc(9);
write24(sb, si->_sample_size + 5);
total += 5;
}
else {
sb.sputc(8);
write24(sb, si->_sample_size + 2);
total += 2;
}
unsigned uts = now * 1000;
write24(sb, uts); sb.sputc( (uts >> 24) & 0xff );
std::cerr << "timestamp_24=" << std::hex << uts << "\n";
write24(sb, 0);
if ( si->_video ) {
if ( si->_keyframe ) {
sb.sputn("\x17\x1", 2);
}
else {
sb.sputn("\x27\x1", 2);
}
write24(sb, si->_composition_offset * 1000.0 / si->_timescale); // composition time offset
}
else {
sb.sputn("\xaf\x1", 2);
}
sb.sputn((char*)mapping + si->_offset, si->_sample_size);
write32(sb, total);
}
close_fragment(segment, fragment, sb.str(), fragments, now, ctx->duration() - now);
return fragments;
}
void ok(const ::boost::shared_ptr<mp4::Context>& ctx) {
std::cout << "ok.\n"; utility::reactor::stop();
std::cout << ctx->_samples.size() << " samples found.\n";
std::cout << "\nnsamples: " << ctx->nsamples()
<< "\nhas video: " << (ctx->has_video() ? "yes" : "no")
<< "\nhas audio: " << (ctx->has_audio() ? "yes" : "no")
<< "\nwidth: " << ctx->width()
<< "\nheight: " << ctx->height()
<< "\npwidth: " << ctx->pwidth()
<< "\npheight: " << ctx->pheight()
<< "\nbitrate: " << ctx->bitrate()
<< "\nduration: " << ctx->duration()
<< std::endl;
std::cout << "writing..." << std::endl;
std::vector<Fragment> fragments = write_fragments(ctx, 10);
std::stringbuf abst;
abst.sputc(0); // version
abst.sputn("\0\0", 3); // flags;
write32(abst, 14); // bootstrapinfoversion
abst.sputc(0); // profile, live, update
write32(abst, 1000); // timescale
write64(abst, ctx->duration() * 1000); // currentmediatime
write64(abst, 0); // smptetimecodeoffset
abst.sputc(0); // movieidentifier
abst.sputc(0); // serverentrycount
abst.sputc(0); // qualityentrycount
abst.sputc(0); // drmdata
abst.sputc(0); // metadata
abst.sputc(1); // segment run table count
std::stringbuf asrt;
asrt.sputc(0); // version
write24(asrt, 0); // flags
asrt.sputc(0); // qualityentrycount
write32(asrt, 1); // segmentrunentry count
write32(asrt, 1); // first segment
write32(asrt, fragments.size()); // fragments per segment
writebox(abst, "asrt", asrt.str());
abst.sputc(1); // fragment run table count
std::stringbuf afrt;
afrt.sputc(0); // version
write24(afrt, 0); // flags
write32(afrt, 1000); // timescale
afrt.sputc(0); // qualityentrycount
std::cerr << fragments.size() << " fragments\n";
write32(afrt, fragments.size()); // fragmentrunentrycount
for ( unsigned ifragment = 0; ifragment < fragments.size(); ++ifragment ) {
write32(afrt, ifragment + 1);
write64(afrt, uint64_t(fragments[ifragment]._ts * 1000));
write32(afrt, uint32_t(fragments[ifragment]._dur * 1000));
if ( fragments[ifragment]._dur == 0 ) {
assert ( ifragment == fragments.size() - 1 );
afrt.sputc(0);
}
}
writebox(abst, "afrt", afrt.str());
std::stringstream bootstrapname;
bootstrapname << docroot << '/' << basedir << '/' << bootstrapinfo_name;
std::string bootstrap_path = bootstrapname.str();
std::ofstream out(bootstrap_path.c_str());
assert ( out );
writebox(*out.rdbuf(), "abst", abst.str());
out.close();
std::string info("bt");
std::stringstream manifestname;
manifestname << docroot << '/' << basedir << '/' << manifest_name;
std::ofstream manifest_out(manifestname.str().c_str());
manifest_out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<manifest xmlns=\"http://ns.adobe.com/f4m/1.0\">\n"
"<id>" << video_id << "</id>\n"
"<streamType>recorded</streamType>\n"
"<duration>" << ctx->duration() << "</duration>\n"
"<bootstrapInfo profile=\"named\" url=\"" << bootstrapinfo_name << "\" id=\"" << info << "\" />>\n"
"<media streamId=\"" << video_id << "\" url=\"" << fragments_dir << '/' << "\" bootstrapinfoId=\"" << info << "\" />\n"
"</manifest>\n";
out.close();
}
void fail(const ::std::string& msg) {
std::cerr << "fail: " << msg << '\n'; utility::reactor::stop();
}
void parse_options(int argc, char **argv) {
namespace po = boost::program_options;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("src", po::value<std::string>(&srcfile), "source mp4 file name")
("docroot", po::value<std::string>(&docroot)->default_value("."), "docroot directory")
("basedir", po::value<std::string>(&basedir)->default_value("."), "base directory for manifest file")
("fragments", po::value<std::string>(&fragments_dir)->default_value("samples"), "directory for fragment files")
("video_id", po::value<std::string>(&video_id)->default_value("some_video"), "video id for manifest file")
("manifest", po::value<std::string>(&manifest_name)->default_value("manifest.f4m"), "manifest file name")
("bootstrapinfo", po::value<std::string>(&bootstrapinfo_name)->default_value("bootstrapinfo"), "bootstrapinfo file name")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help") || argc == 1 || srcfile.size() == 0) {
std::cerr << desc << "\n";
exit(1);
}
}
struct Callback : public mp4::ParseCallback {
::boost::shared_ptr<DataSource> src;
};
Callback ctx;
void run_parser(const std::string& filename) {
ctx._success = ok;
ctx._failure = fail;
ctx.src = get_source(filename);
mp4::a_parse_mp4(ctx.src, &ctx);
}
int main(int argc, char **argv) {
// reactor::set_timer(::boost::bind(run_parser, argv[1]), 1000);
parse_options(argc, argv);
struct stat st;
assert ( stat(srcfile.c_str(), &st) != -1 );
int fd = open(srcfile.c_str(), O_RDONLY);
mapping = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
assert ( mapping != (void*)(-1) );
run_parser(srcfile);
utility::reactor::run();
std::cerr << "That's all!\n";
}
<|endoftext|> |
<commit_before>#include <iostream>
#include <memory>
#include "regex.h"
#include "shl_exception.h"
using std::shared_ptr;
namespace shl {
inline string onig_error_string(int code, OnigErrorInfo* error_info) {
UChar buffer[1024];
int length = onig_error_code_to_str(buffer, code, error_info);
return string(buffer, buffer + length);
}
Match Match::NOT_MATCHED;
Match::Match(shared_ptr<OnigRegion> region, shared_ptr<regex_t> regex, const string& target):_matched(true) {
int capture_count = region->num_regs;
for (int idx = 0; idx < capture_count; idx++) {
_captures.push_back(Range(region->beg[idx] / sizeof(string::value_type), (region->end[idx] - region->beg[idx]) / sizeof(string::value_type)));
}
}
bool Match::operator==(const Match& lh) const {
if (!lh._matched && !this->_matched) return true;
return false;
}
Range Match::operator[](int capture_index) const {
return _captures.at(capture_index);
}
Range Match::operator[](const string& name) const {
return _named_captures.at(name);
}
Regex::Regex(const string& regex) {
init(regex, ONIG_OPTION_CAPTURE_GROUP);
}
Regex::Regex(const string& regex, OnigOptionType option) {
init(regex, option);
}
Match Regex::match(const string& target, int start_offset) const {
UChar* str = (UChar*) target.c_str();
UChar* start = (UChar*) (target.c_str() + start_offset);
UChar* end = (UChar*) (target.c_str() + target.size());
shared_ptr<OnigRegion> region(onig_region_new(), [](OnigRegion* ptr) { onig_region_free(ptr, true);});
if (region == nullptr) throw ShlException("fatal error: can't create OnigRegion");
int ret_code = onig_search(_regex.get(), str, end, start, end, region.get(), ONIG_OPTION_NONE);
if (ret_code != ONIG_MISMATCH) {
return Match(region, _regex, target);
}
return Match::NOT_MATCHED;
}
const string& Regex::source() const {
return _source;
}
void Regex::init(const string& regex, OnigOptionType option) {
OnigErrorInfo oni_error;
UChar* pattern = (UChar*) regex.c_str();
UChar* pattern_end = (UChar*) (regex.c_str() + regex.size());
int ret_code;
regex_t* compiled_regex;
ret_code = onig_new(&compiled_regex, pattern, pattern_end, option, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, &oni_error);
if (ret_code != ONIG_NORMAL) throw InvalidRegexException("invalid regex: " + onig_error_string(ret_code, &oni_error));
_regex = shared_ptr<regex_t>(compiled_regex, [](regex_t* ptr) { onig_free(ptr);});
_source = regex;
}
Match Match::make_dummy(int position, int length) {
Match m;
m._matched = true;
m._captures.push_back(Range(position, length));
}
}
<commit_msg>return the class<commit_after>#include <iostream>
#include <memory>
#include "regex.h"
#include "shl_exception.h"
using std::shared_ptr;
namespace shl {
inline string onig_error_string(int code, OnigErrorInfo* error_info) {
UChar buffer[1024];
int length = onig_error_code_to_str(buffer, code, error_info);
return string(buffer, buffer + length);
}
Match Match::NOT_MATCHED;
Match::Match(shared_ptr<OnigRegion> region, shared_ptr<regex_t> regex, const string& target):_matched(true) {
int capture_count = region->num_regs;
for (int idx = 0; idx < capture_count; idx++) {
_captures.push_back(Range(region->beg[idx] / sizeof(string::value_type), (region->end[idx] - region->beg[idx]) / sizeof(string::value_type)));
}
}
bool Match::operator==(const Match& lh) const {
if (!lh._matched && !this->_matched) return true;
return false;
}
Range Match::operator[](int capture_index) const {
return _captures.at(capture_index);
}
Range Match::operator[](const string& name) const {
return _named_captures.at(name);
}
Regex::Regex(const string& regex) {
init(regex, ONIG_OPTION_CAPTURE_GROUP);
}
Regex::Regex(const string& regex, OnigOptionType option) {
init(regex, option);
}
Match Regex::match(const string& target, int start_offset) const {
UChar* str = (UChar*) target.c_str();
UChar* start = (UChar*) (target.c_str() + start_offset);
UChar* end = (UChar*) (target.c_str() + target.size());
shared_ptr<OnigRegion> region(onig_region_new(), [](OnigRegion* ptr) { onig_region_free(ptr, true);});
if (region == nullptr) throw ShlException("fatal error: can't create OnigRegion");
int ret_code = onig_search(_regex.get(), str, end, start, end, region.get(), ONIG_OPTION_NONE);
if (ret_code != ONIG_MISMATCH) {
return Match(region, _regex, target);
}
return Match::NOT_MATCHED;
}
const string& Regex::source() const {
return _source;
}
void Regex::init(const string& regex, OnigOptionType option) {
OnigErrorInfo oni_error;
UChar* pattern = (UChar*) regex.c_str();
UChar* pattern_end = (UChar*) (regex.c_str() + regex.size());
int ret_code;
regex_t* compiled_regex;
ret_code = onig_new(&compiled_regex, pattern, pattern_end, option, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, &oni_error);
if (ret_code != ONIG_NORMAL) throw InvalidRegexException("invalid regex: " + onig_error_string(ret_code, &oni_error));
_regex = shared_ptr<regex_t>(compiled_regex, [](regex_t* ptr) { onig_free(ptr);});
_source = regex;
}
Match Match::make_dummy(int position, int length) {
Match m;
m._matched = true;
m._captures.push_back(Range(position, length));
return m;
}
}
<|endoftext|> |
<commit_before>#include "qhomebrewupdaterbackend.h"
#include <QtCore/QStandardPaths>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonArray>
using namespace QtAutoUpdater;
Q_LOGGING_CATEGORY(logBrewBackend, "qt.autoupdater.core.plugin.homebrew.backend")
QHomebrewUpdaterBackend::QHomebrewUpdaterBackend(QString &&key, QObject *parent) :
ProcessBackend{std::move(key), parent}
{}
UpdaterBackend::Features QHomebrewUpdaterBackend::features() const
{
return QFileInfo{cakebrewPath()}.isExecutable() ?
(Feature::TriggerInstall | Feature::ParallelInstall) :
Feature::CheckUpdates;
}
void QHomebrewUpdaterBackend::checkForUpdates()
{
UpdateProcessInfo info;
info.program = brewPath();
if (info.program.isEmpty()) {
emit checkDone(false);
return;
}
info.arguments = QStringList {
QStringLiteral("update")
};
if (auto extraArgs = config()->value(QStringLiteral("extraUpdateArgs")); extraArgs)
info.arguments += readArgumentList(*extraArgs);
info.useStdout = true; // DEBUG false
emit checkProgress(-1.0, tr("Updating local package database…"));
runUpdateTool(Update, std::move(info));
}
UpdateInstaller *QHomebrewUpdaterBackend::createInstaller()
{
return nullptr;
}
bool QHomebrewUpdaterBackend::initialize()
{
if (auto pConf = config()->value(QStringLiteral("packages")); pConf)
_packages = readStringList(*pConf);
if (_packages.isEmpty()) {
qCCritical(logBrewBackend) << "Configuration for chocolatey must contain 'packages' with at least one package";
return false;
}
return !brewPath().isEmpty();
}
void QHomebrewUpdaterBackend::onToolDone(int id, int exitCode, QIODevice *processDevice)
{
switch (id) {
case Update:
qCDebug(logBrewBackend) << processDevice->readAll().constData(); // DEBUG remove
onUpdated(exitCode);
break;
case Outdated:
onOutdated(exitCode, processDevice);
break;
default:
Q_UNREACHABLE();
break;
}
}
std::optional<ProcessBackend::InstallProcessInfo> QHomebrewUpdaterBackend::installerInfo(const QList<UpdateInfo> &infos, bool track)
{
Q_UNUSED(infos)
Q_UNUSED(track)
InstallProcessInfo info;
info.program = cakebrewPath();
if (!QFileInfo{info.program}.isExecutable()) {
qCCritical(logBrewBackend) << "Failed to find Cakebrew GUI app bundle";
return std::nullopt;
}
if (auto extraArgs = config()->value(QStringLiteral("extraInstallArgs")); extraArgs)
info.arguments += readArgumentList(*extraArgs);
info.runAsAdmin = false;
return info;
}
QString QHomebrewUpdaterBackend::brewPath() const
{
QStringList paths;
if (auto mPaths = config()->value(QStringLiteral("path")); mPaths)
paths = readPathList(*mPaths);
const auto path = QStandardPaths::findExecutable(QStringLiteral("brew"), paths);
if (path.isEmpty()) {
qCCritical(logBrewBackend) << "Failed to find brew executable";
return {};
} else
return path;
}
QString QHomebrewUpdaterBackend::cakebrewPath() const
{
QDir cakeDir {QStandardPaths::locate(QStandardPaths::ApplicationsLocation,
QStringLiteral("Cakebrew.app"),
QStandardPaths::LocateDirectory)};
if (cakeDir.exists())
return cakeDir.absoluteFilePath(QStringLiteral("Contents/MacOS/Cakebrew"));
else
return {};
}
void QHomebrewUpdaterBackend::onUpdated(int exitCode)
{
if (exitCode == EXIT_SUCCESS) {
UpdateProcessInfo info;
info.program = brewPath();
Q_ASSERT(!info.program.isEmpty());
info.arguments = QStringList {
QStringLiteral("outdated"),
QStringLiteral("--json=v1")
};
if (auto extraArgs = config()->value(QStringLiteral("extraOutdatedArgs")); extraArgs)
info.arguments += readArgumentList(*extraArgs);
emit checkProgress(-1.0, tr("Scanning for outdated packages…"));
runUpdateTool(Outdated, std::move(info));
} else {
qCCritical(logBrewBackend) << "brew update exited with error code" << exitCode;
emit checkDone(false);
}
}
void QHomebrewUpdaterBackend::onOutdated(int exitCode, QIODevice *processDevice)
{
if (exitCode == EXIT_SUCCESS) {
QJsonParseError error;
auto doc = QJsonDocument::fromJson(processDevice->readAll(), &error);
if (error.error != QJsonParseError::NoError) {
qCCritical(logBrewBackend) << "Failed to parse JSON-output at position"
<< error.offset << "with error:"
<< qUtf8Printable(error.errorString());
emit checkDone(false);
return;
}
if (!doc.isArray()) {
qCCritical(logBrewBackend) << "JSON-output is not an array";
emit checkDone(false);
return;
}
QList<UpdateInfo> updates;
for (const auto value : doc.array()) {
const auto obj = value.toObject();
qCDebug(logBrewBackend) << obj; // DEBUG remove
UpdateInfo info;
info.setName(obj[QStringLiteral("name")].toString());
if (!_packages.contains(info.name()))
continue;
info.setVersion(QVersionNumber::fromString(obj[QStringLiteral("current_version")].toString()));
info.setIdentifier(info.name());
updates.append(info);
}
emit checkDone(true, updates);
} else {
qCCritical(logBrewBackend) << "brew outdated exited with error code" << exitCode;
emit checkDone(false);
}
}
<commit_msg>Revert "more debugging"<commit_after>#include "qhomebrewupdaterbackend.h"
#include <QtCore/QStandardPaths>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonArray>
using namespace QtAutoUpdater;
Q_LOGGING_CATEGORY(logBrewBackend, "qt.autoupdater.core.plugin.homebrew.backend")
QHomebrewUpdaterBackend::QHomebrewUpdaterBackend(QString &&key, QObject *parent) :
ProcessBackend{std::move(key), parent}
{}
UpdaterBackend::Features QHomebrewUpdaterBackend::features() const
{
return QFileInfo{cakebrewPath()}.isExecutable() ?
(Feature::TriggerInstall | Feature::ParallelInstall) :
Feature::CheckUpdates;
}
void QHomebrewUpdaterBackend::checkForUpdates()
{
UpdateProcessInfo info;
info.program = brewPath();
if (info.program.isEmpty()) {
emit checkDone(false);
return;
}
info.arguments = QStringList {
QStringLiteral("update")
};
if (auto extraArgs = config()->value(QStringLiteral("extraUpdateArgs")); extraArgs)
info.arguments += readArgumentList(*extraArgs);
info.useStdout = false;
emit checkProgress(-1.0, tr("Updating local package database…"));
runUpdateTool(Update, std::move(info));
}
UpdateInstaller *QHomebrewUpdaterBackend::createInstaller()
{
return nullptr;
}
bool QHomebrewUpdaterBackend::initialize()
{
if (auto pConf = config()->value(QStringLiteral("packages")); pConf)
_packages = readStringList(*pConf);
if (_packages.isEmpty()) {
qCCritical(logBrewBackend) << "Configuration for chocolatey must contain 'packages' with at least one package";
return false;
}
return !brewPath().isEmpty();
}
void QHomebrewUpdaterBackend::onToolDone(int id, int exitCode, QIODevice *processDevice)
{
switch (id) {
case Update:
onUpdated(exitCode);
break;
case Outdated:
onOutdated(exitCode, processDevice);
break;
default:
Q_UNREACHABLE();
break;
}
}
std::optional<ProcessBackend::InstallProcessInfo> QHomebrewUpdaterBackend::installerInfo(const QList<UpdateInfo> &infos, bool track)
{
Q_UNUSED(infos)
Q_UNUSED(track)
InstallProcessInfo info;
info.program = cakebrewPath();
if (!QFileInfo{info.program}.isExecutable()) {
qCCritical(logBrewBackend) << "Failed to find Cakebrew GUI app bundle";
return std::nullopt;
}
if (auto extraArgs = config()->value(QStringLiteral("extraInstallArgs")); extraArgs)
info.arguments += readArgumentList(*extraArgs);
info.runAsAdmin = false;
return info;
}
QString QHomebrewUpdaterBackend::brewPath() const
{
QStringList paths;
if (auto mPaths = config()->value(QStringLiteral("path")); mPaths)
paths = readPathList(*mPaths);
const auto path = QStandardPaths::findExecutable(QStringLiteral("brew"), paths);
if (path.isEmpty()) {
qCCritical(logBrewBackend) << "Failed to find brew executable";
return {};
} else
return path;
}
QString QHomebrewUpdaterBackend::cakebrewPath() const
{
QDir cakeDir {QStandardPaths::locate(QStandardPaths::ApplicationsLocation,
QStringLiteral("Cakebrew.app"),
QStandardPaths::LocateDirectory)};
if (cakeDir.exists())
return cakeDir.absoluteFilePath(QStringLiteral("Contents/MacOS/Cakebrew"));
else
return {};
}
void QHomebrewUpdaterBackend::onUpdated(int exitCode)
{
if (exitCode == EXIT_SUCCESS) {
UpdateProcessInfo info;
info.program = brewPath();
Q_ASSERT(!info.program.isEmpty());
info.arguments = QStringList {
QStringLiteral("outdated"),
QStringLiteral("--json=v1")
};
if (auto extraArgs = config()->value(QStringLiteral("extraOutdatedArgs")); extraArgs)
info.arguments += readArgumentList(*extraArgs);
emit checkProgress(-1.0, tr("Scanning for outdated packages…"));
runUpdateTool(Outdated, std::move(info));
} else {
qCCritical(logBrewBackend) << "brew update exited with error code" << exitCode;
emit checkDone(false);
}
}
void QHomebrewUpdaterBackend::onOutdated(int exitCode, QIODevice *processDevice)
{
if (exitCode == EXIT_SUCCESS) {
QJsonParseError error;
auto doc = QJsonDocument::fromJson(processDevice->readAll(), &error);
if (error.error != QJsonParseError::NoError) {
qCCritical(logBrewBackend) << "Failed to parse JSON-output at position"
<< error.offset << "with error:"
<< qUtf8Printable(error.errorString());
emit checkDone(false);
return;
}
if (!doc.isArray()) {
qCCritical(logBrewBackend) << "JSON-output is not an array";
emit checkDone(false);
return;
}
QList<UpdateInfo> updates;
for (const auto value : doc.array()) {
const auto obj = value.toObject();
UpdateInfo info;
info.setName(obj[QStringLiteral("name")].toString());
if (!_packages.contains(info.name()))
continue;
info.setVersion(QVersionNumber::fromString(obj[QStringLiteral("current_version")].toString()));
info.setIdentifier(info.name());
updates.append(info);
}
emit checkDone(true, updates);
} else {
qCCritical(logBrewBackend) << "brew outdated exited with error code" << exitCode;
emit checkDone(false);
}
}
<|endoftext|> |
<commit_before>#include <hadouken/scripting/modules/bittorrent/torrent_info_wrapper.hpp>
#include <libtorrent/torrent_info.hpp>
#include "../common.hpp"
#include "../../duktape.h"
using namespace hadouken::scripting::modules;
using namespace hadouken::scripting::modules::bittorrent;
duk_ret_t torrent_info_wrapper::construct(duk_context* ctx)
{
int t = duk_get_type(ctx, 0);
libtorrent::torrent_info* info;
if (t == DUK_TYPE_STRING)
{
std::string file(duk_require_string(ctx, 0));
// TODO: error handling
info = new libtorrent::torrent_info(file);
}
else if (t == DUK_TYPE_BUFFER)
{
duk_size_t size;
const char* buffer = static_cast<const char*>(duk_require_buffer(ctx, 0, &size));
// TODO: error handling
info = new libtorrent::torrent_info(buffer, size);
}
duk_push_this(ctx);
common::set_pointer<libtorrent::torrent_info>(ctx, -2, info);
duk_push_c_function(ctx, finalize, 1);
duk_set_finalizer(ctx, -2);
return 0;
}
void torrent_info_wrapper::initialize(duk_context* ctx, const libtorrent::torrent_info& info)
{
duk_function_list_entry functions[] =
{
{ "getFiles", get_files, 0 },
{ NULL, NULL, 0 }
};
duk_idx_t infoIndex = duk_push_object(ctx);
duk_put_function_list(ctx, infoIndex, functions);
// Set internal pointers
common::set_pointer<libtorrent::torrent_info>(ctx, infoIndex, new libtorrent::torrent_info(info));
DUK_READONLY_PROPERTY(ctx, infoIndex, comment, get_comment);
DUK_READONLY_PROPERTY(ctx, infoIndex, creationDate, get_creation_date);
DUK_READONLY_PROPERTY(ctx, infoIndex, creator, get_creator);
DUK_READONLY_PROPERTY(ctx, infoIndex, infoHash, get_info_hash);
DUK_READONLY_PROPERTY(ctx, infoIndex, name, get_name);
DUK_READONLY_PROPERTY(ctx, infoIndex, totalSize, get_total_size);
duk_push_c_function(ctx, finalize, 1);
duk_set_finalizer(ctx, -2);
}
duk_ret_t torrent_info_wrapper::finalize(duk_context* ctx)
{
common::finalize<libtorrent::torrent_info>(ctx);
return 0;
}
duk_ret_t torrent_info_wrapper::get_creation_date(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
if (info->creation_date())
{
duk_push_number(ctx, info->creation_date().get());
}
else
{
duk_push_number(ctx, -1);
}
return 1;
}
duk_ret_t torrent_info_wrapper::get_comment(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, info->comment().c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_creator(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, info->creator().c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_files(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
int arrayIndex = duk_push_array(ctx);
int i = 0;
const libtorrent::file_storage& storage = info->files();
for (int i = 0; i < storage.num_files(); i++)
{
libtorrent::file_entry entry = storage.at(i);
duk_idx_t entryIndex = duk_push_object(ctx);
duk_push_string(ctx, entry.path.c_str());
duk_put_prop_string(ctx, entryIndex, "path");
duk_push_number(ctx, static_cast<duk_double_t>(entry.size));
duk_put_prop_string(ctx, entryIndex, "size");
// Put entry object
duk_put_prop_index(ctx, arrayIndex, i);
}
return 1;
}
duk_ret_t torrent_info_wrapper::get_info_hash(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, libtorrent::to_hex(info->info_hash().to_string()).c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_name(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, info->name().c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_total_size(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_number(ctx, static_cast<duk_double_t>(info->total_size()));
return 1;
}
<commit_msg>Fix crash when adding an invalid torrent file<commit_after>#include <hadouken/scripting/modules/bittorrent/torrent_info_wrapper.hpp>
#include <boost/log/trivial.hpp>
#include <libtorrent/torrent_info.hpp>
#include "../common.hpp"
#include "../../duktape.h"
using namespace hadouken::scripting::modules;
using namespace hadouken::scripting::modules::bittorrent;
duk_ret_t torrent_info_wrapper::construct(duk_context* ctx)
{
int t = duk_get_type(ctx, 0);
libtorrent::torrent_info* info;
try
{
if (t == DUK_TYPE_STRING)
{
std::string file(duk_require_string(ctx, 0));
info = new libtorrent::torrent_info(file);
}
else if (t == DUK_TYPE_BUFFER)
{
duk_size_t size;
const char* buffer = static_cast<const char*>(duk_require_buffer(ctx, 0, &size));
info = new libtorrent::torrent_info(buffer, size);
}
duk_push_this(ctx);
common::set_pointer<libtorrent::torrent_info>(ctx, -2, info);
duk_push_c_function(ctx, finalize, 1);
duk_set_finalizer(ctx, -2);
}
catch (const libtorrent::libtorrent_exception& ex)
{
BOOST_LOG_TRIVIAL(warning) << "Invalid torrent file: " << ex.what();
return DUK_RET_UNSUPPORTED_ERROR;
}
catch (const std::exception& ex)
{
BOOST_LOG_TRIVIAL(warning) << "Error adding torrent: " << ex.what();
return DUK_RET_ERROR;
}
return 0;
}
void torrent_info_wrapper::initialize(duk_context* ctx, const libtorrent::torrent_info& info)
{
duk_function_list_entry functions[] =
{
{ "getFiles", get_files, 0 },
{ NULL, NULL, 0 }
};
duk_idx_t infoIndex = duk_push_object(ctx);
duk_put_function_list(ctx, infoIndex, functions);
// Set internal pointers
common::set_pointer<libtorrent::torrent_info>(ctx, infoIndex, new libtorrent::torrent_info(info));
DUK_READONLY_PROPERTY(ctx, infoIndex, comment, get_comment);
DUK_READONLY_PROPERTY(ctx, infoIndex, creationDate, get_creation_date);
DUK_READONLY_PROPERTY(ctx, infoIndex, creator, get_creator);
DUK_READONLY_PROPERTY(ctx, infoIndex, infoHash, get_info_hash);
DUK_READONLY_PROPERTY(ctx, infoIndex, name, get_name);
DUK_READONLY_PROPERTY(ctx, infoIndex, totalSize, get_total_size);
duk_push_c_function(ctx, finalize, 1);
duk_set_finalizer(ctx, -2);
}
duk_ret_t torrent_info_wrapper::finalize(duk_context* ctx)
{
common::finalize<libtorrent::torrent_info>(ctx);
return 0;
}
duk_ret_t torrent_info_wrapper::get_creation_date(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
if (info->creation_date())
{
duk_push_number(ctx, info->creation_date().get());
}
else
{
duk_push_number(ctx, -1);
}
return 1;
}
duk_ret_t torrent_info_wrapper::get_comment(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, info->comment().c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_creator(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, info->creator().c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_files(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
int arrayIndex = duk_push_array(ctx);
int i = 0;
const libtorrent::file_storage& storage = info->files();
for (int i = 0; i < storage.num_files(); i++)
{
libtorrent::file_entry entry = storage.at(i);
duk_idx_t entryIndex = duk_push_object(ctx);
duk_push_string(ctx, entry.path.c_str());
duk_put_prop_string(ctx, entryIndex, "path");
duk_push_number(ctx, static_cast<duk_double_t>(entry.size));
duk_put_prop_string(ctx, entryIndex, "size");
// Put entry object
duk_put_prop_index(ctx, arrayIndex, i);
}
return 1;
}
duk_ret_t torrent_info_wrapper::get_info_hash(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, libtorrent::to_hex(info->info_hash().to_string()).c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_name(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_string(ctx, info->name().c_str());
return 1;
}
duk_ret_t torrent_info_wrapper::get_total_size(duk_context* ctx)
{
libtorrent::torrent_info* info = common::get_pointer<libtorrent::torrent_info>(ctx);
duk_push_number(ctx, static_cast<duk_double_t>(info->total_size()));
return 1;
}
<|endoftext|> |
<commit_before>/*
Original code from tekkies/CVdrone (get actual address from github)
Modified by Elliot Greenlee, Caleb Mennen, Jacob Pollack
COSC 402 Senior Design
Min Kao Drone Tour
See readme at (get actual address from github)
*/
#include "ardrone/ardrone.h"
#include "structures.h"
#include "objectFollowing/objectFollowing.h"
#include "manual/manual.h"
#include "lineFollowing/lineFollowing.h"
#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
using namespace std;
class Control {
public:
//AR.Drone class
ARDrone ardrone;
int key;
FlyingMode flyingMode = Manual;
double speed;
int batteryPercentage;
bool flying;
ControlMovements controlMovements;
FILE *flight_log;
void detectFlyingMode();
};
void Control::detectFlyingMode() {
//switch between flying modes
if (key == 'b') {
flyingMode = Manual;
ardrone.setCamera(0);
printf("Manual flying mode is enabled\n");
printf("Press n for object following and m for line following\n");
printf("While in manual mode, use q and a for up and down, t and g for forward and backward, and f and h for left and right. Press space to take off.\n\n");
}
else if (key == 'n') {
flyingMode = ObjectFollow;
ardrone.setCamera(0);
printf("Object Following flying mode is enabled\n");
printf("Press b for manual and m for line following\n");
printf("While in object following mode, use l to toggle learning a specific color. Press space to take off after learning a color.\n\n");
}
else if (key == 'm') {
flyingMode = LineFollow;
ardrone.setCamera(1);
printf("Line Following flying mode is enabled\n");
printf("Press b for manual and n for object following\n");
printf("No control for line following yet exists\n\n");
}
}
int main(int argc, char *argv[])
{
Control control;
//Control classes
ObjectFollowing objectFollowing;
//TODO: ManualDriving manualDriving;
//TODO: LineFollowing lineFollwing;
//Display variables
FILE *flight_log;
char modeDisplay[80]; //print buffer for flying mode
char flyingDisplay[80]; //print buffer for if flying
char speedDisplay[80]; //print buffer for speed
cv::Scalar green = CV_RGB(0,255,0); //putText color value
//Drone control
float speed = 0.0;
double vx = 0.0;
double vy = 0.0;
double vz = 0.0;
double vr = 0.0;
ControlMovements controlMovements;
//Initializing Message
printf("Connecting to the drone\n");
printf("If there is no version number response in the next 10 seconds, please restart the drone and code.\n");
printf("To disconnect, press the ESC key\n\n");
fflush(stdout);
// Initialize
if (!(control.ardrone.open())) {
printf("Failed to initialize.\n");
return -1;
}
//Set drone on flat surface and initialize
control.ardrone.setFlatTrim();
//initialize object following code
objectFollowing.initializeObjectFollowing();
//Print default command information
printf("Currently the drone is in manual mode.\n");
printf("Use the b key for manual mode, the n key for object following, and the m key for line following. The number keys can be used to set a speed. Use spacebar to take off and land, which is required before any control can be executed.\n\n");
flight_log = fopen("flight_log.txt", "w");
// Main loop
while (1) {
control.key = cv::waitKey(33); // Key input
if (control.key == 0x1b) { break; } //press the escape key to exit
//TODO:Write battery percentage to screen
printf("%d\n", control.ardrone.getBatteryPercentage());
control.detectFlyingMode();
// Get an image
cv::Mat image = control.ardrone.getImage();
//Speed
if ((control.key >= '0') && (control.key <= '9')) //number keys
{
speed = (control.key-'0')*0.1;
}
//Write speed to image
sprintf(speedDisplay, "Speed = %3.2f", speed);
putText(image, speedDisplay, cvPoint(30,40), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, green, 1, CV_AA);
//Take off / Landing
if (control.key == ' ') { //spacebar
if (control.ardrone.onGround()) {
control.ardrone.takeoff();
fprintf(flight_log, "TAKEOFF\n");
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
}
else {
control.ardrone.landing();
fprintf(flight_log, "LAND\n");
}
}
//Write if grounded or flying to image
if (control.ardrone.onGround()) {
sprintf(flyingDisplay, "Landed");
}
else {
sprintf(flyingDisplay, "Flying");
}
putText(image, flyingDisplay, cvPoint(200,40), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, green, 1, CV_AA);
switch (control.flyingMode) {
case Manual:
//TODO: Allow user to set camera mode in Manual
//TODO: Change 0/1 to CONSTANTS of 0 = front, 1 = bottom
//TODO: Scale these values for normal human control when in manual mode
controlMovements = manualMovement(control.key);
sprintf(modeDisplay, "Manual Mode");
//TODO: Move this into manualMovement(control.key) function
displayManualInfo(&image, controlMovements);
vx = controlMovements.vx;
vy = controlMovements.vy;
vz = controlMovements.vz;
vr = controlMovements.vr;
break;
case ObjectFollow:
controlMovements = objectFollowing.detectObject(image, control.key);
vx = controlMovements.vx;
vy = controlMovements.vy;
vz = controlMovements.vz;
vr = controlMovements.vr;
sprintf(modeDisplay, "Object Following Mode");
break;
case LineFollow:
sprintf(modeDisplay, "Line Following Mode");
break;
}
putText(image, modeDisplay, cvPoint(30,20), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, green, 1, CV_AA);
fprintf(flight_log, "ardrone.move3D(vx=%f, vy=%f, vz=%f, vr=%f)\n", (speed), (vy * speed), (vz * speed), vr);
control.ardrone.move3D(vx * speed, vy * speed, vz * speed, vr);
//Display the camera feed
cv::imshow("camera", image);
}
//Write hsv values to a file
objectFollowing.closeObjectFollowing();
//TODO: closeManual();
//TODO: closeLineFollowing();
//Close connection to drone
control.ardrone.close();
return 0;
}
<commit_msg>Remove unused velocities. Move control into controlMovements struct.<commit_after>/*
Original code from tekkies/CVdrone (get actual address from github)
Modified by Elliot Greenlee, Caleb Mennen, Jacob Pollack
COSC 402 Senior Design
Min Kao Drone Tour
See readme at (get actual address from github)
*/
#include "ardrone/ardrone.h"
#include "structures.h"
#include "objectFollowing/objectFollowing.h"
#include "manual/manual.h"
#include "lineFollowing/lineFollowing.h"
#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
using namespace std;
class Control {
public:
//AR.Drone class
ARDrone ardrone;
int key;
FlyingMode flyingMode = Manual;
double speed;
int batteryPercentage;
bool flying;
ControlMovements controlMovements;
FILE *flight_log;
void detectFlyingMode();
};
void Control::detectFlyingMode() {
//switch between flying modes
if (key == 'b') {
flyingMode = Manual;
ardrone.setCamera(0);
printf("Manual flying mode is enabled\n");
printf("Press n for object following and m for line following\n");
printf("While in manual mode, use q and a for up and down, t and g for forward and backward, and f and h for left and right. Press space to take off.\n\n");
}
else if (key == 'n') {
flyingMode = ObjectFollow;
ardrone.setCamera(0);
printf("Object Following flying mode is enabled\n");
printf("Press b for manual and m for line following\n");
printf("While in object following mode, use l to toggle learning a specific color. Press space to take off after learning a color.\n\n");
}
else if (key == 'm') {
flyingMode = LineFollow;
ardrone.setCamera(1);
printf("Line Following flying mode is enabled\n");
printf("Press b for manual and n for object following\n");
printf("No control for line following yet exists\n\n");
}
}
int main(int argc, char *argv[])
{
Control control;
//Controlling classes
ObjectFollowing objectFollowing;
//TODO: ManualDriving manualDriving;
//TODO: LineFollowing lineFollwing;
//Display variables
FILE *flight_log;
char modeDisplay[80]; //print buffer for flying mode
char flyingDisplay[80]; //print buffer for if flying
char speedDisplay[80]; //print buffer for speed
cv::Scalar green = CV_RGB(0,255,0); //putText color value
//Drone control
float speed = 0.0;
ControlMovements controlMovements;
//Initializing Message
printf("Connecting to the drone\n");
printf("If there is no version number response in the next 10 seconds, please restart the drone and code.\n");
printf("To disconnect, press the ESC key\n\n");
fflush(stdout);
// Initialize
if (!(control.ardrone.open())) {
printf("Failed to initialize.\n");
return -1;
}
//Set drone on flat surface and initialize
control.ardrone.setFlatTrim();
//initialize object following code
objectFollowing.initializeObjectFollowing();
//Print default command information
printf("Currently the drone is in manual mode.\n");
printf("Use the b key for manual mode, the n key for object following, and the m key for line following. The number keys can be used to set a speed. Use spacebar to take off and land, which is required before any control can be executed.\n\n");
flight_log = fopen("flight_log.txt", "w");
// Main loop
while (1) {
control.key = cv::waitKey(33); // Key input
if (control.key == 0x1b) { break; } //press the escape key to exit
//TODO:Write battery percentage to screen
printf("%d\n", control.ardrone.getBatteryPercentage());
control.detectFlyingMode();
// Get an image
cv::Mat image = control.ardrone.getImage();
//Speed
if ((control.key >= '0') && (control.key <= '9')) //number keys
{
speed = (control.key-'0')*0.1;
}
//Write speed to image
sprintf(speedDisplay, "Speed = %3.2f", speed);
putText(image, speedDisplay, cvPoint(30,40), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, green, 1, CV_AA);
//Take off / Landing
if (control.key == ' ') { //spacebar
if (control.ardrone.onGround()) {
control.ardrone.takeoff();
fprintf(flight_log, "TAKEOFF\n");
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
}
else {
control.ardrone.landing();
fprintf(flight_log, "LAND\n");
}
}
//Write if grounded or flying to image
if (control.ardrone.onGround()) {
sprintf(flyingDisplay, "Landed");
}
else {
sprintf(flyingDisplay, "Flying");
}
putText(image, flyingDisplay, cvPoint(200,40), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, green, 1, CV_AA);
switch (control.flyingMode) {
case Manual:
//TODO: Allow user to set camera mode in Manual
//TODO: Change 0/1 to CONSTANTS of 0 = front, 1 = bottom
//TODO: Scale these values for normal human control when in manual mode
controlMovements = manualMovement(control.key);
sprintf(modeDisplay, "Manual Mode");
//TODO: Move this into manualMovement(control.key) function
displayManualInfo(&image, controlMovements);
break;
case ObjectFollow:
controlMovements = objectFollowing.detectObject(image, control.key);
sprintf(modeDisplay, "Object Following Mode");
break;
case LineFollow:
sprintf(modeDisplay, "Line Following Mode");
break;
}
putText(image, modeDisplay, cvPoint(30,20), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, green, 1, CV_AA);
control.ardrone.move3D(controlMovements.vx * speed, controlMovements.vy * speed, controlMovements.vz * speed, controlMovements.vr);
//Display the camera feed
cv::imshow("camera", image);
}
//Write hsv values to a file
objectFollowing.closeObjectFollowing();
//TODO: closeManual();
//TODO: closeLineFollowing();
//Close connection to drone
control.ardrone.close();
return 0;
}
<|endoftext|> |
<commit_before>/** \brief Utility for dumping metadata out of the delivered_marc_records MySQL table in ub_tools.
* \author Mario Trojan ([email protected])
*
* \copyright 2021 Universitätsbibliothek Tübingen. All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include "DbConnection.h"
#include "FileUtil.h"
#include "MARC.h"
#include "StringUtil.h"
#include "TextUtil.h"
#include "util.h"
namespace {
[[noreturn]] void Usage() {
::Usage("[--extended] zeder_journal_id csv_path\n"
"\"--extended\" will add information from BLOBs as well, e.g. DOIs.");
}
MARC::Record GetTemporaryRecord(const std::string &blob) {
const auto tmp_path(FileUtil::UniqueFileName());
FileUtil::WriteStringOrDie(tmp_path, blob);
auto reader(MARC::Reader::Factory(tmp_path));
return reader->read();
}
void GetJournalDetailsFromDb(DbConnection * const db_connection, const std::string &zeder_journal_id, File * const csv_file) {
db_connection->queryOrDie("SELECT * FROM zeder_journals WHERE id=" + db_connection->escapeAndQuoteString(zeder_journal_id));
auto result(db_connection->getLastResultSet());
if (result.size() != 1)
LOG_ERROR("entry not found");
while (DbRow journal = result.getNextRow()) {
csv_file->writeln(journal["id"] + ";" + journal["zeder_id"] + ";" + journal["zeder_instance"] + ";" + TextUtil::CSVEscape(journal["journal_name"]));
csv_file->writeln("");
break;
}
}
void GetJournalEntriesFromDb(DbConnection * const db_connection, const std::string &zeder_journal_id, File * const csv_file, const bool extended) {
std::string query("SELECT * FROM delivered_marc_records WHERE zeder_journal_id=" + db_connection->escapeAndQuoteString(zeder_journal_id) + " ORDER BY delivered_at ASC");
db_connection->queryOrDie(query);
auto result(db_connection->getLastResultSet());
while (DbRow row = result.getNextRow()) {
std::string csv_row(row["id"] + ";" + row["hash"] + ";" + row["delivery_state"] + ";" + TextUtil::CSVEscape(row["error_message"]) + ";" + row["delivered_at"] + ";" + TextUtil::CSVEscape(row["main_title"]));
if (extended and not row["record"].empty()) {
const auto record(GetTemporaryRecord(row["record"]));
const auto dois(record.getDOIs());
csv_row += TextUtil::CSVEscape(StringUtil::Join(dois, '\n'));
}
csv_file->writeln(csv_row);
}
}
} // unnamed namespace
int Main(int argc, char *argv[]) {
if (argc != 3 and argc != 4)
Usage();
bool extended(false);
if (argc == 4 and StringUtil::StartsWith(argv[1], "--extended")) {
extended = true;
++argv, --argc;
}
const std::string zeder_journal_id(argv[1]);
const std::string csv_path(argv[2]);
auto csv_file(FileUtil::OpenOutputFileOrDie(csv_path));
DbConnection db_connection;
csv_file->writeln("zeder_journal_id;zeder_id;zeder_instance;journal_name");
GetJournalDetailsFromDb(&db_connection, zeder_journal_id, csv_file.get());
std::string entries_header("id;hash;delivery_state;error_message;delivered_at;main_title");
if (extended)
entries_header += ";DOIs";
csv_file->writeln(entries_header);
GetJournalEntriesFromDb(&db_connection, zeder_journal_id, csv_file.get(), extended);
return EXIT_SUCCESS;
}
<commit_msg>dump_delivered_marc_records.cc: Decompress BLOB<commit_after>/** \brief Utility for dumping metadata out of the delivered_marc_records MySQL table in ub_tools.
* \author Mario Trojan ([email protected])
*
* \copyright 2021 Universitätsbibliothek Tübingen. All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include "DbConnection.h"
#include "FileUtil.h"
#include "GzStream.h"
#include "MARC.h"
#include "StringUtil.h"
#include "TextUtil.h"
#include "util.h"
namespace {
[[noreturn]] void Usage() {
::Usage("[--extended] zeder_journal_id csv_path\n"
"\"--extended\" will add information from BLOBs as well, e.g. DOIs.");
}
MARC::Record GetTemporaryRecord(const std::string &blob) {
const std::string decompressed_blob(GzStream::DecompressString(blob));
const auto tmp_path(FileUtil::UniqueFileName());
FileUtil::WriteStringOrDie(tmp_path, decompressed_blob);
auto reader(MARC::Reader::Factory(tmp_path));
return reader->read();
}
void GetJournalDetailsFromDb(DbConnection * const db_connection, const std::string &zeder_journal_id, File * const csv_file) {
db_connection->queryOrDie("SELECT * FROM zeder_journals WHERE id=" + db_connection->escapeAndQuoteString(zeder_journal_id));
auto result(db_connection->getLastResultSet());
if (result.size() != 1)
LOG_ERROR("entry not found");
while (DbRow journal = result.getNextRow()) {
csv_file->writeln(journal["id"] + ";" + journal["zeder_id"] + ";" + journal["zeder_instance"] + ";" + TextUtil::CSVEscape(journal["journal_name"]));
csv_file->writeln("");
break;
}
}
void GetJournalEntriesFromDb(DbConnection * const db_connection, const std::string &zeder_journal_id, File * const csv_file, const bool extended) {
std::string query("SELECT * FROM delivered_marc_records WHERE zeder_journal_id=" + db_connection->escapeAndQuoteString(zeder_journal_id) + " ORDER BY delivered_at ASC");
db_connection->queryOrDie(query);
auto result(db_connection->getLastResultSet());
while (DbRow row = result.getNextRow()) {
std::string csv_row(row["id"] + ";" + row["hash"] + ";" + row["delivery_state"] + ";" + TextUtil::CSVEscape(row["error_message"]) + ";" + row["delivered_at"] + ";" + TextUtil::CSVEscape(row["main_title"]));
if (extended and not row["record"].empty()) {
const auto record(GetTemporaryRecord(row["record"]));
const auto dois(record.getDOIs());
csv_row += TextUtil::CSVEscape(StringUtil::Join(dois, '\n'));
}
csv_file->writeln(csv_row);
}
}
} // unnamed namespace
int Main(int argc, char *argv[]) {
if (argc != 3 and argc != 4)
Usage();
bool extended(false);
if (argc == 4 and StringUtil::StartsWith(argv[1], "--extended")) {
extended = true;
++argv, --argc;
}
const std::string zeder_journal_id(argv[1]);
const std::string csv_path(argv[2]);
auto csv_file(FileUtil::OpenOutputFileOrDie(csv_path));
DbConnection db_connection;
csv_file->writeln("zeder_journal_id;zeder_id;zeder_instance;journal_name");
GetJournalDetailsFromDb(&db_connection, zeder_journal_id, csv_file.get());
std::string entries_header("id;hash;delivery_state;error_message;delivered_at;main_title");
if (extended)
entries_header += ";DOIs";
csv_file->writeln(entries_header);
GetJournalEntriesFromDb(&db_connection, zeder_journal_id, csv_file.get(), extended);
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/*
* Copyright 2015 Cloudius Systems
*
* Modified by Cloudius Systems
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#include "create_index_statement.hh"
#include "validation.hh"
#include "service/storage_proxy.hh"
#include "service/migration_manager.hh"
#include "schema.hh"
#include "schema_builder.hh"
cql3::statements::create_index_statement::create_index_statement(
::shared_ptr<cf_name> name, ::shared_ptr<index_name> index_name,
::shared_ptr<index_target::raw> raw_target,
::shared_ptr<index_prop_defs> properties, bool if_not_exists)
: schema_altering_statement(name), _index_name(index_name->get_idx()), _raw_target(
raw_target), _properties(properties), _if_not_exists(
if_not_exists) {
}
void
cql3::statements::create_index_statement::check_access(const service::client_state& state) {
warn(unimplemented::cause::MIGRATIONS);
// TODO
//state.hasColumnFamilyAccess(keyspace(), columnFamily(), Permission.ALTER);
}
void
cql3::statements::create_index_statement::validate(distributed<service::storage_proxy>& proxy
, const service::client_state& state)
{
auto schema = validation::validate_column_family(proxy.local().get_db().local(), keyspace(), column_family());
if (schema->is_counter()) {
throw exceptions::invalid_request_exception("Secondary indexes are not supported on counter tables");
}
// Added since we might as well fail fast if anyone is trying to insert java classes here...
if (_properties->is_custom) {
throw exceptions::invalid_request_exception("CUSTOM index not supported");
}
auto target = _raw_target->prepare(schema);
auto cd = schema->get_column_definition(target->column->name());
if (cd == nullptr) {
throw exceptions::invalid_request_exception(sprint("No column definition found for column %s", target->column->name()));
}
bool is_map = dynamic_cast<const collection_type_impl *>(cd->type.get()) != nullptr
&& dynamic_cast<const collection_type_impl *>(cd->type.get())->is_map();
bool is_frozen_collection = cd->type->is_collection() && !cd->type->is_multi_cell();
if (is_frozen_collection) {
if (target->type != index_target::target_type::full) {
throw exceptions::invalid_request_exception(
sprint("Cannot create index on %s of frozen<map> column %s",
index_target::index_option(target->type),
target->column->name()));
}
} else {
// validateNotFullIndex
if (target->type == index_target::target_type::full) {
throw exceptions::invalid_request_exception("full() indexes can only be created on frozen collections");
}
// validateIsValuesIndexIfTargetColumnNotCollection
if (!cd->type->is_collection()
&& target->type != index_target::target_type::values) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create index on %s of column %s; only non-frozen collections support %s indexes",
index_target::index_option(target->type),
target->column->name(),
index_target::index_option(target->type)));
}
// validateTargetColumnIsMapIfIndexInvolvesKeys
if (target->type == index_target::target_type::keys
|| target->type == index_target::target_type::keys_and_values) {
if (!is_map) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create index on %s of column %s with non-map type",
index_target::index_option(target->type),
target->column->name()));
}
}
}
if (cd->idx_info.index_type != ::index_type::none) {
auto prev_type = index_target::from_column_definition(*cd);
if (is_map && target->type != prev_type) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create index on %s(%s): an index on %s(%s) already exists and indexing "
"a map on more than one dimension at the same time is not currently supported",
index_target::index_option(target->type),
target->column->name(),
index_target::index_option(prev_type),
target->column->name()));
}
if (_if_not_exists) {
return;
} else {
throw exceptions::invalid_request_exception("Index already exists");
}
}
_properties->validate();
// Origin TODO: we could lift that limitation
if ((schema->is_dense() || !schema->thrift().has_compound_comparator()) && cd->kind != column_kind::regular_column) {
throw exceptions::invalid_request_exception("Secondary indexes are not supported on PRIMARY KEY columns in COMPACT STORAGE tables");
}
// It would be possible to support 2ndary index on static columns (but not without modifications of at least ExtendedFilter and
// CompositesIndex) and maybe we should, but that means a query like:
// SELECT * FROM foo WHERE static_column = 'bar'
// would pull the full partition every time the static column of partition is 'bar', which sounds like offering a
// fair potential for foot-shooting, so I prefer leaving that to a follow up ticket once we have identified cases where
// such indexing is actually useful.
if (cd->is_static()) {
throw exceptions::invalid_request_exception("Secondary indexes are not allowed on static columns");
}
if (cd->kind == column_kind::partition_key && cd->is_on_all_components()) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create secondary index on partition key column %s",
target->column->name()));
}
}
future<bool>
cql3::statements::create_index_statement::announce_migration(distributed<service::storage_proxy>& proxy, bool is_local_only) {
auto schema = proxy.local().get_db().local().find_schema(keyspace(), column_family());
auto target = _raw_target->prepare(schema);
schema_builder cfm(schema);
auto* cd = schema->get_column_definition(target->column->name());
index_info idx = cd->idx_info;
if (idx.index_type != ::index_type::none && _if_not_exists) {
return make_ready_future<bool>(false);
}
if (_properties->is_custom) {
idx.index_type = index_type::custom;
idx.index_options = _properties->get_options();
} else if (schema->thrift().has_compound_comparator()) {
index_options_map options;
if (cd->type->is_collection() && cd->type->is_multi_cell()) {
options[index_target::index_option(target->type)] = "";
}
idx.index_type = index_type::composites;
idx.index_options = options;
} else {
idx.index_type = index_type::keys;
idx.index_options = index_options_map();
}
idx.index_name = _index_name;
cfm.add_default_index_names(proxy.local().get_db().local());
return service::get_local_migration_manager().announce_column_family_update(
cfm.build(), false, is_local_only).then([]() {
return make_ready_future<bool>(true);
});
}
<commit_msg>create_index_statement: Use textual representation of column name<commit_after>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/*
* Copyright 2015 Cloudius Systems
*
* Modified by Cloudius Systems
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#include "create_index_statement.hh"
#include "validation.hh"
#include "service/storage_proxy.hh"
#include "service/migration_manager.hh"
#include "schema.hh"
#include "schema_builder.hh"
cql3::statements::create_index_statement::create_index_statement(
::shared_ptr<cf_name> name, ::shared_ptr<index_name> index_name,
::shared_ptr<index_target::raw> raw_target,
::shared_ptr<index_prop_defs> properties, bool if_not_exists)
: schema_altering_statement(name), _index_name(index_name->get_idx()), _raw_target(
raw_target), _properties(properties), _if_not_exists(
if_not_exists) {
}
void
cql3::statements::create_index_statement::check_access(const service::client_state& state) {
warn(unimplemented::cause::MIGRATIONS);
// TODO
//state.hasColumnFamilyAccess(keyspace(), columnFamily(), Permission.ALTER);
}
void
cql3::statements::create_index_statement::validate(distributed<service::storage_proxy>& proxy
, const service::client_state& state)
{
auto schema = validation::validate_column_family(proxy.local().get_db().local(), keyspace(), column_family());
if (schema->is_counter()) {
throw exceptions::invalid_request_exception("Secondary indexes are not supported on counter tables");
}
// Added since we might as well fail fast if anyone is trying to insert java classes here...
if (_properties->is_custom) {
throw exceptions::invalid_request_exception("CUSTOM index not supported");
}
auto target = _raw_target->prepare(schema);
auto cd = schema->get_column_definition(target->column->name());
if (cd == nullptr) {
throw exceptions::invalid_request_exception(sprint("No column definition found for column %s", target->column->text()));
}
bool is_map = dynamic_cast<const collection_type_impl *>(cd->type.get()) != nullptr
&& dynamic_cast<const collection_type_impl *>(cd->type.get())->is_map();
bool is_frozen_collection = cd->type->is_collection() && !cd->type->is_multi_cell();
if (is_frozen_collection) {
if (target->type != index_target::target_type::full) {
throw exceptions::invalid_request_exception(
sprint("Cannot create index on %s of frozen<map> column %s",
index_target::index_option(target->type),
target->column->name()));
}
} else {
// validateNotFullIndex
if (target->type == index_target::target_type::full) {
throw exceptions::invalid_request_exception("full() indexes can only be created on frozen collections");
}
// validateIsValuesIndexIfTargetColumnNotCollection
if (!cd->type->is_collection()
&& target->type != index_target::target_type::values) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create index on %s of column %s; only non-frozen collections support %s indexes",
index_target::index_option(target->type),
target->column->name(),
index_target::index_option(target->type)));
}
// validateTargetColumnIsMapIfIndexInvolvesKeys
if (target->type == index_target::target_type::keys
|| target->type == index_target::target_type::keys_and_values) {
if (!is_map) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create index on %s of column %s with non-map type",
index_target::index_option(target->type),
target->column->name()));
}
}
}
if (cd->idx_info.index_type != ::index_type::none) {
auto prev_type = index_target::from_column_definition(*cd);
if (is_map && target->type != prev_type) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create index on %s(%s): an index on %s(%s) already exists and indexing "
"a map on more than one dimension at the same time is not currently supported",
index_target::index_option(target->type),
target->column->name(),
index_target::index_option(prev_type),
target->column->name()));
}
if (_if_not_exists) {
return;
} else {
throw exceptions::invalid_request_exception("Index already exists");
}
}
_properties->validate();
// Origin TODO: we could lift that limitation
if ((schema->is_dense() || !schema->thrift().has_compound_comparator()) && cd->kind != column_kind::regular_column) {
throw exceptions::invalid_request_exception("Secondary indexes are not supported on PRIMARY KEY columns in COMPACT STORAGE tables");
}
// It would be possible to support 2ndary index on static columns (but not without modifications of at least ExtendedFilter and
// CompositesIndex) and maybe we should, but that means a query like:
// SELECT * FROM foo WHERE static_column = 'bar'
// would pull the full partition every time the static column of partition is 'bar', which sounds like offering a
// fair potential for foot-shooting, so I prefer leaving that to a follow up ticket once we have identified cases where
// such indexing is actually useful.
if (cd->is_static()) {
throw exceptions::invalid_request_exception("Secondary indexes are not allowed on static columns");
}
if (cd->kind == column_kind::partition_key && cd->is_on_all_components()) {
throw exceptions::invalid_request_exception(
sprint(
"Cannot create secondary index on partition key column %s",
target->column->name()));
}
}
future<bool>
cql3::statements::create_index_statement::announce_migration(distributed<service::storage_proxy>& proxy, bool is_local_only) {
auto schema = proxy.local().get_db().local().find_schema(keyspace(), column_family());
auto target = _raw_target->prepare(schema);
schema_builder cfm(schema);
auto* cd = schema->get_column_definition(target->column->name());
index_info idx = cd->idx_info;
if (idx.index_type != ::index_type::none && _if_not_exists) {
return make_ready_future<bool>(false);
}
if (_properties->is_custom) {
idx.index_type = index_type::custom;
idx.index_options = _properties->get_options();
} else if (schema->thrift().has_compound_comparator()) {
index_options_map options;
if (cd->type->is_collection() && cd->type->is_multi_cell()) {
options[index_target::index_option(target->type)] = "";
}
idx.index_type = index_type::composites;
idx.index_options = options;
} else {
idx.index_type = index_type::keys;
idx.index_options = index_options_map();
}
idx.index_name = _index_name;
cfm.add_default_index_names(proxy.local().get_db().local());
return service::get_local_migration_manager().announce_column_family_update(
cfm.build(), false, is_local_only).then([]() {
return make_ready_future<bool>(true);
});
}
<|endoftext|> |
<commit_before>#include "dispatch_queue.h"
#include <thread>
#include <queue>
struct dispatch_queue_t::impl
{
impl();
static void dispatch_thread_proc(impl *self);
std::queue< std::function< void() > > queue;
std::mutex queue_mtx;
std::condition_variable queue_cond;
std::atomic< bool > quit;
std::thread queue_thread;
using queue_lock_t = std::unique_lock< decltype(queue_mtx) >;
};
void dispatch_queue_t::impl::dispatch_thread_proc(dispatch_queue_t::impl *self)
{
using queue_size_t = decltype(self->queue)::size_type;
while (self->quit == false)
{
queue_lock_t queue_lock(self->queue_mtx);
self->queue_cond.wait(queue_lock, [&self] { return self->queue.size() > 0; });
for (queue_size_t i = 0, n = self->queue.size(); i < n; ++i) {
auto dispatch_func = self->queue.front();
self->queue.pop();
queue_lock.unlock();
dispatch_func();
queue_lock.lock();
}
}
}
dispatch_queue_t::impl::impl()
: quit(false)
, queue_thread(&dispatch_thread_proc, this)
{
}
dispatch_queue_t::dispatch_queue_t()
: m(new impl)
{
}
dispatch_queue_t::~dispatch_queue_t()
{
dispatch_async([this] { m->quit = true; });
m->queue_thread.join();
}
void dispatch_queue_t::dispatch_async(std::function< void() > func)
{
impl::queue_lock_t queue_lock(m->queue_mtx);
m->queue.push(func);
m->queue_cond.notify_one();
}
void dispatch_queue_t::dispatch_sync(std::function< void() > func)
{
std::mutex sync_mtx;
impl::queue_lock_t sync_lock(sync_mtx);
std::condition_variable sync_cond;
auto completed = false;
{
impl::queue_lock_t queue_lock(m->queue_mtx);
m->queue.push(func);
m->queue.push([&] {
std::unique_lock< decltype(sync_mtx) > sync_cb_lock(sync_mtx);
completed = true;
sync_cond.notify_one();
});
m->queue_cond.notify_one();
}
sync_cond.wait(sync_lock, [&completed] { return completed; });
}
void dispatch_queue_t::dispatch_flush()
{
dispatch_sync([]{});
}
<commit_msg>completed is atomic, remove reference capture var names<commit_after>#include "dispatch_queue.h"
#include <thread>
#include <queue>
struct dispatch_queue_t::impl
{
impl();
static void dispatch_thread_proc(impl *self);
std::queue< std::function< void() > > queue;
std::mutex queue_mtx;
std::condition_variable queue_cond;
std::atomic< bool > quit;
std::thread queue_thread;
using queue_lock_t = std::unique_lock< decltype(queue_mtx) >;
};
void dispatch_queue_t::impl::dispatch_thread_proc(dispatch_queue_t::impl *self)
{
using queue_size_t = decltype(self->queue)::size_type;
while (self->quit == false)
{
queue_lock_t queue_lock(self->queue_mtx);
self->queue_cond.wait(queue_lock, [&] { return self->queue.size() > 0; });
for (queue_size_t i = 0, n = self->queue.size(); i < n; ++i) {
auto dispatch_func = self->queue.front();
self->queue.pop();
queue_lock.unlock();
dispatch_func();
queue_lock.lock();
}
}
}
dispatch_queue_t::impl::impl()
: quit(false)
, queue_thread(&dispatch_thread_proc, this)
{
}
dispatch_queue_t::dispatch_queue_t()
: m(new impl)
{
}
dispatch_queue_t::~dispatch_queue_t()
{
dispatch_async([this] { m->quit = true; });
m->queue_thread.join();
}
void dispatch_queue_t::dispatch_async(std::function< void() > func)
{
impl::queue_lock_t queue_lock(m->queue_mtx);
m->queue.push(func);
m->queue_cond.notify_one();
}
void dispatch_queue_t::dispatch_sync(std::function< void() > func)
{
std::mutex sync_mtx;
impl::queue_lock_t sync_lock(sync_mtx);
std::condition_variable sync_cond;
std::atomic< bool > completed(false);
{
impl::queue_lock_t queue_lock(m->queue_mtx);
m->queue.push(func);
m->queue.push([&] {
std::unique_lock< decltype(sync_mtx) > sync_cb_lock(sync_mtx);
completed = true;
sync_cond.notify_one();
});
m->queue_cond.notify_one();
}
sync_cond.wait(sync_lock, [&] { return completed.load(); });
}
void dispatch_queue_t::dispatch_flush()
{
dispatch_sync([]{});
}
<|endoftext|> |
<commit_before><commit_msg>Changed license and added #ifdef.<commit_after><|endoftext|> |
<commit_before>#ifdef _WIN32
#define NOMINMAX
#include <windows.h>
#endif
#include "SE_Screen.h"
int main()
{
sf::ContextSettings settings;
settings.DepthBits = 24; // set 24 bits Z-buffer
settings.StencilBits = 8; // set 8 bits stencil-buffer
// settings.AntialiasingLevel = 2; // set 2x antialiasing
sf::Window app(sf::VideoMode(640, 480, 32), "SpeakEasy, v0.2.1", sf::Style::Resize | sf::Style::Close, settings);
app.SetFramerateLimit(10);
app.ShowMouseCursor(false);
SE_Screen vl_screen;
vl_screen.initializeGL();
vl_screen.resizeGL(640, 480);
while (app.IsOpened())
{
// Process events
sf::Event event;
while (app.PollEvent(event))
{
// Close window : exit
if (event.Type == sf::Event::Closed)
app.Close();
// Escape key : exit
if ((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape))
{
app.Close();
}
else if ((event.Type == sf::Event::KeyPressed))
{
vl_screen.keyPressEvent(event.Key.Code);
}
if (event.Type == sf::Event::KeyReleased)
{
vl_screen.keyReleaseEvent(event.Key.Code);
}
if (event.Type == sf::Event::MouseMoved)
{
vl_screen.mouseMoveEvent(&app, event.MouseMove.X, event.MouseMove.Y);
}
// Adjust the viewport when the window is resized
if (event.Type == sf::Event::Resized)
{
vl_screen.resizeGL(event.Size.Width, event.Size.Height);
}
}
vl_screen.paintGL();
app.Display();
}
return EXIT_SUCCESS;
}
<commit_msg>- Revert framerate to 60<commit_after>#ifdef _WIN32
#define NOMINMAX
#include <windows.h>
#endif
#include "SE_Screen.h"
int main()
{
sf::ContextSettings settings;
settings.DepthBits = 24; // set 24 bits Z-buffer
settings.StencilBits = 8; // set 8 bits stencil-buffer
// settings.AntialiasingLevel = 2; // set 2x antialiasing
sf::Window app(sf::VideoMode(640, 480, 32), "SpeakEasy, v0.2.1", sf::Style::Resize | sf::Style::Close, settings);
app.SetFramerateLimit(60);
app.ShowMouseCursor(false);
SE_Screen vl_screen;
vl_screen.initializeGL();
vl_screen.resizeGL(640, 480);
while (app.IsOpened())
{
// Process events
sf::Event event;
while (app.PollEvent(event))
{
// Close window : exit
if (event.Type == sf::Event::Closed)
app.Close();
// Escape key : exit
if ((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape))
{
app.Close();
}
else if ((event.Type == sf::Event::KeyPressed))
{
vl_screen.keyPressEvent(event.Key.Code);
}
if (event.Type == sf::Event::KeyReleased)
{
vl_screen.keyReleaseEvent(event.Key.Code);
}
if (event.Type == sf::Event::MouseMoved)
{
vl_screen.mouseMoveEvent(&app, event.MouseMove.X, event.MouseMove.Y);
}
// Adjust the viewport when the window is resized
if (event.Type == sf::Event::Resized)
{
vl_screen.resizeGL(event.Size.Width, event.Size.Height);
}
}
vl_screen.paintGL();
app.Display();
}
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <map>
#include <utility>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <vector>
#include <string>
#include <iostream>
#include "functions.h"
int main(int argc, char** argv) {
std::string prompt;
getPrompt(prompt);
bool quit = false;
// print welcome message and prompt
printf("Welcome to rshell!\n");
while (!quit) {
// holds a single command and its arguments
Command_t cmd;
// holds multiple commands
std::vector<Command_t> cmds;
// hold a raw line of input
std::string line;
// print prompt and get a line of text (done in condition)
printf("%s", prompt.c_str());
preProcessLine(line);
int mode = GETWORD;
unsigned begin = 0;
// prepare cmd
cmd.connector = NONE;
// syntax error flag
bool se = false;
// starts with a connector? I don't think so
if (line.size() > 0 && isConn(line[0]) && line[0] != ';') {
se = true;
} else if (line.size() > 0 && (isRedir(line[0]) || isdigit(line[0]))) {
mode = GETREDIR;
}
// handle the input
for(unsigned i = 0; i < line.size() && !se; ++i) {
bool con = isConn(line[i]);
// bool dig = isdigit(line[i]);
bool redir = isRedir(line[i]);
bool space = isspace(line[i]);
// if we're getting a word and there's a whitespace or connector here
if (mode == GETWORD && (space || con || redir)) {
// only happens for blank lines:
if (i == 0 && con) break;
if (redir) {
mode = GETREDIR;
continue;
}
// chunk the last term and throw it into the vector
addArg(cmd, line, begin, i);
if (space) {
mode = TRIMSPACE;
} else if (con) {
handleCon(cmds, cmd, line, mode, begin, i, se);
}
} else if (mode == TRIMSPACE && !space) {
if (con && cmd.args.empty() && line[i] != ';') {
se = true;
} else if (con) {
handleCon(cmds, cmd, line, mode, begin, i, se);
} else if (redir) {
begin = i;
mode = GETREDIR;
} else {
begin = i;
mode = GETWORD;
}
} else if (mode == HANDLESEMI && line[i] != ';') {
if (isConn(line[i])) {
se = true;
} else if (isspace(line[i])) {
mode = TRIMSPACE;
} else { // it's a word
begin = i;
mode = GETWORD;
}
} else if (mode == GETREDIR && line[i] == '"') {
mode = GETSTRING;
} else if (mode == GETREDIR && space) {
handleRedir(cmds, cmd, line, mode, begin, i, se);
mode = TRIMSPACE;
} else if (mode == GETSTRING && line[i] == '"') {
mode = ENDQUOTE;
} else if (mode == ENDQUOTE) {
if (space) {
handleRedir(cmds, cmd, line, mode, begin, i, se);
mode = TRIMSPACE;
} else {
se = true;
continue;
}
}
}
// if the last command has a continuation connector, syntax error
if (cmds.size() > 0 && (cmds[cmds.size()-1].connector == AND
|| cmds[cmds.size()-1].connector == OR
|| cmds[cmds.size()-1].connector == PIPE)) {
se = true;
}
if (mode == GETSTRING) se = true;
// if there was a syntax error
if (se) {
printf("Syntax error\n");
continue;
}
/*
for(unsigned i = 0; i < cmds.size(); ++i) {
for(unsigned j = 0; j < cmds[i].args.size(); ++j) {
printf("cmd %d arg %d: \"%s\"\n", i, j, cmds[i].args[j]);
}
if (cmds[i].connector == NONE) printf("connector: NONE\n");
else if (cmds[i].connector == AND) printf("connector: AND\n");
else if (cmds[i].connector == OR) printf("connector: OR\n");
else if (cmds[i].connector == SEMI) printf("connector: SEMI\n");
else if (cmds[i].connector == PIPE) printf("connector: PIPE\n");
printf("file descriptor modifications:\n");
for(unsigned j = 0; j < cmds[i].fdChanges.size(); ++j) {
if (cmds[i].fdChanges[j].type == INPUT) {
printf("change fd %d to ",
(cmds[i].fdChanges[j].orig == DEFAULT) ? 0 :
cmds[i].fdChanges[j].orig);
if (cmds[i].fdChanges[j].moveTo == UNDEFINED)
printf("UNDEFINED\n");
else if (cmds[i].fdChanges[j].moveTo == FROMSTR)
printf("FROMSTR (\"%s\")\n", cmds[i].fdChanges[j].s.c_str());
else
printf("Some other fd (%d)\n", cmds[i].fdChanges[j].moveTo);
}
if (cmds[i].fdChanges[j].type == OUTPUT) {
printf("change fd %d to ",
(cmds[i].fdChanges[j].orig == DEFAULT) ? 1 :
cmds[i].fdChanges[j].orig);
if (cmds[i].fdChanges[j].moveTo == UNDEFINED)
printf("UNDEFINED\n");
else
printf("Some other fd (%d)\n", cmds[i].fdChanges[j].moveTo);
}
}
}
// *///
// now to execute all the commands
int pa[2];
for(unsigned i = 0; i < cmds.size(); ++i) {
size_t argsSize = cmds[i].args.size();
int exitStatus = 0;
char* arg = cmds[i].args[0];
if (strcmp(arg, "exit") == 0) {
quit = true;
break;
}
char** argv = new char*[argsSize+1];
for(unsigned j = 0; j < argsSize; ++j) {
argv[j] = cmds[i].args[j];
}
argv[argsSize] = 0;
if (cmds[i].connector == PIPE) {
// 1. make pipe
if (-1 == pipe(pa)) {
perror("pipe");
exit(1);
}
// 2. this program gets output and next program gets input
// this program:
fdChange_t outfdC(1, pa[1], OUTPUT);
fdChange_t infdC(0, pa[0], INPUT);
cmds[i].fdChanges.push_back(outfdC);
cmds[i].closefd.push_back(pa[1]);
// next program:
cmds[i+1].fdChanges.push_back(infdC);
cmds[i+1].closefd.push_back(pa[0]);
}
std::map<int, fdData_t> fds;
for(unsigned j = 0; j < cmds[i].fdChanges.size(); ++j) {
int o = cmds[i].fdChanges[j].orig;
int mt = cmds[i].fdChanges[j].moveTo;
int t = cmds[i].fdChanges[j].type;
std::string str = cmds[i].fdChanges[j].s;
if (t == INPUT) {
if (mt == FILEIN) {
fds.insert(std::pair<int, fdData_t>(o, fdData_t(-1, DT_FIN, str)));
// printf("Adding %d pointing to the file %s in input mode\n", o, str.c_str());
} else if (mt == FROMSTR) {
fds.insert(std::pair<int, fdData_t>(o, fdData_t(-1, DT_STR, str)));
// printf("Adding %d pointing to the string %s in input mode\n", o, str.c_str());
} else {
fds.insert(std::pair<int, fdData_t>(o, fdData_t(mt, DT_FDIN, str)));
// printf("Adding %d pointing to the fd %d in input mode\n", mt, o);
}
} else if (t == OUTPUT) {
if (mt == FILEOUT) {
fds.insert(std::pair<int, fdData_t>(-1, fdData_t(o, DT_FOW, str)));
// printf("Adding %d pointing to the file %s in output write mode\n", o, str.c_str());
} else if (mt == FILEAPP) {
// if (fds
fds.insert(std::pair<int, fdData_t>(-1, fdData_t(o, DT_FOA, str)));
// printf("Adding %d pointing to the file %s in output append mode\n", o, str.c_str());
} else {
fds.insert(std::pair<int, fdData_t>(mt, fdData_t(o, DT_FDO, str)));
// printf("Adding %d pointing to the fd %d in output mode\n", o, mt);
}
}
}
debugMap(fds);
// arg and argv are now prepared
pid_t pid = fork();
if (-1 == pid) {
perror("fork");
exit(1); // fatal error
} else if (0 == pid) { // child process
deltaFD(fds);
if (-1 == execvp(arg, argv)) {
// if there's a return value (-1), there was a problem
perror(arg);
delete[] argv;
exit(1);
}
} else { // parent process
// close current fd's
/*
for(unsigned j = 0; j < cmds[i].closefd.size(); ++j) {
if (-1 == close(cmds[i].closefd[j])) {
perror("closing in parent");
exit(1);
}
} */
// only wait for non-pipes
if (cmds[i].connector != PIPE && -1 == waitpid(pid, &exitStatus, 0)) {
perror("waitpid");
exit(1);
}
}
if (!exitStatus) { // all is good (0)
while (i < cmds.size() && cmds[i].connector == OR) {
++i;
}
} else { // last command failed
while (i < cmds.size() && cmds[i].connector == AND) {
++i;
}
}
}
// deallocate allocated memory
for(unsigned i = 0; i < cmds.size(); ++i) {
for(unsigned j = 0; j < cmds[i].args.size(); ++j) {
delete[] cmds[i].args[j];
}
}
}
printf("Goodbye!\n");
return 0;
}
<commit_msg>removed execvp and added ability to manually search for paths<commit_after>#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <map>
#include <utility>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <vector>
#include <string>
#include <iostream>
#include "functions.h"
int main(int argc, char** argv) {
std::string prompt;
getPrompt(prompt);
bool quit = false;
// print welcome message and prompt
printf("Welcome to rshell!\n");
while (!quit) {
// holds a single command and its arguments
Command_t cmd;
// holds multiple commands
std::vector<Command_t> cmds;
// hold a raw line of input
std::string line;
// print prompt and get a line of text (done in condition)
printf("%s", prompt.c_str());
preProcessLine(line);
int mode = GETWORD;
unsigned begin = 0;
// prepare cmd
cmd.connector = NONE;
// syntax error flag
bool se = false;
// starts with a connector? I don't think so
if (line.size() > 0 && isConn(line[0]) && line[0] != ';') {
se = true;
} else if (line.size() > 0 && (isRedir(line[0]) || isdigit(line[0]))) {
mode = GETREDIR;
}
// handle the input
for(unsigned i = 0; i < line.size() && !se; ++i) {
bool con = isConn(line[i]);
// bool dig = isdigit(line[i]);
bool redir = isRedir(line[i]);
bool space = isspace(line[i]);
// if we're getting a word and there's a whitespace or connector here
if (mode == GETWORD && (space || con || redir)) {
// only happens for blank lines:
if (i == 0 && con) break;
if (redir) {
mode = GETREDIR;
continue;
}
// chunk the last term and throw it into the vector
addArg(cmd, line, begin, i);
if (space) {
mode = TRIMSPACE;
} else if (con) {
handleCon(cmds, cmd, line, mode, begin, i, se);
}
} else if (mode == TRIMSPACE && !space) {
if (con && cmd.args.empty() && line[i] != ';') {
se = true;
} else if (con) {
handleCon(cmds, cmd, line, mode, begin, i, se);
} else if (redir) {
begin = i;
mode = GETREDIR;
} else {
begin = i;
mode = GETWORD;
}
} else if (mode == HANDLESEMI && line[i] != ';') {
if (isConn(line[i])) {
se = true;
} else if (isspace(line[i])) {
mode = TRIMSPACE;
} else { // it's a word
begin = i;
mode = GETWORD;
}
} else if (mode == GETREDIR && line[i] == '"') {
mode = GETSTRING;
} else if (mode == GETREDIR && space) {
handleRedir(cmds, cmd, line, mode, begin, i, se);
mode = TRIMSPACE;
} else if (mode == GETSTRING && line[i] == '"') {
mode = ENDQUOTE;
} else if (mode == ENDQUOTE) {
if (space) {
handleRedir(cmds, cmd, line, mode, begin, i, se);
mode = TRIMSPACE;
} else {
se = true;
continue;
}
}
}
// if the last command has a continuation connector, syntax error
if (cmds.size() > 0 && (cmds[cmds.size()-1].connector == AND
|| cmds[cmds.size()-1].connector == OR
|| cmds[cmds.size()-1].connector == PIPE)) {
se = true;
}
if (mode == GETSTRING) se = true;
// if there was a syntax error
if (se) {
printf("Syntax error\n");
continue;
}
/* code for debugging
for(unsigned i = 0; i < cmds.size(); ++i) {
for(unsigned j = 0; j < cmds[i].args.size(); ++j) {
printf("cmd %d arg %d: \"%s\"\n", i, j, cmds[i].args[j]);
}
if (cmds[i].connector == NONE) printf("connector: NONE\n");
else if (cmds[i].connector == AND) printf("connector: AND\n");
else if (cmds[i].connector == OR) printf("connector: OR\n");
else if (cmds[i].connector == SEMI) printf("connector: SEMI\n");
else if (cmds[i].connector == PIPE) printf("connector: PIPE\n");
printf("file descriptor modifications:\n");
for(unsigned j = 0; j < cmds[i].fdChanges.size(); ++j) {
if (cmds[i].fdChanges[j].type == INPUT) {
printf("change fd %d to ",
(cmds[i].fdChanges[j].orig == DEFAULT) ? 0 :
cmds[i].fdChanges[j].orig);
if (cmds[i].fdChanges[j].moveTo == UNDEFINED)
printf("UNDEFINED\n");
else if (cmds[i].fdChanges[j].moveTo == FROMSTR)
printf("FROMSTR (\"%s\")\n", cmds[i].fdChanges[j].s.c_str());
else
printf("Some other fd (%d)\n", cmds[i].fdChanges[j].moveTo);
}
if (cmds[i].fdChanges[j].type == OUTPUT) {
printf("change fd %d to ",
(cmds[i].fdChanges[j].orig == DEFAULT) ? 1 :
cmds[i].fdChanges[j].orig);
if (cmds[i].fdChanges[j].moveTo == UNDEFINED)
printf("UNDEFINED\n");
else
printf("Some other fd (%d)\n", cmds[i].fdChanges[j].moveTo);
}
}
}
// */
// now to execute all the commands
// pipe
int pa[2];
std::vector<char*> paths;
// getPaths
fillPaths(paths);
for(unsigned cmdi = 0; cmdi < cmds.size(); ++cmdi) {
size_t argsSize = cmds[cmdi].args.size();
int exitStatus = 0;
char* arg = cmds[cmdi].args[0];
if (strcmp(arg, "exit") == 0) {
quit = true;
break;
}
char** argv = new char*[argsSize+1];
for(unsigned j = 0; j < argsSize; ++j) {
argv[j] = cmds[cmdi].args[j];
}
argv[argsSize] = 0;
if (cmds[cmdi].connector == PIPE) {
// 1. make pipe
if (-1 == pipe(pa)) {
perror("pipe");
exit(1);
}
// 2. this program gets output and next program gets input
// this program:
fdChange_t outfdC(1, pa[1], OUTPUT);
fdChange_t infdC(0, pa[0], INPUT);
cmds[cmdi].fdChanges.push_back(outfdC);
cmds[cmdi].closefd.push_back(pa[1]);
// next program:
cmds[cmdi+1].fdChanges.push_back(infdC);
cmds[cmdi+1].closefd.push_back(pa[0]);
}
std::map<int, fdData_t> fds;
for(unsigned j = 0; j < cmds[cmdi].fdChanges.size(); ++j) {
int o = cmds[cmdi].fdChanges[j].orig;
int mt = cmds[cmdi].fdChanges[j].moveTo;
int t = cmds[cmdi].fdChanges[j].type;
std::string str = cmds[cmdi].fdChanges[j].s;
if (t == INPUT) {
if (mt == FILEIN) {
fds.insert(std::pair<int, fdData_t>(o, fdData_t(-1, DT_FIN, str)));
// printf("Adding %d pointing to the file %s in input mode\n", o, str.c_str());
} else if (mt == FROMSTR) {
fds.insert(std::pair<int, fdData_t>(o, fdData_t(-1, DT_STR, str)));
// printf("Adding %d pointing to the string %s in input mode\n", o, str.c_str());
} else {
fds.insert(std::pair<int, fdData_t>(o, fdData_t(mt, DT_FDIN, str)));
// printf("Adding %d pointing to the fd %d in input mode\n", mt, o);
}
} else if (t == OUTPUT) {
if (mt == FILEOUT) {
fds.insert(std::pair<int, fdData_t>(-1, fdData_t(o, DT_FOW, str)));
// printf("Adding %d pointing to the file %s in output write mode\n", o, str.c_str());
} else if (mt == FILEAPP) {
// if (fds
fds.insert(std::pair<int, fdData_t>(-1, fdData_t(o, DT_FOA, str)));
// printf("Adding %d pointing to the file %s in output append mode\n", o, str.c_str());
} else {
fds.insert(std::pair<int, fdData_t>(mt, fdData_t(o, DT_FDO, str)));
// printf("Adding %d pointing to the fd %d in output mode\n", o, mt);
}
}
}
debugMap(fds);
// arg and argv are now prepared
pid_t pid = fork();
if (-1 == pid) {
perror("fork");
exit(1); // fatal error
} else if (0 == pid) { // child process
deltaFD(fds);
for(unsigned i = 0; i < paths.size(); ++i) {
char* executable = new char[strlen(paths[i]) + strlen(arg) + 2];
strcpy(executable, paths[i]);
strcat(executable, "/");
strcat(executable, arg);
struct stat statRes;
if (-1 != stat(executable, &statRes)) {
if (-1 == execv(executable, argv)) {
// if there's a return value (-1), there was a problem
debug("executing");
perror(executable);
delete[] argv;
delete[] executable;
exit(1);
}
}
errno = 0;
delete[] executable;
}
fprintf(stderr, "%s: command not found\n", arg);
exit(1);
} else { // parent process
// close current fd's
/*
for(unsigned j = 0; j < cmds[cmdi].closefd.size(); ++j) {
if (-1 == close(cmds[cmdi].closefd[j])) {
perror("closing in parent");
exit(1);
}
} */
// only wait for non-pipes
if (cmds[cmdi].connector != PIPE && -1 == waitpid(pid, &exitStatus, 0)) {
perror("waitpid");
exit(1);
}
}
if (!exitStatus) { // all is good (0)
while (cmdi < cmds.size() && cmds[cmdi].connector == OR) {
++cmdi;
}
} else { // last command failed
while (cmdi < cmds.size() && cmds[cmdi].connector == AND) {
++cmdi;
}
}
}
// deallocate allocated memory
for(unsigned i = 0; i < cmds.size(); ++i) {
for(unsigned j = 0; j < cmds[i].args.size(); ++j) {
delete[] cmds[i].args[j];
}
}
for(unsigned i = 0; i < paths.size(); ++i) {
delete[] paths[i];
}
}
printf("Goodbye!\n");
return 0;
}
<|endoftext|> |
<commit_before>#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <getopt.h>
#include <string>
#include <vector>
#include "sequence.hpp"
#include "polisher.hpp"
#ifdef CUDA_ENABLED
#include "cuda/cudapolisher.hpp"
#endif
#ifndef RACON_VERSION
#error "Undefined version for Racon. Please pass version using -DRACON_VERSION macro."
#endif
static const char* version = RACON_VERSION;
static const int32_t CUDAALIGNER_INPUT_CODE = 10000;
static const int32_t CUDAALIGNER_BAND_WIDTH_INPUT_CODE = 10001;
static struct option options[] = {
{"include-unpolished", no_argument, 0, 'u'},
{"fragment-correction", no_argument, 0, 'f'},
{"window-length", required_argument, 0, 'w'},
{"quality-threshold", required_argument, 0, 'q'},
{"error-threshold", required_argument, 0, 'e'},
{"no-trimming", no_argument, 0, 'T'},
{"match", required_argument, 0, 'm'},
{"mismatch", required_argument, 0, 'x'},
{"gap", required_argument, 0, 'g'},
{"threads", required_argument, 0, 't'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
#ifdef CUDA_ENABLED
{"cudapoa-batches", optional_argument, 0, 'c'},
{"cuda-banded-alignment", no_argument, 0, 'b'},
{"cudaaligner-batches", required_argument, 0, CUDAALIGNER_INPUT_CODE},
{"cudaaligner-band-width", required_argument, 0, CUDAALIGNER_BAND_WIDTH_INPUT_CODE},
#endif
{0, 0, 0, 0}
};
void help();
int main(int argc, char** argv) {
std::vector<std::string> input_paths;
uint32_t window_length = 500;
double quality_threshold = 10.0;
double error_threshold = 0.3;
bool trim = true;
int8_t match = 3;
int8_t mismatch = -5;
int8_t gap = -4;
uint32_t type = 0;
bool drop_unpolished_sequences = true;
uint32_t num_threads = 1;
uint32_t cudapoa_batches = 0;
uint32_t cudaaligner_batches = 0;
uint32_t cudaaligner_band_width = 1024;
bool cuda_banded_alignment = false;
std::string optstring = "ufw:q:e:m:x:g:t:h";
#ifdef CUDA_ENABLED
optstring += "bc::";
#endif
int32_t argument;
while ((argument = getopt_long(argc, argv, optstring.c_str(), options, nullptr)) != -1) {
switch (argument) {
case 'u':
drop_unpolished_sequences = false;
break;
case 'f':
type = 1;
break;
case 'w':
window_length = atoi(optarg);
break;
case 'q':
quality_threshold = atof(optarg);
break;
case 'e':
error_threshold = atof(optarg);
break;
case 'T':
trim = false;
break;
case 'm':
match = atoi(optarg);
break;
case 'x':
mismatch = atoi(optarg);
break;
case 'g':
gap = atoi(optarg);
break;
case 't':
num_threads = atoi(optarg);
break;
case 'v':
printf("%s\n", version);
exit(0);
case 'h':
help();
exit(0);
#ifdef CUDA_ENABLED
case 'c':
//if option c encountered, cudapoa_batches initialized with a default value of 1.
cudapoa_batches = 1;
// next text entry is not an option, assuming it's the arg for option 'c'
if (optarg == NULL && argv[optind] != NULL
&& argv[optind][0] != '-') {
cudapoa_batches = atoi(argv[optind++]);
}
// optional argument provided in the ususal way
if (optarg != NULL) {
cudapoa_batches = atoi(optarg);
}
break;
case 'b':
cuda_banded_alignment = true;
break;
case CUDAALIGNER_INPUT_CODE: // cudaaligner-batches
cudaaligner_batches = atoi(optarg);
break;
case CUDAALIGNER_BAND_WIDTH_INPUT_CODE: // cudaaligner-band-width
cudaaligner_band_width = atoi(optarg);
break;
#endif
default:
exit(1);
}
}
for (int32_t i = optind; i < argc; ++i) {
input_paths.emplace_back(argv[i]);
}
if (input_paths.size() < 3) {
fprintf(stderr, "[racon::] error: missing input file(s)!\n");
help();
exit(1);
}
auto polisher = racon::createPolisher(input_paths[0], input_paths[1],
input_paths[2], type == 0 ? racon::PolisherType::kC :
racon::PolisherType::kF, window_length, quality_threshold,
error_threshold, trim, match, mismatch, gap, num_threads,
cudapoa_batches, cuda_banded_alignment, cudaaligner_batches,
cudaaligner_band_width);
polisher->initialize();
std::vector<std::unique_ptr<racon::Sequence>> polished_sequences;
polisher->polish(polished_sequences, drop_unpolished_sequences);
for (const auto& it: polished_sequences) {
fprintf(stdout, ">%s\n%s\n", it->name().c_str(), it->data().c_str());
}
return 0;
}
void help() {
printf(
"usage: racon [options ...] <sequences> <overlaps> <target sequences>\n"
"\n"
" #default output is stdout\n"
" <sequences>\n"
" input file in FASTA/FASTQ format (can be compressed with gzip)\n"
" containing sequences used for correction\n"
" <overlaps>\n"
" input file in MHAP/PAF/SAM format (can be compressed with gzip)\n"
" containing overlaps between sequences and target sequences\n"
" <target sequences>\n"
" input file in FASTA/FASTQ format (can be compressed with gzip)\n"
" containing sequences which will be corrected\n"
"\n"
" options:\n"
" -u, --include-unpolished\n"
" output unpolished target sequences\n"
" -f, --fragment-correction\n"
" perform fragment correction instead of contig polishing\n"
" (overlaps file should contain dual/self overlaps!)\n"
" -w, --window-length <int>\n"
" default: 500\n"
" size of window on which POA is performed\n"
" -q, --quality-threshold <float>\n"
" default: 10.0\n"
" threshold for average base quality of windows used in POA\n"
" -e, --error-threshold <float>\n"
" default: 0.3\n"
" maximum allowed error rate used for filtering overlaps\n"
" --no-trimming\n"
" disables consensus trimming at window ends\n"
" -m, --match <int>\n"
" default: 3\n"
" score for matching bases\n"
" -x, --mismatch <int>\n"
" default: -5\n"
" score for mismatching bases\n"
" -g, --gap <int>\n"
" default: -4\n"
" gap penalty (must be negative)\n"
" -t, --threads <int>\n"
" default: 1\n"
" number of threads\n"
" --version\n"
" prints the version number\n"
" -h, --help\n"
" prints the usage\n"
#ifdef CUDA_ENABLED
" -c, --cudapoa-batches <int>\n"
" default: 0\n"
" number of batches for CUDA accelerated polishing per GPU\n"
" -b, --cuda-banded-alignment\n"
" use banding approximation for alignment on GPU\n"
" --cudaaligner-batches <int>\n"
" default: 0\n"
" number of batches for CUDA accelerated alignment per GPU\n"
" --cudaaligner-band-width <int>\n"
" default: 0\n"
" Band width for cuda alignment. Must be >= 0. Non-zero allows user defined \n"
" band width, whereas 0 implies auto band width determination.\n"
#endif
);
}
<commit_msg>[main] update cudaaligner default band to 0<commit_after>#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <getopt.h>
#include <string>
#include <vector>
#include "sequence.hpp"
#include "polisher.hpp"
#ifdef CUDA_ENABLED
#include "cuda/cudapolisher.hpp"
#endif
#ifndef RACON_VERSION
#error "Undefined version for Racon. Please pass version using -DRACON_VERSION macro."
#endif
static const char* version = RACON_VERSION;
static const int32_t CUDAALIGNER_INPUT_CODE = 10000;
static const int32_t CUDAALIGNER_BAND_WIDTH_INPUT_CODE = 10001;
static struct option options[] = {
{"include-unpolished", no_argument, 0, 'u'},
{"fragment-correction", no_argument, 0, 'f'},
{"window-length", required_argument, 0, 'w'},
{"quality-threshold", required_argument, 0, 'q'},
{"error-threshold", required_argument, 0, 'e'},
{"no-trimming", no_argument, 0, 'T'},
{"match", required_argument, 0, 'm'},
{"mismatch", required_argument, 0, 'x'},
{"gap", required_argument, 0, 'g'},
{"threads", required_argument, 0, 't'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
#ifdef CUDA_ENABLED
{"cudapoa-batches", optional_argument, 0, 'c'},
{"cuda-banded-alignment", no_argument, 0, 'b'},
{"cudaaligner-batches", required_argument, 0, CUDAALIGNER_INPUT_CODE},
{"cudaaligner-band-width", required_argument, 0, CUDAALIGNER_BAND_WIDTH_INPUT_CODE},
#endif
{0, 0, 0, 0}
};
void help();
int main(int argc, char** argv) {
std::vector<std::string> input_paths;
uint32_t window_length = 500;
double quality_threshold = 10.0;
double error_threshold = 0.3;
bool trim = true;
int8_t match = 3;
int8_t mismatch = -5;
int8_t gap = -4;
uint32_t type = 0;
bool drop_unpolished_sequences = true;
uint32_t num_threads = 1;
uint32_t cudapoa_batches = 0;
uint32_t cudaaligner_batches = 0;
uint32_t cudaaligner_band_width = 0;
bool cuda_banded_alignment = false;
std::string optstring = "ufw:q:e:m:x:g:t:h";
#ifdef CUDA_ENABLED
optstring += "bc::";
#endif
int32_t argument;
while ((argument = getopt_long(argc, argv, optstring.c_str(), options, nullptr)) != -1) {
switch (argument) {
case 'u':
drop_unpolished_sequences = false;
break;
case 'f':
type = 1;
break;
case 'w':
window_length = atoi(optarg);
break;
case 'q':
quality_threshold = atof(optarg);
break;
case 'e':
error_threshold = atof(optarg);
break;
case 'T':
trim = false;
break;
case 'm':
match = atoi(optarg);
break;
case 'x':
mismatch = atoi(optarg);
break;
case 'g':
gap = atoi(optarg);
break;
case 't':
num_threads = atoi(optarg);
break;
case 'v':
printf("%s\n", version);
exit(0);
case 'h':
help();
exit(0);
#ifdef CUDA_ENABLED
case 'c':
//if option c encountered, cudapoa_batches initialized with a default value of 1.
cudapoa_batches = 1;
// next text entry is not an option, assuming it's the arg for option 'c'
if (optarg == NULL && argv[optind] != NULL
&& argv[optind][0] != '-') {
cudapoa_batches = atoi(argv[optind++]);
}
// optional argument provided in the ususal way
if (optarg != NULL) {
cudapoa_batches = atoi(optarg);
}
break;
case 'b':
cuda_banded_alignment = true;
break;
case CUDAALIGNER_INPUT_CODE: // cudaaligner-batches
cudaaligner_batches = atoi(optarg);
break;
case CUDAALIGNER_BAND_WIDTH_INPUT_CODE: // cudaaligner-band-width
cudaaligner_band_width = atoi(optarg);
break;
#endif
default:
exit(1);
}
}
for (int32_t i = optind; i < argc; ++i) {
input_paths.emplace_back(argv[i]);
}
if (input_paths.size() < 3) {
fprintf(stderr, "[racon::] error: missing input file(s)!\n");
help();
exit(1);
}
auto polisher = racon::createPolisher(input_paths[0], input_paths[1],
input_paths[2], type == 0 ? racon::PolisherType::kC :
racon::PolisherType::kF, window_length, quality_threshold,
error_threshold, trim, match, mismatch, gap, num_threads,
cudapoa_batches, cuda_banded_alignment, cudaaligner_batches,
cudaaligner_band_width);
polisher->initialize();
std::vector<std::unique_ptr<racon::Sequence>> polished_sequences;
polisher->polish(polished_sequences, drop_unpolished_sequences);
for (const auto& it: polished_sequences) {
fprintf(stdout, ">%s\n%s\n", it->name().c_str(), it->data().c_str());
}
return 0;
}
void help() {
printf(
"usage: racon [options ...] <sequences> <overlaps> <target sequences>\n"
"\n"
" #default output is stdout\n"
" <sequences>\n"
" input file in FASTA/FASTQ format (can be compressed with gzip)\n"
" containing sequences used for correction\n"
" <overlaps>\n"
" input file in MHAP/PAF/SAM format (can be compressed with gzip)\n"
" containing overlaps between sequences and target sequences\n"
" <target sequences>\n"
" input file in FASTA/FASTQ format (can be compressed with gzip)\n"
" containing sequences which will be corrected\n"
"\n"
" options:\n"
" -u, --include-unpolished\n"
" output unpolished target sequences\n"
" -f, --fragment-correction\n"
" perform fragment correction instead of contig polishing\n"
" (overlaps file should contain dual/self overlaps!)\n"
" -w, --window-length <int>\n"
" default: 500\n"
" size of window on which POA is performed\n"
" -q, --quality-threshold <float>\n"
" default: 10.0\n"
" threshold for average base quality of windows used in POA\n"
" -e, --error-threshold <float>\n"
" default: 0.3\n"
" maximum allowed error rate used for filtering overlaps\n"
" --no-trimming\n"
" disables consensus trimming at window ends\n"
" -m, --match <int>\n"
" default: 3\n"
" score for matching bases\n"
" -x, --mismatch <int>\n"
" default: -5\n"
" score for mismatching bases\n"
" -g, --gap <int>\n"
" default: -4\n"
" gap penalty (must be negative)\n"
" -t, --threads <int>\n"
" default: 1\n"
" number of threads\n"
" --version\n"
" prints the version number\n"
" -h, --help\n"
" prints the usage\n"
#ifdef CUDA_ENABLED
" -c, --cudapoa-batches <int>\n"
" default: 0\n"
" number of batches for CUDA accelerated polishing per GPU\n"
" -b, --cuda-banded-alignment\n"
" use banding approximation for alignment on GPU\n"
" --cudaaligner-batches <int>\n"
" default: 0\n"
" number of batches for CUDA accelerated alignment per GPU\n"
" --cudaaligner-band-width <int>\n"
" default: 0\n"
" Band width for cuda alignment. Must be >= 0. Non-zero allows user defined \n"
" band width, whereas 0 implies auto band width determination.\n"
#endif
);
}
<|endoftext|> |
<commit_before>#include <iostream>
#include "systems/OpenGLSystem.h"
#include "systems/SimplePhysics.h"
#include "systems/FactorySystem.h"
#include "controllers/GLSixDOFViewController.h"
#include "components/ViewMover.h"
#include "SCParser.h"
#if defined OS_Win32
#include "os/win32/win32.h"
#elif defined OS_SDL
#include "os/sdl/SDLSys.h"
#endif
int main(int argCount, char **argValues) {
OpenGLSystem glsys;
SimplePhysics physys;
FactorySystem::getInstance().register_Factory(&glsys);
FactorySystem::getInstance().register_Factory(&physys);
IOpSys* os = nullptr;
#if defined OS_Win32
os = new win32();
#elif defined OS_SDL
os = new SDLSys();
#endif
if(os->CreateGraphicsWindow(1024,768) == 0) {
std::cout << "Error creating window!" << std::endl;
}
const int* version = glsys.Start();
glsys.SetViewportSize(os->GetWindowWidth(), os->GetWindowHeight());
if (version[0] == -1) {
std::cout << "Error starting OpenGL!" << std::endl;
} else {
std::cout << "OpenGL version: " << version[0] << "." << version[1] << std::endl;
}
Sigma::parser::SCParser parser;
if (!parser.Parse("test.sc")) {
assert(0 && "Failed to load entities from file.");
}
for (unsigned int i = 0; i < parser.EntityCount(); ++i) {
const Sigma::parser::Entity* e = parser.GetEntity(i);
for (auto itr = e->components.begin(); itr != e->components.end(); ++itr) {
FactorySystem::getInstance().create(
itr->type,e->id,
const_cast<std::vector<Property>&>(itr->properties));
}
}
std::vector<Property> props;
physys.createViewMover("ViewMover", 9, props);
ViewMover* mover = reinterpret_cast<ViewMover*>(physys.getComponent(9,ViewMover::getStaticComponentID()));
Sigma::event::handler::GLSixDOFViewController cameraController(glsys.View(), mover);
IOpSys::KeyboardEventSystem.Register(&cameraController);
os->SetupTimer();
double delta;
bool isWireframe=false;
while (os->MessageLoop()) {
delta = os->GetDeltaTime();
double deltaSec = (double)delta/100.0f;
if (os->KeyReleased('P', true)) { // Wireframe mode
if (!isWireframe) {
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
isWireframe = true;
} else {
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
isWireframe = false;
}
}
if (os->KeyReleased('M', true)) {
os->ToggleFullscreen();
glsys.SetViewportSize(os->GetWindowWidth(), os->GetWindowHeight());
}
// Pass in delta time in seconds
physys.Update(deltaSec);
if (glsys.Update(delta)) {
os->Present();
}
}
delete os;
return 0;
}
<commit_msg>Removed some unnecessary getInstance calls<commit_after>#include <iostream>
#include "systems/OpenGLSystem.h"
#include "systems/SimplePhysics.h"
#include "systems/FactorySystem.h"
#include "controllers/GLSixDOFViewController.h"
#include "components/ViewMover.h"
#include "SCParser.h"
#if defined OS_Win32
#include "os/win32/win32.h"
#elif defined OS_SDL
#include "os/sdl/SDLSys.h"
#endif
int main(int argCount, char **argValues) {
OpenGLSystem glsys;
SimplePhysics physys;
FactorySystem& factory = FactorySystem::getInstance();
factory.register_Factory(&glsys);
factory.register_Factory(&physys);
IOpSys* os = nullptr;
#if defined OS_Win32
os = new win32();
#elif defined OS_SDL
os = new SDLSys();
#endif
if(os->CreateGraphicsWindow(1024,768) == 0) {
std::cout << "Error creating window!" << std::endl;
}
const int* version = glsys.Start();
glsys.SetViewportSize(os->GetWindowWidth(), os->GetWindowHeight());
if (version[0] == -1) {
std::cout << "Error starting OpenGL!" << std::endl;
} else {
std::cout << "OpenGL version: " << version[0] << "." << version[1] << std::endl;
}
Sigma::parser::SCParser parser;
if (!parser.Parse("test.sc")) {
assert(0 && "Failed to load entities from file.");
}
for (unsigned int i = 0; i < parser.EntityCount(); ++i) {
const Sigma::parser::Entity* e = parser.GetEntity(i);
for (auto itr = e->components.begin(); itr != e->components.end(); ++itr) {
factory.create(
itr->type,e->id,
const_cast<std::vector<Property>&>(itr->properties));
}
}
std::vector<Property> props;
physys.createViewMover("ViewMover", 9, props);
ViewMover* mover = reinterpret_cast<ViewMover*>(physys.getComponent(9,ViewMover::getStaticComponentID()));
Sigma::event::handler::GLSixDOFViewController cameraController(glsys.View(), mover);
IOpSys::KeyboardEventSystem.Register(&cameraController);
os->SetupTimer();
double delta;
bool isWireframe=false;
while (os->MessageLoop()) {
delta = os->GetDeltaTime();
double deltaSec = (double)delta/100.0f;
if (os->KeyReleased('P', true)) { // Wireframe mode
if (!isWireframe) {
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
isWireframe = true;
} else {
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
isWireframe = false;
}
}
if (os->KeyReleased('M', true)) {
os->ToggleFullscreen();
glsys.SetViewportSize(os->GetWindowWidth(), os->GetWindowHeight());
}
// Pass in delta time in seconds
physys.Update(deltaSec);
if (glsys.Update(delta)) {
os->Present();
}
}
delete os;
return 0;
}
<|endoftext|> |
<commit_before>/**
* @file main.cpp
*
* User interface to the face recognition system.
*/
#include <cstdlib>
#include <exception>
#include <getopt.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <mlearn.h>
#include <unistd.h>
using namespace ML;
enum class InputDataType {
None,
Genome,
Image
};
enum class FeatureType {
Identity,
PCA,
LDA,
ICA
};
enum class ClassifierType {
None,
KNN,
Bayes
};
typedef enum {
OPTION_GPU,
OPTION_LOGLEVEL,
OPTION_TRAIN,
OPTION_TEST,
OPTION_STREAM,
OPTION_DATA,
OPTION_PCA,
OPTION_LDA,
OPTION_ICA,
OPTION_KNN,
OPTION_BAYES,
OPTION_PCA_N1,
OPTION_LDA_N1,
OPTION_LDA_N2,
OPTION_ICA_N1,
OPTION_ICA_N2,
OPTION_ICA_NONL,
OPTION_ICA_MAX_ITER,
OPTION_ICA_EPS,
OPTION_KNN_K,
OPTION_KNN_DIST,
OPTION_UNKNOWN = '?'
} option_t;
typedef struct {
bool train;
bool test;
bool stream;
const char *path_train;
const char *path_test;
const char *path_model;
InputDataType data_type;
FeatureType feature_type;
ClassifierType classifier_type;
int pca_n1;
int lda_n1;
int lda_n2;
int ica_n1;
int ica_n2;
ICANonl ica_nonl;
int ica_max_iter;
precision_t ica_eps;
int knn_k;
dist_func_t knn_dist;
} optarg_t;
const std::map<std::string, InputDataType> data_types = {
{ "genome", InputDataType::Genome },
{ "image", InputDataType::Image }
};
const std::map<std::string, dist_func_t> dist_funcs = {
{ "COS", m_dist_COS },
{ "L1", m_dist_L1 },
{ "L2", m_dist_L2 }
};
const std::map<std::string, ICANonl> nonl_funcs = {
{ "pow3", ICANonl::pow3 },
{ "tanh", ICANonl::tanh },
{ "gauss", ICANonl::gauss }
};
/**
* Print command-line usage and help text.
*/
void print_usage()
{
std::cerr <<
"Usage: ./face-rec [options]\n"
"\n"
"Options:\n"
" --gpu enable GPU acceleration\n"
" --loglevel LEVEL set the log level ([1]=info, 2=verbose, 3=debug)\n"
" --train DIRECTORY train a model with a training set\n"
" --test DIRECTORY perform recognition on a test set\n"
" --stream perform recognition on an input stream\n"
" --data data type (genome, [image])\n"
" --pca use PCA for feature extraction\n"
" --lda use LDA for feature extraction\n"
" --ica use ICA for feature extraction\n"
" --knn use the kNN classifier (default)\n"
" --bayes use the Bayes classifier\n"
"\n"
"Hyperparameters:\n"
"PCA:\n"
" --pca_n1 N number of principal components to compute\n"
"\n"
"LDA:\n"
" --lda_n1 N number of principal components to compute\n"
" --lda_n2 N number of Fisherfaces to compute\n"
"\n"
"ICA:\n"
" --ica_n1 N number of principal components to compute\n"
" --ica_n2 N number of independent components to estimate\n"
" --ica_nonl [nonl] nonlinearity function to use ([pow3], tanh, gauss)\n"
" --ica_max_iter N maximum iterations\n"
" --ica_eps X convergence threshold for w\n"
"\n"
"kNN:\n"
" --knn_k N number of nearest neighbors to use\n"
" --knn_dist [dist] distance function to use (L1, [L2], COS)\n";
}
/**
* Parse command-line arguments.
*
* @param argc
* @param argv
*/
optarg_t parse_args(int argc, char **argv)
{
optarg_t args = {
false,
false,
false,
nullptr,
nullptr,
"./model.dat",
InputDataType::Image,
FeatureType::Identity,
ClassifierType::KNN,
-1,
-1, -1,
-1, -1, ICANonl::pow3, 1000, 0.0001f,
1, m_dist_L2
};
struct option long_options[] = {
{ "gpu", no_argument, 0, OPTION_GPU },
{ "loglevel", required_argument, 0, OPTION_LOGLEVEL },
{ "train", required_argument, 0, OPTION_TRAIN },
{ "test", required_argument, 0, OPTION_TEST },
{ "stream", no_argument, 0, OPTION_STREAM },
{ "data", required_argument, 0, OPTION_DATA },
{ "pca", no_argument, 0, OPTION_PCA },
{ "lda", no_argument, 0, OPTION_LDA },
{ "ica", no_argument, 0, OPTION_ICA },
{ "knn", no_argument, 0, OPTION_KNN },
{ "bayes", no_argument, 0, OPTION_BAYES },
{ "pca_n1", required_argument, 0, OPTION_PCA_N1 },
{ "lda_n1", required_argument, 0, OPTION_LDA_N1 },
{ "lda_n2", required_argument, 0, OPTION_LDA_N2 },
{ "ica_n1", required_argument, 0, OPTION_ICA_N1 },
{ "ica_n2", required_argument, 0, OPTION_ICA_N2 },
{ "ica_nonl", required_argument, 0, OPTION_ICA_NONL },
{ "ica_max_iter", required_argument, 0, OPTION_ICA_MAX_ITER },
{ "ica_eps", required_argument, 0, OPTION_ICA_EPS },
{ "knn_k", required_argument, 0, OPTION_KNN_K },
{ "knn_dist", required_argument, 0, OPTION_KNN_DIST },
{ 0, 0, 0, 0 }
};
int opt;
while ( (opt = getopt_long_only(argc, argv, "", long_options, nullptr)) != -1 ) {
switch ( opt ) {
case OPTION_GPU:
GPU = true;
break;
case OPTION_LOGLEVEL:
LOGLEVEL = (logger_level_t) atoi(optarg);
break;
case OPTION_TRAIN:
args.train = true;
args.path_train = optarg;
break;
case OPTION_TEST:
args.test = true;
args.path_test = optarg;
break;
case OPTION_STREAM:
args.stream = true;
break;
case OPTION_DATA:
try {
args.data_type = data_types.at(optarg);
}
catch ( std::exception& e ) {
args.data_type = InputDataType::None;
}
break;
case OPTION_PCA:
args.feature_type = FeatureType::PCA;
break;
case OPTION_LDA:
args.feature_type = FeatureType::LDA;
break;
case OPTION_ICA:
args.feature_type = FeatureType::ICA;
break;
case OPTION_KNN:
args.classifier_type = ClassifierType::KNN;
break;
case OPTION_BAYES:
args.classifier_type = ClassifierType::Bayes;
break;
case OPTION_PCA_N1:
args.pca_n1 = atoi(optarg);
break;
case OPTION_LDA_N1:
args.lda_n1 = atoi(optarg);
break;
case OPTION_LDA_N2:
args.lda_n2 = atoi(optarg);
break;
case OPTION_ICA_N1:
args.ica_n1 = atoi(optarg);
break;
case OPTION_ICA_N2:
args.ica_n2 = atoi(optarg);
break;
case OPTION_ICA_NONL:
try {
args.ica_nonl = nonl_funcs.at(optarg);
}
catch ( std::exception& e ) {
args.ica_nonl = ICANonl::none;
}
break;
case OPTION_ICA_MAX_ITER:
args.ica_max_iter = atoi(optarg);
break;
case OPTION_ICA_EPS:
args.ica_eps = atof(optarg);
break;
case OPTION_KNN_K:
args.knn_k = atoi(optarg);
break;
case OPTION_KNN_DIST:
try {
args.knn_dist = dist_funcs.at(optarg);
}
catch ( std::exception& e ) {
args.knn_dist = nullptr;
}
break;
case OPTION_UNKNOWN:
print_usage();
exit(1);
}
}
return args;
}
/**
* Validate command-line arguments.
*
* @param args
*/
void validate_args(const optarg_t& args)
{
std::vector<std::pair<bool, std::string>> validators = {
{ args.train || args.test, "--train and/or --test are required" },
{ args.data_type != InputDataType::None, "--data must be genome | image" },
{ args.knn_dist != nullptr, "--knn_dist must be L1 | L2 | COS" },
{ args.ica_nonl != ICANonl::none, "--ica_nonl must be pow3 | tanh | gauss" }
};
bool valid = true;
for ( auto v : validators ) {
if ( !v.first ) {
std::cerr << "error: " << v.second << "\n";
valid = false;
}
}
if ( !valid ) {
print_usage();
exit(1);
}
}
int main(int argc, char **argv)
{
// parse command-line arguments
optarg_t args = parse_args(argc, argv);
// validate arguments
validate_args(args);
// initialize GPU if enabled
gpu_init();
// initialize data type
DataType *data_type;
if ( args.data_type == InputDataType::Genome ) {
data_type = new Genome();
}
else if ( args.data_type == InputDataType::Image ) {
data_type = new Image();
}
// initialize feature layer
FeatureLayer *feature;
if ( args.feature_type == FeatureType::Identity ) {
feature = new IdentityLayer();
}
else if ( args.feature_type == FeatureType::PCA ) {
feature = new PCALayer(args.pca_n1);
}
else if ( args.feature_type == FeatureType::LDA ) {
feature = new LDALayer(args.lda_n1, args.lda_n2);
}
else if ( args.feature_type == FeatureType::ICA ) {
feature = new ICALayer(
args.ica_n1,
args.ica_n2,
args.ica_nonl,
args.ica_max_iter,
args.ica_eps
);
}
// initialize classifier layer
ClassifierLayer *classifier;
if ( args.classifier_type == ClassifierType::KNN ) {
classifier = new KNNLayer(args.knn_k, args.knn_dist);
}
else if ( args.classifier_type == ClassifierType::Bayes ) {
classifier = new BayesLayer();
}
// initialize model
ClassificationModel model(feature, classifier);
// run the face recognition system
if ( args.train ) {
Dataset train_set(data_type, args.path_train);
model.train(train_set);
}
else {
model.load(args.path_model);
}
if ( args.test && args.stream ) {
char END = '0';
char READ = '1';
while ( 1 ) {
char c = std::cin.get();
if ( c == END ) {
break;
}
else if ( c == READ ) {
Dataset test_set(data_type, args.path_test, false);
std::vector<DataLabel> Y_pred = model.predict(test_set);
// print results
for ( size_t i = 0; i < test_set.entries().size(); i++ ) {
const DataLabel& y_pred = Y_pred[i];
const DataEntry& entry = test_set.entries()[i];
std::cout << std::left << std::setw(12) << entry.name << " " << y_pred << "\n";
}
}
}
}
else if ( args.test ) {
Dataset test_set(data_type, args.path_test);
std::vector<DataLabel> Y_pred = model.predict(test_set);
model.validate(test_set, Y_pred);
}
else {
model.save(args.path_model);
}
timer_print();
model.print_stats();
gpu_finalize();
return 0;
}
<commit_msg>Added separate path arg for --stream<commit_after>/**
* @file main.cpp
*
* User interface to the face recognition system.
*/
#include <cstdlib>
#include <exception>
#include <getopt.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <mlearn.h>
#include <unistd.h>
using namespace ML;
enum class InputDataType {
None,
Genome,
Image
};
enum class FeatureType {
Identity,
PCA,
LDA,
ICA
};
enum class ClassifierType {
None,
KNN,
Bayes
};
typedef enum {
OPTION_GPU,
OPTION_LOGLEVEL,
OPTION_TRAIN,
OPTION_TEST,
OPTION_STREAM,
OPTION_DATA,
OPTION_PCA,
OPTION_LDA,
OPTION_ICA,
OPTION_KNN,
OPTION_BAYES,
OPTION_PCA_N1,
OPTION_LDA_N1,
OPTION_LDA_N2,
OPTION_ICA_N1,
OPTION_ICA_N2,
OPTION_ICA_NONL,
OPTION_ICA_MAX_ITER,
OPTION_ICA_EPS,
OPTION_KNN_K,
OPTION_KNN_DIST,
OPTION_UNKNOWN = '?'
} option_t;
typedef struct {
bool train;
bool test;
bool stream;
const char *path_train;
const char *path_test;
const char *path_stream;
const char *path_model;
InputDataType data_type;
FeatureType feature_type;
ClassifierType classifier_type;
int pca_n1;
int lda_n1;
int lda_n2;
int ica_n1;
int ica_n2;
ICANonl ica_nonl;
int ica_max_iter;
precision_t ica_eps;
int knn_k;
dist_func_t knn_dist;
} optarg_t;
const std::map<std::string, InputDataType> data_types = {
{ "genome", InputDataType::Genome },
{ "image", InputDataType::Image }
};
const std::map<std::string, dist_func_t> dist_funcs = {
{ "COS", m_dist_COS },
{ "L1", m_dist_L1 },
{ "L2", m_dist_L2 }
};
const std::map<std::string, ICANonl> nonl_funcs = {
{ "pow3", ICANonl::pow3 },
{ "tanh", ICANonl::tanh },
{ "gauss", ICANonl::gauss }
};
/**
* Print command-line usage and help text.
*/
void print_usage()
{
std::cerr <<
"Usage: ./face-rec [options]\n"
"\n"
"Options:\n"
" --gpu enable GPU acceleration\n"
" --loglevel LEVEL set the log level ([1]=info, 2=verbose, 3=debug)\n"
" --train DIRECTORY train a model with a training set\n"
" --test DIRECTORY perform recognition on a test set\n"
" --stream perform recognition on an input stream\n"
" --data data type (genome, [image])\n"
" --pca use PCA for feature extraction\n"
" --lda use LDA for feature extraction\n"
" --ica use ICA for feature extraction\n"
" --knn use the kNN classifier (default)\n"
" --bayes use the Bayes classifier\n"
"\n"
"Hyperparameters:\n"
"PCA:\n"
" --pca_n1 N number of principal components to compute\n"
"\n"
"LDA:\n"
" --lda_n1 N number of principal components to compute\n"
" --lda_n2 N number of Fisherfaces to compute\n"
"\n"
"ICA:\n"
" --ica_n1 N number of principal components to compute\n"
" --ica_n2 N number of independent components to estimate\n"
" --ica_nonl [nonl] nonlinearity function to use ([pow3], tanh, gauss)\n"
" --ica_max_iter N maximum iterations\n"
" --ica_eps X convergence threshold for w\n"
"\n"
"kNN:\n"
" --knn_k N number of nearest neighbors to use\n"
" --knn_dist [dist] distance function to use (L1, [L2], COS)\n";
}
/**
* Parse command-line arguments.
*
* @param argc
* @param argv
*/
optarg_t parse_args(int argc, char **argv)
{
optarg_t args = {
false,
false,
false,
nullptr,
nullptr,
nullptr,
"./model.dat",
InputDataType::Image,
FeatureType::Identity,
ClassifierType::KNN,
-1,
-1, -1,
-1, -1, ICANonl::pow3, 1000, 0.0001f,
1, m_dist_L2
};
struct option long_options[] = {
{ "gpu", no_argument, 0, OPTION_GPU },
{ "loglevel", required_argument, 0, OPTION_LOGLEVEL },
{ "train", required_argument, 0, OPTION_TRAIN },
{ "test", required_argument, 0, OPTION_TEST },
{ "stream", required_argument, 0, OPTION_STREAM },
{ "data", required_argument, 0, OPTION_DATA },
{ "pca", no_argument, 0, OPTION_PCA },
{ "lda", no_argument, 0, OPTION_LDA },
{ "ica", no_argument, 0, OPTION_ICA },
{ "knn", no_argument, 0, OPTION_KNN },
{ "bayes", no_argument, 0, OPTION_BAYES },
{ "pca_n1", required_argument, 0, OPTION_PCA_N1 },
{ "lda_n1", required_argument, 0, OPTION_LDA_N1 },
{ "lda_n2", required_argument, 0, OPTION_LDA_N2 },
{ "ica_n1", required_argument, 0, OPTION_ICA_N1 },
{ "ica_n2", required_argument, 0, OPTION_ICA_N2 },
{ "ica_nonl", required_argument, 0, OPTION_ICA_NONL },
{ "ica_max_iter", required_argument, 0, OPTION_ICA_MAX_ITER },
{ "ica_eps", required_argument, 0, OPTION_ICA_EPS },
{ "knn_k", required_argument, 0, OPTION_KNN_K },
{ "knn_dist", required_argument, 0, OPTION_KNN_DIST },
{ 0, 0, 0, 0 }
};
int opt;
while ( (opt = getopt_long_only(argc, argv, "", long_options, nullptr)) != -1 ) {
switch ( opt ) {
case OPTION_GPU:
GPU = true;
break;
case OPTION_LOGLEVEL:
LOGLEVEL = (logger_level_t) atoi(optarg);
break;
case OPTION_TRAIN:
args.train = true;
args.path_train = optarg;
break;
case OPTION_TEST:
args.test = true;
args.path_test = optarg;
break;
case OPTION_STREAM:
args.stream = true;
args.path_stream = optarg;
break;
case OPTION_DATA:
try {
args.data_type = data_types.at(optarg);
}
catch ( std::exception& e ) {
args.data_type = InputDataType::None;
}
break;
case OPTION_PCA:
args.feature_type = FeatureType::PCA;
break;
case OPTION_LDA:
args.feature_type = FeatureType::LDA;
break;
case OPTION_ICA:
args.feature_type = FeatureType::ICA;
break;
case OPTION_KNN:
args.classifier_type = ClassifierType::KNN;
break;
case OPTION_BAYES:
args.classifier_type = ClassifierType::Bayes;
break;
case OPTION_PCA_N1:
args.pca_n1 = atoi(optarg);
break;
case OPTION_LDA_N1:
args.lda_n1 = atoi(optarg);
break;
case OPTION_LDA_N2:
args.lda_n2 = atoi(optarg);
break;
case OPTION_ICA_N1:
args.ica_n1 = atoi(optarg);
break;
case OPTION_ICA_N2:
args.ica_n2 = atoi(optarg);
break;
case OPTION_ICA_NONL:
try {
args.ica_nonl = nonl_funcs.at(optarg);
}
catch ( std::exception& e ) {
args.ica_nonl = ICANonl::none;
}
break;
case OPTION_ICA_MAX_ITER:
args.ica_max_iter = atoi(optarg);
break;
case OPTION_ICA_EPS:
args.ica_eps = atof(optarg);
break;
case OPTION_KNN_K:
args.knn_k = atoi(optarg);
break;
case OPTION_KNN_DIST:
try {
args.knn_dist = dist_funcs.at(optarg);
}
catch ( std::exception& e ) {
args.knn_dist = nullptr;
}
break;
case OPTION_UNKNOWN:
print_usage();
exit(1);
}
}
return args;
}
/**
* Validate command-line arguments.
*
* @param args
*/
void validate_args(const optarg_t& args)
{
std::vector<std::pair<bool, std::string>> validators = {
{ args.train || args.test || args.stream, "--train / --test / --stream are required" },
{ args.data_type != InputDataType::None, "--data must be genome | image" },
{ args.knn_dist != nullptr, "--knn_dist must be L1 | L2 | COS" },
{ args.ica_nonl != ICANonl::none, "--ica_nonl must be pow3 | tanh | gauss" }
};
bool valid = true;
for ( auto v : validators ) {
if ( !v.first ) {
std::cerr << "error: " << v.second << "\n";
valid = false;
}
}
if ( !valid ) {
print_usage();
exit(1);
}
}
int main(int argc, char **argv)
{
// parse command-line arguments
optarg_t args = parse_args(argc, argv);
// validate arguments
validate_args(args);
// initialize GPU if enabled
gpu_init();
// initialize data type
DataType *data_type;
if ( args.data_type == InputDataType::Genome ) {
data_type = new Genome();
}
else if ( args.data_type == InputDataType::Image ) {
data_type = new Image();
}
// initialize feature layer
FeatureLayer *feature;
if ( args.feature_type == FeatureType::Identity ) {
feature = new IdentityLayer();
}
else if ( args.feature_type == FeatureType::PCA ) {
feature = new PCALayer(args.pca_n1);
}
else if ( args.feature_type == FeatureType::LDA ) {
feature = new LDALayer(args.lda_n1, args.lda_n2);
}
else if ( args.feature_type == FeatureType::ICA ) {
feature = new ICALayer(
args.ica_n1,
args.ica_n2,
args.ica_nonl,
args.ica_max_iter,
args.ica_eps
);
}
// initialize classifier layer
ClassifierLayer *classifier;
if ( args.classifier_type == ClassifierType::KNN ) {
classifier = new KNNLayer(args.knn_k, args.knn_dist);
}
else if ( args.classifier_type == ClassifierType::Bayes ) {
classifier = new BayesLayer();
}
// initialize model
ClassificationModel model(feature, classifier);
// run the face recognition system
if ( args.train ) {
Dataset train_set(data_type, args.path_train);
model.train(train_set);
}
else {
model.load(args.path_model);
}
if ( args.test ) {
Dataset test_set(data_type, args.path_test);
std::vector<DataLabel> Y_pred = model.predict(test_set);
model.validate(test_set, Y_pred);
}
else if ( args.stream ) {
const char END = '0';
const char READ = '1';
while ( true ) {
char c = std::cin.get();
if ( c == END ) {
break;
}
else if ( c == READ ) {
Dataset test_set(data_type, args.path_stream, false);
std::vector<DataLabel> Y_pred = model.predict(test_set);
// print results
for ( size_t i = 0; i < test_set.entries().size(); i++ ) {
const DataLabel& y_pred = Y_pred[i];
const DataEntry& entry = test_set.entries()[i];
std::cout << std::left << std::setw(12) << entry.name << " " << y_pred << "\n";
}
}
}
}
else {
model.save(args.path_model);
}
timer_print();
model.print_stats();
gpu_finalize();
return 0;
}
<|endoftext|> |
<commit_before>// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/message_pump_x.h"
#include <X11/extensions/XInput2.h>
#include "base/basictypes.h"
#include "base/message_loop.h"
namespace {
gboolean XSourcePrepare(GSource* source, gint* timeout_ms) {
if (XPending(base::MessagePumpX::GetDefaultXDisplay()))
*timeout_ms = 0;
else
*timeout_ms = -1;
return FALSE;
}
gboolean XSourceCheck(GSource* source) {
return XPending(base::MessagePumpX::GetDefaultXDisplay());
}
gboolean XSourceDispatch(GSource* source,
GSourceFunc unused_func,
gpointer data) {
base::MessagePumpX* pump = static_cast<base::MessagePumpX*>(data);
return pump->DispatchXEvents();
}
GSourceFuncs XSourceFuncs = {
XSourcePrepare,
XSourceCheck,
XSourceDispatch,
NULL
};
// The opcode used for checking events.
int xiopcode = -1;
// The message-pump opens a connection to the display and owns it.
Display* g_xdisplay = NULL;
// The default dispatcher to process native events when no dispatcher
// is specified.
base::MessagePumpDispatcher* g_default_dispatcher = NULL;
void InitializeXInput2(void) {
Display* display = base::MessagePumpX::GetDefaultXDisplay();
if (!display)
return;
int event, err;
if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
DVLOG(1) << "X Input extension not available.";
xiopcode = -1;
return;
}
#if defined(USE_XI2_MT)
// USE_XI2_MT also defines the required XI2 minor minimum version.
int major = 2, minor = USE_XI2_MT;
#else
int major = 2, minor = 0;
#endif
if (XIQueryVersion(display, &major, &minor) == BadRequest) {
DVLOG(1) << "XInput2 not supported in the server.";
xiopcode = -1;
return;
}
#if defined(USE_XI2_MT)
if (major < 2 || (major == 2 && minor < USE_XI2_MT)) {
DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
<< "But 2." << USE_XI2_MT << " is required.";
xiopcode = -1;
return;
}
#endif
}
} // namespace
namespace base {
MessagePumpX::MessagePumpX() : MessagePumpGlib(),
x_source_(NULL) {
InitializeXInput2();
InitXSource();
}
MessagePumpX::~MessagePumpX() {
g_source_destroy(x_source_);
g_source_unref(x_source_);
XCloseDisplay(g_xdisplay);
g_xdisplay = NULL;
}
// static
Display* MessagePumpX::GetDefaultXDisplay() {
if (!g_xdisplay)
g_xdisplay = XOpenDisplay(NULL);
return g_xdisplay;
}
// static
bool MessagePumpX::HasXInput2() {
return xiopcode != -1;
}
// static
void MessagePumpX::SetDefaultDispatcher(MessagePumpDispatcher* dispatcher) {
DCHECK(!g_default_dispatcher || !dispatcher);
g_default_dispatcher = dispatcher;
}
void MessagePumpX::InitXSource() {
DCHECK(!x_source_);
x_poll_.reset(new GPollFD());
Display* display = GetDefaultXDisplay();
DCHECK(display) << "Unable to get connection to X server";
x_poll_->fd = ConnectionNumber(display);
x_poll_->events = G_IO_IN;
x_source_ = g_source_new(&XSourceFuncs, sizeof(GSource));
g_source_add_poll(x_source_, x_poll_.get());
g_source_set_can_recurse(x_source_, TRUE);
g_source_set_callback(x_source_, NULL, this, NULL);
g_source_attach(x_source_, g_main_context_default());
}
bool MessagePumpX::ProcessXEvent(MessagePumpDispatcher* dispatcher,
XEvent* xev) {
bool should_quit = false;
bool have_cookie = false;
if (xev->type == GenericEvent &&
XGetEventData(xev->xgeneric.display, &xev->xcookie)) {
have_cookie = true;
}
if (!WillProcessXEvent(xev)) {
MessagePumpDispatcher::DispatchStatus status =
dispatcher->Dispatch(xev);
if (status == MessagePumpDispatcher::EVENT_QUIT) {
should_quit = true;
Quit();
} else if (status == MessagePumpDispatcher::EVENT_IGNORED) {
DVLOG(1) << "Event (" << xev->type << ") not handled.";
}
DidProcessXEvent(xev);
}
if (have_cookie) {
XFreeEventData(xev->xgeneric.display, &xev->xcookie);
}
return should_quit;
}
gboolean MessagePumpX::DispatchXEvents() {
Display* display = GetDefaultXDisplay();
DCHECK(display);
MessagePumpDispatcher* dispatcher =
GetDispatcher() ? GetDispatcher() : g_default_dispatcher;
// In the general case, we want to handle all pending events before running
// the tasks. This is what happens in the message_pump_glib case.
while (XPending(display)) {
XEvent xev;
XNextEvent(display, &xev);
if (dispatcher && ProcessXEvent(dispatcher, &xev))
return TRUE;
}
return TRUE;
}
bool MessagePumpX::WillProcessXEvent(XEvent* xevent) {
if (!observers().might_have_observers())
return false;
ObserverListBase<MessagePumpObserver>::Iterator it(observers());
MessagePumpObserver* obs;
while ((obs = it.GetNext()) != NULL) {
if (obs->WillProcessEvent(xevent))
return true;
}
return false;
}
void MessagePumpX::DidProcessXEvent(XEvent* xevent) {
FOR_EACH_OBSERVER(MessagePumpObserver, observers(), DidProcessEvent(xevent));
}
} // namespace base
<commit_msg>CrOS: Add a CHECK to help debug a crash in the wild.<commit_after>// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/message_pump_x.h"
#include <X11/extensions/XInput2.h>
#include "base/basictypes.h"
#include "base/message_loop.h"
namespace {
gboolean XSourcePrepare(GSource* source, gint* timeout_ms) {
if (XPending(base::MessagePumpX::GetDefaultXDisplay()))
*timeout_ms = 0;
else
*timeout_ms = -1;
return FALSE;
}
gboolean XSourceCheck(GSource* source) {
return XPending(base::MessagePumpX::GetDefaultXDisplay());
}
gboolean XSourceDispatch(GSource* source,
GSourceFunc unused_func,
gpointer data) {
base::MessagePumpX* pump = static_cast<base::MessagePumpX*>(data);
return pump->DispatchXEvents();
}
GSourceFuncs XSourceFuncs = {
XSourcePrepare,
XSourceCheck,
XSourceDispatch,
NULL
};
// The opcode used for checking events.
int xiopcode = -1;
// The message-pump opens a connection to the display and owns it.
Display* g_xdisplay = NULL;
// The default dispatcher to process native events when no dispatcher
// is specified.
base::MessagePumpDispatcher* g_default_dispatcher = NULL;
void InitializeXInput2(void) {
Display* display = base::MessagePumpX::GetDefaultXDisplay();
if (!display)
return;
int event, err;
if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
DVLOG(1) << "X Input extension not available.";
xiopcode = -1;
return;
}
#if defined(USE_XI2_MT)
// USE_XI2_MT also defines the required XI2 minor minimum version.
int major = 2, minor = USE_XI2_MT;
#else
int major = 2, minor = 0;
#endif
if (XIQueryVersion(display, &major, &minor) == BadRequest) {
DVLOG(1) << "XInput2 not supported in the server.";
xiopcode = -1;
return;
}
#if defined(USE_XI2_MT)
if (major < 2 || (major == 2 && minor < USE_XI2_MT)) {
DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
<< "But 2." << USE_XI2_MT << " is required.";
xiopcode = -1;
return;
}
#endif
}
} // namespace
namespace base {
MessagePumpX::MessagePumpX() : MessagePumpGlib(),
x_source_(NULL) {
InitializeXInput2();
InitXSource();
}
MessagePumpX::~MessagePumpX() {
g_source_destroy(x_source_);
g_source_unref(x_source_);
XCloseDisplay(g_xdisplay);
g_xdisplay = NULL;
}
// static
Display* MessagePumpX::GetDefaultXDisplay() {
if (!g_xdisplay)
g_xdisplay = XOpenDisplay(NULL);
return g_xdisplay;
}
// static
bool MessagePumpX::HasXInput2() {
return xiopcode != -1;
}
// static
void MessagePumpX::SetDefaultDispatcher(MessagePumpDispatcher* dispatcher) {
DCHECK(!g_default_dispatcher || !dispatcher);
g_default_dispatcher = dispatcher;
}
void MessagePumpX::InitXSource() {
// CHECKs are to help track down crbug.com/113106.
CHECK(!x_source_);
Display* display = GetDefaultXDisplay();
CHECK(display) << "Unable to get connection to X server";
x_poll_.reset(new GPollFD());
CHECK(x_poll_.get());
x_poll_->fd = ConnectionNumber(display);
x_poll_->events = G_IO_IN;
x_source_ = g_source_new(&XSourceFuncs, sizeof(GSource));
g_source_add_poll(x_source_, x_poll_.get());
g_source_set_can_recurse(x_source_, TRUE);
g_source_set_callback(x_source_, NULL, this, NULL);
g_source_attach(x_source_, g_main_context_default());
}
bool MessagePumpX::ProcessXEvent(MessagePumpDispatcher* dispatcher,
XEvent* xev) {
bool should_quit = false;
bool have_cookie = false;
if (xev->type == GenericEvent &&
XGetEventData(xev->xgeneric.display, &xev->xcookie)) {
have_cookie = true;
}
if (!WillProcessXEvent(xev)) {
MessagePumpDispatcher::DispatchStatus status =
dispatcher->Dispatch(xev);
if (status == MessagePumpDispatcher::EVENT_QUIT) {
should_quit = true;
Quit();
} else if (status == MessagePumpDispatcher::EVENT_IGNORED) {
DVLOG(1) << "Event (" << xev->type << ") not handled.";
}
DidProcessXEvent(xev);
}
if (have_cookie) {
XFreeEventData(xev->xgeneric.display, &xev->xcookie);
}
return should_quit;
}
gboolean MessagePumpX::DispatchXEvents() {
Display* display = GetDefaultXDisplay();
DCHECK(display);
MessagePumpDispatcher* dispatcher =
GetDispatcher() ? GetDispatcher() : g_default_dispatcher;
// In the general case, we want to handle all pending events before running
// the tasks. This is what happens in the message_pump_glib case.
while (XPending(display)) {
XEvent xev;
XNextEvent(display, &xev);
if (dispatcher && ProcessXEvent(dispatcher, &xev))
return TRUE;
}
return TRUE;
}
bool MessagePumpX::WillProcessXEvent(XEvent* xevent) {
if (!observers().might_have_observers())
return false;
ObserverListBase<MessagePumpObserver>::Iterator it(observers());
MessagePumpObserver* obs;
while ((obs = it.GetNext()) != NULL) {
if (obs->WillProcessEvent(xevent))
return true;
}
return false;
}
void MessagePumpX::DidProcessXEvent(XEvent* xevent) {
FOR_EACH_OBSERVER(MessagePumpObserver, observers(), DidProcessEvent(xevent));
}
} // namespace base
<|endoftext|> |
<commit_before>/*************************************************************************
*
* $RCSfile: dbexchange.cxx,v $
*
* $Revision: 1.10 $
*
* last change: $Author: fs $ $Date: 2001-04-11 12:58:38 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an AS IS basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef DBAUI_DBEXCHANGE_HXX
#include "dbexchange.hxx"
#endif
#ifndef _SOT_FORMATS_HXX
#include <sot/formats.hxx>
#endif
#ifndef _SOT_STORAGE_HXX
#include <sot/storage.hxx>
#endif
#ifndef _OSL_DIAGNOSE_H_
#include <osl/diagnose.h>
#endif
#ifndef _COM_SUN_STAR_SDB_COMMANDTYPE_HPP_
#include <com/sun/star/sdb/CommandType.hpp>
#endif
#ifndef DBAUI_TOKENWRITER_HXX
#include "TokenWriter.hxx"
#endif
#ifndef DBACCESS_SHARED_DBUSTRINGS_HRC
#include "dbustrings.hrc"
#endif
#ifndef _COMPHELPER_EXTRACT_HXX_
#include <comphelper/extract.hxx>
#endif
#ifndef _SVX_DATACCESSDESCRIPTOR_HXX_
#include <svx/dataaccessdescriptor.hxx>
#endif
namespace dbaui
{
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::datatransfer;
using namespace ::svx;
// -----------------------------------------------------------------------------
ODataClipboard::ODataClipboard(
const ::rtl::OUString& _rDatasource,
const sal_Int32 _nCommandType,
const ::rtl::OUString& _rCommand,
const Reference< XConnection >& _rxConnection,
const Reference< XNumberFormatter >& _rxFormatter,
const Reference< XMultiServiceFactory >& _rxORB,
const sal_Int32 _nFormats)
:m_pHtml(NULL)
,m_pRtf(NULL)
,m_nObjectType(CommandType::TABLE)
,m_nFormats(_nFormats)
{
// build the descriptor (the property sequence)
ODataAccessDescriptor aDescriptor;
aDescriptor[daDataSource] <<= _rDatasource;
aDescriptor[daConnection] <<= _rxConnection;
aDescriptor[daCommand] <<= _rCommand;
aDescriptor[daCommandType] <<= _nCommandType;
m_aSeq = aDescriptor.createPropertyValueSequence();
// calculate some stuff which helps us providing the different formats
if (m_nFormats && DCF_OBJECT_DESCRIPTOR)
{
// extract the single values from the sequence
::rtl::OUString sDatasourceName;
::rtl::OUString sObjectName;
sal_Bool bEscapeProcessing = sal_True;
sDatasourceName = _rDatasource;
m_nObjectType = _nCommandType;
sObjectName = _rCommand;
// for compatibility: create a string which can be used for the SOT_FORMATSTR_ID_SBA_DATAEXCHANGE format
sal_Bool bTreatAsStatement = (CommandType::COMMAND == m_nObjectType);
// statements are - in this old and ugly format - described as queries
const sal_Unicode cSeparator = sal_Unicode(11);
const ::rtl::OUString sSeparator(&cSeparator, 1);
const sal_Unicode cTableMark = '1';
const sal_Unicode cQueryMark = '0';
// build the descriptor string
m_sCompatibleObjectDescription += sDatasourceName;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += bTreatAsStatement ? ::rtl::OUString() : sObjectName;
m_sCompatibleObjectDescription += sSeparator;
switch (m_nObjectType)
{
case CommandType::TABLE:
m_sCompatibleObjectDescription += ::rtl::OUString(&cTableMark, 1);
break;
case CommandType::QUERY:
m_sCompatibleObjectDescription += ::rtl::OUString(&cQueryMark, 1);
break;
case CommandType::COMMAND:
m_sCompatibleObjectDescription += ::rtl::OUString(&cQueryMark, 1);
// think of it as a query
break;
}
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += bTreatAsStatement ? sObjectName : ::rtl::OUString();
m_sCompatibleObjectDescription += sSeparator;
}
if (m_nFormats && DCF_HTML_TABLE)
{
m_pHtml = new OHTMLImportExport(m_aSeq, _rxORB, _rxFormatter);
m_xHtml = m_pHtml;
m_pHtml->initialize();
}
if (m_nFormats && DCF_RTF_TABLE)
{
m_pRtf = new ORTFImportExport(m_aSeq, _rxORB, _rxFormatter);
m_xRtf = m_pRtf;
m_pRtf->initialize();
}
}
// -----------------------------------------------------------------------------
ODataClipboard::ODataClipboard(const Reference< XPropertySet >& _rxLivingForm, const Reference< XSQLQueryComposer >& _rxComposer)
:m_pHtml(NULL)
,m_pRtf(NULL)
,m_nObjectType(CommandType::TABLE)
,m_nFormats(DCF_OBJECT_DESCRIPTOR)
{
// collect some properties of the form
::rtl::OUString sDatasourceName;
sal_Int32 nObjectType = CommandType::COMMAND;
::rtl::OUString sObjectName;
try
{
_rxLivingForm->getPropertyValue(PROPERTY_COMMANDTYPE) >>= nObjectType;
_rxLivingForm->getPropertyValue(PROPERTY_COMMAND) >>= sObjectName;
_rxLivingForm->getPropertyValue(PROPERTY_DATASOURCENAME) >>= sDatasourceName;
}
catch(Exception&)
{
OSL_ENSURE(sal_False, "ODataClipboard::ODataClipboard: could not collect essential form attributes !");
m_nFormats = 0;
return;
}
sal_Bool bIsStatement = CommandType::COMMAND == nObjectType;
String sObjectKind = (CommandType::TABLE == nObjectType) ? String('1') : String('0');
// check if the SQL-statement is modified
sal_Bool bHasFilterOrSort(sal_False);
::rtl::OUString sCompleteStatement;
try
{
::rtl::OUString sFilter;
if (::cppu::any2bool(_rxLivingForm->getPropertyValue(PROPERTY_APPLYFILTER)))
_rxLivingForm->getPropertyValue(PROPERTY_FILTER) >>= sFilter;
::rtl::OUString sSort;
_rxLivingForm->getPropertyValue(PROPERTY_ORDER) >>= sSort;
bHasFilterOrSort = (sFilter.len()>0) || (sSort.len()>0);
_rxLivingForm->getPropertyValue(PROPERTY_ACTIVECOMMAND) >>= sCompleteStatement;
if (_rxComposer.is())
{
_rxComposer->setQuery(sCompleteStatement);
_rxComposer->setFilter(sFilter);
_rxComposer->setOrder(sSort);
sCompleteStatement = _rxComposer->getComposedQuery();
}
}
catch(Exception&)
{
OSL_ENSURE(sal_False, "ODataClipboard::ODataClipboard: could not collect essential form attributes (part two) !");
m_nFormats = 0;
return;
}
// build the object description (as string)
const sal_Unicode cSeparator(11);
const ::rtl::OUString sSeparator(&cSeparator, 1);
m_sCompatibleObjectDescription = sDatasourceName;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += bIsStatement ? ::rtl::OUString() : sDatasourceName;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += sObjectKind;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription +=
(CommandType::QUERY == nObjectType) && !bHasFilterOrSort
? ::rtl::OUString()
: sCompleteStatement;
// compatibility says : always add the statement, but don't if it is a "pure" query
m_sCompatibleObjectDescription += sSeparator;
}
// -----------------------------------------------------------------------------
void ODataClipboard::addRow(sal_Int32 _nRow)
{
OSL_ENSURE(m_nFormats && DCF_OBJECT_DESCRIPTOR, "ODataClipboard::addRow: don't have this (object descriptor) format!");
const sal_Unicode cSeparator(11);
const ::rtl::OUString sSeparator(&cSeparator, 1);
m_sCompatibleObjectDescription += ::rtl::OUString::valueOf((sal_Int32)_nRow);
m_sCompatibleObjectDescription += sSeparator;
}
// -----------------------------------------------------------------------------
sal_Bool ODataClipboard::WriteObject( SotStorageStreamRef& rxOStm, void* pUserObject, sal_uInt32 nUserObjectId, const ::com::sun::star::datatransfer::DataFlavor& rFlavor )
{
if (nUserObjectId == SOT_FORMAT_RTF || nUserObjectId == SOT_FORMATSTR_ID_HTML)
{
ODatabaseImportExport* pExport = reinterpret_cast<ODatabaseImportExport*>(pUserObject);
if(pExport)
{
pExport->setStream(&rxOStm);
return pExport->Write();
}
}
return sal_False;
}
// -----------------------------------------------------------------------------
void ODataClipboard::AddSupportedFormats()
{
// RTF?
if (m_nFormats && DCF_RTF_TABLE)
AddFormat(SOT_FORMAT_RTF);
// HTML?
if (m_nFormats && DCF_HTML_TABLE)
AddFormat(SOT_FORMATSTR_ID_HTML);
// object descriptor?
if (m_nFormats && DCF_OBJECT_DESCRIPTOR)
{
switch (m_nObjectType)
{
case CommandType::TABLE:
AddFormat(SOT_FORMATSTR_ID_DBACCESS_TABLE);
break;
case CommandType::QUERY:
AddFormat(SOT_FORMATSTR_ID_DBACCESS_QUERY);
break;
case CommandType::COMMAND:
AddFormat(SOT_FORMATSTR_ID_DBACCESS_COMMAND);
break;
}
sal_Int32 nDescriptorLen = m_sCompatibleObjectDescription.getLength();
if (nDescriptorLen)
{
if (m_sCompatibleObjectDescription.getStr()[nDescriptorLen] == 11)
m_sCompatibleObjectDescription = m_sCompatibleObjectDescription.copy(0, nDescriptorLen - 1);
if (nDescriptorLen)
AddFormat(SOT_FORMATSTR_ID_SBA_DATAEXCHANGE);
}
}
}
// -----------------------------------------------------------------------------
sal_Bool ODataClipboard::GetData( const DataFlavor& rFlavor )
{
ULONG nFormat = SotExchange::GetFormat(rFlavor);
switch (nFormat)
{
case SOT_FORMAT_RTF:
return SetObject(m_pRtf,SOT_FORMAT_RTF,rFlavor);
case SOT_FORMATSTR_ID_HTML:
return SetObject(m_pHtml,SOT_FORMATSTR_ID_HTML,rFlavor);
case SOT_FORMATSTR_ID_DBACCESS_TABLE:
case SOT_FORMATSTR_ID_DBACCESS_QUERY:
case SOT_FORMATSTR_ID_DBACCESS_COMMAND:
return SetAny(makeAny(m_aSeq), rFlavor);
case SOT_FORMATSTR_ID_SBA_DATAEXCHANGE:
return SetString(m_sCompatibleObjectDescription, rFlavor);
}
return sal_False;
}
// -----------------------------------------------------------------------------
void ODataClipboard::ObjectReleased()
{
m_xHtml = m_xRtf = NULL;
m_pHtml = NULL;
m_pRtf = NULL;
m_aSeq.realloc(0);
}
// -----------------------------------------------------------------------------
}
<commit_msg>#86569# corrected building the compatible object description<commit_after>/*************************************************************************
*
* $RCSfile: dbexchange.cxx,v $
*
* $Revision: 1.11 $
*
* last change: $Author: fs $ $Date: 2001-05-03 09:24:23 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an AS IS basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef DBAUI_DBEXCHANGE_HXX
#include "dbexchange.hxx"
#endif
#ifndef _SOT_FORMATS_HXX
#include <sot/formats.hxx>
#endif
#ifndef _SOT_STORAGE_HXX
#include <sot/storage.hxx>
#endif
#ifndef _OSL_DIAGNOSE_H_
#include <osl/diagnose.h>
#endif
#ifndef _COM_SUN_STAR_SDB_COMMANDTYPE_HPP_
#include <com/sun/star/sdb/CommandType.hpp>
#endif
#ifndef DBAUI_TOKENWRITER_HXX
#include "TokenWriter.hxx"
#endif
#ifndef DBACCESS_SHARED_DBUSTRINGS_HRC
#include "dbustrings.hrc"
#endif
#ifndef _COMPHELPER_EXTRACT_HXX_
#include <comphelper/extract.hxx>
#endif
#ifndef _SVX_DATACCESSDESCRIPTOR_HXX_
#include <svx/dataaccessdescriptor.hxx>
#endif
namespace dbaui
{
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::sdb;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::datatransfer;
using namespace ::svx;
// -----------------------------------------------------------------------------
ODataClipboard::ODataClipboard(
const ::rtl::OUString& _rDatasource,
const sal_Int32 _nCommandType,
const ::rtl::OUString& _rCommand,
const Reference< XConnection >& _rxConnection,
const Reference< XNumberFormatter >& _rxFormatter,
const Reference< XMultiServiceFactory >& _rxORB,
const sal_Int32 _nFormats)
:m_pHtml(NULL)
,m_pRtf(NULL)
,m_nObjectType(CommandType::TABLE)
,m_nFormats(_nFormats)
{
// build the descriptor (the property sequence)
ODataAccessDescriptor aDescriptor;
aDescriptor[daDataSource] <<= _rDatasource;
aDescriptor[daConnection] <<= _rxConnection;
aDescriptor[daCommand] <<= _rCommand;
aDescriptor[daCommandType] <<= _nCommandType;
m_aSeq = aDescriptor.createPropertyValueSequence();
// calculate some stuff which helps us providing the different formats
if (m_nFormats && DCF_OBJECT_DESCRIPTOR)
{
// extract the single values from the sequence
::rtl::OUString sDatasourceName;
::rtl::OUString sObjectName;
sal_Bool bEscapeProcessing = sal_True;
sDatasourceName = _rDatasource;
m_nObjectType = _nCommandType;
sObjectName = _rCommand;
// for compatibility: create a string which can be used for the SOT_FORMATSTR_ID_SBA_DATAEXCHANGE format
sal_Bool bTreatAsStatement = (CommandType::COMMAND == m_nObjectType);
// statements are - in this old and ugly format - described as queries
const sal_Unicode cSeparator = sal_Unicode(11);
const ::rtl::OUString sSeparator(&cSeparator, 1);
const sal_Unicode cTableMark = '1';
const sal_Unicode cQueryMark = '0';
// build the descriptor string
m_sCompatibleObjectDescription += sDatasourceName;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += bTreatAsStatement ? ::rtl::OUString() : sObjectName;
m_sCompatibleObjectDescription += sSeparator;
switch (m_nObjectType)
{
case CommandType::TABLE:
m_sCompatibleObjectDescription += ::rtl::OUString(&cTableMark, 1);
break;
case CommandType::QUERY:
m_sCompatibleObjectDescription += ::rtl::OUString(&cQueryMark, 1);
break;
case CommandType::COMMAND:
m_sCompatibleObjectDescription += ::rtl::OUString(&cQueryMark, 1);
// think of it as a query
break;
}
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += bTreatAsStatement ? sObjectName : ::rtl::OUString();
m_sCompatibleObjectDescription += sSeparator;
}
if (m_nFormats && DCF_HTML_TABLE)
{
m_pHtml = new OHTMLImportExport(m_aSeq, _rxORB, _rxFormatter);
m_xHtml = m_pHtml;
m_pHtml->initialize();
}
if (m_nFormats && DCF_RTF_TABLE)
{
m_pRtf = new ORTFImportExport(m_aSeq, _rxORB, _rxFormatter);
m_xRtf = m_pRtf;
m_pRtf->initialize();
}
}
// -----------------------------------------------------------------------------
ODataClipboard::ODataClipboard(const Reference< XPropertySet >& _rxLivingForm, const Reference< XSQLQueryComposer >& _rxComposer)
:m_pHtml(NULL)
,m_pRtf(NULL)
,m_nObjectType(CommandType::TABLE)
,m_nFormats(DCF_OBJECT_DESCRIPTOR)
{
// collect some properties of the form
::rtl::OUString sDatasourceName;
sal_Int32 nObjectType = CommandType::COMMAND;
::rtl::OUString sObjectName;
try
{
_rxLivingForm->getPropertyValue(PROPERTY_COMMANDTYPE) >>= nObjectType;
_rxLivingForm->getPropertyValue(PROPERTY_COMMAND) >>= sObjectName;
_rxLivingForm->getPropertyValue(PROPERTY_DATASOURCENAME) >>= sDatasourceName;
}
catch(Exception&)
{
OSL_ENSURE(sal_False, "ODataClipboard::ODataClipboard: could not collect essential form attributes !");
m_nFormats = 0;
return;
}
sal_Bool bIsStatement = CommandType::COMMAND == nObjectType;
String sObjectKind = (CommandType::TABLE == nObjectType) ? String('1') : String('0');
// check if the SQL-statement is modified
sal_Bool bHasFilterOrSort(sal_False);
::rtl::OUString sCompleteStatement;
try
{
::rtl::OUString sFilter;
if (::cppu::any2bool(_rxLivingForm->getPropertyValue(PROPERTY_APPLYFILTER)))
_rxLivingForm->getPropertyValue(PROPERTY_FILTER) >>= sFilter;
::rtl::OUString sSort;
_rxLivingForm->getPropertyValue(PROPERTY_ORDER) >>= sSort;
bHasFilterOrSort = (sFilter.len()>0) || (sSort.len()>0);
_rxLivingForm->getPropertyValue(PROPERTY_ACTIVECOMMAND) >>= sCompleteStatement;
if (_rxComposer.is())
{
_rxComposer->setQuery(sCompleteStatement);
_rxComposer->setFilter(sFilter);
_rxComposer->setOrder(sSort);
sCompleteStatement = _rxComposer->getComposedQuery();
}
}
catch(Exception&)
{
OSL_ENSURE(sal_False, "ODataClipboard::ODataClipboard: could not collect essential form attributes (part two) !");
m_nFormats = 0;
return;
}
// build the object description (as string)
const sal_Unicode cSeparator(11);
const ::rtl::OUString sSeparator(&cSeparator, 1);
m_sCompatibleObjectDescription = sDatasourceName;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += bIsStatement ? ::rtl::OUString() : sObjectName;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription += sObjectKind;
m_sCompatibleObjectDescription += sSeparator;
m_sCompatibleObjectDescription +=
(CommandType::QUERY == nObjectType) && !bHasFilterOrSort
? ::rtl::OUString()
: sCompleteStatement;
// compatibility says : always add the statement, but don't if it is a "pure" query
m_sCompatibleObjectDescription += sSeparator;
}
// -----------------------------------------------------------------------------
void ODataClipboard::addRow(sal_Int32 _nRow)
{
OSL_ENSURE(m_nFormats && DCF_OBJECT_DESCRIPTOR, "ODataClipboard::addRow: don't have this (object descriptor) format!");
const sal_Unicode cSeparator(11);
const ::rtl::OUString sSeparator(&cSeparator, 1);
m_sCompatibleObjectDescription += ::rtl::OUString::valueOf((sal_Int32)_nRow);
m_sCompatibleObjectDescription += sSeparator;
}
// -----------------------------------------------------------------------------
sal_Bool ODataClipboard::WriteObject( SotStorageStreamRef& rxOStm, void* pUserObject, sal_uInt32 nUserObjectId, const ::com::sun::star::datatransfer::DataFlavor& rFlavor )
{
if (nUserObjectId == SOT_FORMAT_RTF || nUserObjectId == SOT_FORMATSTR_ID_HTML)
{
ODatabaseImportExport* pExport = reinterpret_cast<ODatabaseImportExport*>(pUserObject);
if(pExport)
{
pExport->setStream(&rxOStm);
return pExport->Write();
}
}
return sal_False;
}
// -----------------------------------------------------------------------------
void ODataClipboard::AddSupportedFormats()
{
// RTF?
if (m_nFormats && DCF_RTF_TABLE)
AddFormat(SOT_FORMAT_RTF);
// HTML?
if (m_nFormats && DCF_HTML_TABLE)
AddFormat(SOT_FORMATSTR_ID_HTML);
// object descriptor?
if (m_nFormats && DCF_OBJECT_DESCRIPTOR)
{
switch (m_nObjectType)
{
case CommandType::TABLE:
AddFormat(SOT_FORMATSTR_ID_DBACCESS_TABLE);
break;
case CommandType::QUERY:
AddFormat(SOT_FORMATSTR_ID_DBACCESS_QUERY);
break;
case CommandType::COMMAND:
AddFormat(SOT_FORMATSTR_ID_DBACCESS_COMMAND);
break;
}
sal_Int32 nDescriptorLen = m_sCompatibleObjectDescription.getLength();
if (nDescriptorLen)
{
if (m_sCompatibleObjectDescription.getStr()[nDescriptorLen] == 11)
m_sCompatibleObjectDescription = m_sCompatibleObjectDescription.copy(0, nDescriptorLen - 1);
if (nDescriptorLen)
AddFormat(SOT_FORMATSTR_ID_SBA_DATAEXCHANGE);
}
}
}
// -----------------------------------------------------------------------------
sal_Bool ODataClipboard::GetData( const DataFlavor& rFlavor )
{
ULONG nFormat = SotExchange::GetFormat(rFlavor);
switch (nFormat)
{
case SOT_FORMAT_RTF:
return SetObject(m_pRtf,SOT_FORMAT_RTF,rFlavor);
case SOT_FORMATSTR_ID_HTML:
return SetObject(m_pHtml,SOT_FORMATSTR_ID_HTML,rFlavor);
case SOT_FORMATSTR_ID_DBACCESS_TABLE:
case SOT_FORMATSTR_ID_DBACCESS_QUERY:
case SOT_FORMATSTR_ID_DBACCESS_COMMAND:
return SetAny(makeAny(m_aSeq), rFlavor);
case SOT_FORMATSTR_ID_SBA_DATAEXCHANGE:
return SetString(m_sCompatibleObjectDescription, rFlavor);
}
return sal_False;
}
// -----------------------------------------------------------------------------
void ODataClipboard::ObjectReleased()
{
m_xHtml = m_xRtf = NULL;
m_pHtml = NULL;
m_pRtf = NULL;
m_aSeq.realloc(0);
}
// -----------------------------------------------------------------------------
}
<|endoftext|> |
<commit_before>#pragma once
#include "main.h"
#include "natives.h"
#include "CTeamspeak.h"
void **ppPluginData;
extern void *pAMXFunctions;
logprintf_t logprintf;
PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports() {
return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES;
}
PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData) {
pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
logprintf = (logprintf_t)ppData[PLUGIN_DATA_LOGPRINTF];
#ifdef _WIN32
WSAData wsa_unused;
WSAStartup(MAKEWORD(2,0), &wsa_unused);
#endif
logprintf("TSConnector v0.3 loaded.");
return 1;
}
PLUGIN_EXPORT void PLUGIN_CALL Unload() {
#ifdef _WIN32
WSACleanup();
#endif
logprintf("TSConnector unloaded.");
}
#if defined __cplusplus
extern "C"
#endif
const AMX_NATIVE_INFO NativesList[] = {
{"TSC_Connect", native_TSC_Connect},
{"TSC_Disconnect", native_TSC_Disconnect},
{"TSC_Login", native_TSC_Login},
{"TSC_SetActiveVServer", native_TSC_SetActiveVServer},
{"TSC_SetTimeoutTime", native_TSC_SetTimeoutTime},
{"TSC_CreateChannel", native_TSC_CreateChannel},
{"TSC_DeleteChannel", native_TSC_DeleteChannel},
{"TSC_GetChannelIDByName", native_TSC_GetChannelIDByName},
{"TSC_SetChannelName", native_TSC_SetChannelName},
{"TSC_SetChannelDescription", native_TSC_SetChannelDescription},
{"TSC_SetChannelType", native_TSC_SetChannelType},
{"TSC_SetChannelPassword", native_TSC_SetChannelPassword},
{"TSC_SetChannelTalkPower", native_TSC_SetChannelTalkPower},
{"TSC_SetChannelUserLimit", native_TSC_SetChannelUserLimit},
{"TSC_SetChannelSubChannel", native_TSC_SetChannelSubChannel},
{"TSC_MoveChannelBelowChannel", native_TSC_MoveChannelBelowChannel},
{"TSC_GetChannelName", native_TSC_GetChannelName},
{"TSC_GetChannelClientList", native_TSC_GetChannelClientList},
{"TSC_GetSubChannelListOnChannel", native_TSC_GetSubChannelListOnChannel},
{"TSC_KickClient", native_TSC_KickClient},
{"TSC_BanClient", native_TSC_BanClient},
{"TSC_MoveClient", native_TSC_MoveClient},
{"TSC_SetClientChannelGroup", native_TSC_SetClientChannelGroup},
{"TSC_AddClientToServerGroup", native_TSC_AddClientToServerGroup},
{"TSC_RemoveClientFromServerGroup", native_TSC_RemoveClientFromServerGroup},
{"TSC_GetClientDBIDByUID", native_TSC_GetClientDBIDByUID},
{"TSC_GetClientDBIDByID", native_TSC_GetClientDBIDByID},
{"TSC_GetClientName", native_TSC_GetClientName},
{"TSC_GetClientIDByName", native_TSC_GetClientIDByName},
{"TSC_GetClientCurrentChannelID", native_TSC_GetClientCurrentChannelID},
{NULL, NULL}
};
PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX *amx) {
return amx_Register(amx, NativesList, -1);
}
PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX *amx) {
return AMX_ERR_NONE;
}
string AMX_GetString(AMX* amx, cell param) {
cell *String;
char *Dest;
int Len;
amx_GetAddr(amx, param, &String);
amx_StrLen(String, &Len);
Dest = new char[Len + 1];
amx_GetString(Dest, String, 0, UNLIMITED);
Dest[Len] = '\0';
string Return(Dest);
delete Dest;
return Return;
}
int AMX_SetString(AMX* amx, cell param, string str) {
cell *Dest;
amx_GetAddr(amx, param, &Dest);
amx_SetString(Dest, str.c_str(), 0, 0, str.length() + 1);
return 1;
}<commit_msg>v0.3.1<commit_after>#pragma once
#include "main.h"
#include "natives.h"
#include "CTeamspeak.h"
void **ppPluginData;
extern void *pAMXFunctions;
logprintf_t logprintf;
PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports() {
return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES;
}
PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData) {
pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
logprintf = (logprintf_t)ppData[PLUGIN_DATA_LOGPRINTF];
#ifdef _WIN32
WSAData wsa_unused;
WSAStartup(MAKEWORD(2,0), &wsa_unused);
#endif
logprintf("TSConnector v0.3.1 loaded.");
return 1;
}
PLUGIN_EXPORT void PLUGIN_CALL Unload() {
#ifdef _WIN32
WSACleanup();
#endif
logprintf("TSConnector unloaded.");
}
#if defined __cplusplus
extern "C"
#endif
const AMX_NATIVE_INFO NativesList[] = {
{"TSC_Connect", native_TSC_Connect},
{"TSC_Disconnect", native_TSC_Disconnect},
{"TSC_Login", native_TSC_Login},
{"TSC_SetActiveVServer", native_TSC_SetActiveVServer},
{"TSC_SetTimeoutTime", native_TSC_SetTimeoutTime},
{"TSC_CreateChannel", native_TSC_CreateChannel},
{"TSC_DeleteChannel", native_TSC_DeleteChannel},
{"TSC_GetChannelIDByName", native_TSC_GetChannelIDByName},
{"TSC_SetChannelName", native_TSC_SetChannelName},
{"TSC_SetChannelDescription", native_TSC_SetChannelDescription},
{"TSC_SetChannelType", native_TSC_SetChannelType},
{"TSC_SetChannelPassword", native_TSC_SetChannelPassword},
{"TSC_SetChannelTalkPower", native_TSC_SetChannelTalkPower},
{"TSC_SetChannelUserLimit", native_TSC_SetChannelUserLimit},
{"TSC_SetChannelSubChannel", native_TSC_SetChannelSubChannel},
{"TSC_MoveChannelBelowChannel", native_TSC_MoveChannelBelowChannel},
{"TSC_GetChannelName", native_TSC_GetChannelName},
{"TSC_GetChannelClientList", native_TSC_GetChannelClientList},
{"TSC_GetSubChannelListOnChannel", native_TSC_GetSubChannelListOnChannel},
{"TSC_KickClient", native_TSC_KickClient},
{"TSC_BanClient", native_TSC_BanClient},
{"TSC_MoveClient", native_TSC_MoveClient},
{"TSC_SetClientChannelGroup", native_TSC_SetClientChannelGroup},
{"TSC_AddClientToServerGroup", native_TSC_AddClientToServerGroup},
{"TSC_RemoveClientFromServerGroup", native_TSC_RemoveClientFromServerGroup},
{"TSC_GetClientDBIDByUID", native_TSC_GetClientDBIDByUID},
{"TSC_GetClientDBIDByID", native_TSC_GetClientDBIDByID},
{"TSC_GetClientName", native_TSC_GetClientName},
{"TSC_GetClientIDByName", native_TSC_GetClientIDByName},
{"TSC_GetClientCurrentChannelID", native_TSC_GetClientCurrentChannelID},
{NULL, NULL}
};
PLUGIN_EXPORT int PLUGIN_CALL AmxLoad(AMX *amx) {
return amx_Register(amx, NativesList, -1);
}
PLUGIN_EXPORT int PLUGIN_CALL AmxUnload(AMX *amx) {
return AMX_ERR_NONE;
}
string AMX_GetString(AMX* amx, cell param) {
cell *String;
char *Dest;
int Len;
amx_GetAddr(amx, param, &String);
amx_StrLen(String, &Len);
Dest = new char[Len + 1];
amx_GetString(Dest, String, 0, UNLIMITED);
Dest[Len] = '\0';
string Return(Dest);
delete Dest;
return Return;
}
int AMX_SetString(AMX* amx, cell param, string str) {
cell *Dest;
amx_GetAddr(amx, param, &Dest);
amx_SetString(Dest, str.c_str(), 0, 0, str.length() + 1);
return 1;
}<|endoftext|> |
<commit_before>#include <iostream>
#include <GLES3/gl3.h>
#include <SDL/SDL.h>
#ifdef EMSCRIPTEN
#include <emscripten.h>
#endif
#include "shaders.h"
GLuint programObject;
SDL_Surface* screen;
GLfloat vVertices[] = {
-1.0f, 1.0f, 0.0f, // Top-left
1.0f, 1.0f, 0.0f, // Top-right
1.0f, -1.0f, 0.0f, // Bottom-right
1.0f, -1.0f, 0.0f, // Bottom-right
-1.0f, -1.0f, 0.0f, // Bottom-left
-1.0f, 1.0f, 0.0f, // Top-left
};
GLint uniformOriginX, uniformOriginY, uniformZoom;
extern "C" int initGL(int width, int height)
{
//initialise SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) == 0)
{
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL);
if (screen == NULL)
{
std::cerr << "Could not set video mode: " << SDL_GetError() << std::endl;
return 0;
}
}
else
{
std::cerr << "Could not initialize SDL: " << SDL_GetError() << std::endl;
return 0;
}
//SDL initialised successfully, now load shaders and geometry
const char vertexShaderSource[] =
"attribute vec4 vPosition; \n"
"varying vec3 color; \n"
"void main() \n"
"{ \n"
" gl_Position = vPosition; \n"
" color = gl_Position.xyz + vec3(0.5); \n"
"} \n";
const char fragmentShaderSource[] =
"precision mediump float; \n"
"varying vec3 color; \n"
"void main() \n"
"{ \n"
" gl_FragColor = vec4 ( color, 1.0 ); \n"
"} \n";
//load vertex and fragment shaders
GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexShaderSource);
GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
programObject = buildProgram(vertexShader, fragmentShader, "vPosition");
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
//glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
glViewport(0, 0, width, height);
return 1;
}
extern "C" void update()
{
}
extern "C" void draw()
{
//fill the screen with the clear color
glClear(GL_COLOR_BUFFER_BIT);
//enable our shader program
glUseProgram(programObject);
//set up the vertices array
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
//draw the triangle
glDrawArrays(GL_TRIANGLES, 0, 6);
//swap buffer to make whatever we've drawn to backbuffer appear on the screen
SDL_GL_SwapBuffers();
}<commit_msg>removed variables<commit_after>#include <iostream>
#include <GLES3/gl3.h>
#include <SDL/SDL.h>
#ifdef EMSCRIPTEN
#include <emscripten.h>
#endif
#include "shaders.h"
GLuint programObject;
SDL_Surface* screen;
GLfloat vVertices[] = {
-1.0f, 1.0f, 0.0f, // Top-left
1.0f, 1.0f, 0.0f, // Top-right
1.0f, -1.0f, 0.0f, // Bottom-right
1.0f, -1.0f, 0.0f, // Bottom-right
-1.0f, -1.0f, 0.0f, // Bottom-left
-1.0f, 1.0f, 0.0f, // Top-left
};
extern "C" int initGL(int width, int height)
{
//initialise SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) == 0)
{
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL);
if (screen == NULL)
{
std::cerr << "Could not set video mode: " << SDL_GetError() << std::endl;
return 0;
}
}
else
{
std::cerr << "Could not initialize SDL: " << SDL_GetError() << std::endl;
return 0;
}
//SDL initialised successfully, now load shaders and geometry
const char vertexShaderSource[] =
"attribute vec4 vPosition; \n"
"varying vec3 color; \n"
"void main() \n"
"{ \n"
" gl_Position = vPosition; \n"
" color = gl_Position.xyz + vec3(0.5); \n"
"} \n";
const char fragmentShaderSource[] =
"precision mediump float; \n"
"varying vec3 color; \n"
"void main() \n"
"{ \n"
" gl_FragColor = vec4 ( color, 1.0 ); \n"
"} \n";
//load vertex and fragment shaders
GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexShaderSource);
GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
programObject = buildProgram(vertexShader, fragmentShader, "vPosition");
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
//glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
glViewport(0, 0, width, height);
return 1;
}
extern "C" void update()
{
}
extern "C" void draw()
{
//fill the screen with the clear color
glClear(GL_COLOR_BUFFER_BIT);
//enable our shader program
glUseProgram(programObject);
//set up the vertices array
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
glEnableVertexAttribArray(0);
//draw the triangle
glDrawArrays(GL_TRIANGLES, 0, 6);
//swap buffer to make whatever we've drawn to backbuffer appear on the screen
SDL_GL_SwapBuffers();
}<|endoftext|> |
<commit_before>// Lesson 13.cpp : Defines the entry point for the console application.
#include <render_framework\render_framework.h>
#pragma comment (lib , "Render Framework" )
using namespace std;
using namespace glm;
using namespace render_framework;
int main()
{
// Initialize the renderer
if (!renderer::get_instance().initialise()) return -1;
// Set the clear colour to cyan
glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
/* Set the projection matrix */
// First get the aspect ratio (width/height)
float aspect = (float)renderer::get_instance().get_screen_width() /
(float)renderer::get_instance().get_screen_width();
// Use this to create projection matrix
auto projection = perspective(
degrees(quarter_pi<float>()), // FOV
aspect, // Aspect ratio
2.414f, // Near plane
10000.0f); // Far plane
// Set the projection matrix
renderer::get_instance().set_projection(projection);
// Set the view matrix
auto view = lookAt(
vec3(20.0f, 20.0f, 20.0f), // Camera position
vec3(0.0f, 0.0f, 0.0f), // Target
vec3(0.0f, 1.0f, 0.0f)); // Up vector
renderer::get_instance().set_view(view);
// Create Cube
auto box = geometry_builder::create_box();
// Main render loop
while (renderer::get_instance().is_running())
{
// Check if running
if (renderer::get_instance().begin_render())
{
// Render Cube
renderer::get_instance().render(box);
// End the render
renderer::get_instance().end_render();
}
}
}
<commit_msg>Created Torus<commit_after>// Lesson 13.cpp : Defines the entry point for the console application.
#include <render_framework\render_framework.h>
#pragma comment (lib , "Render Framework" )
using namespace std;
using namespace glm;
using namespace render_framework;
int main()
{
// Initialize the renderer
if (!renderer::get_instance().initialise()) return -1;
// Set the clear colour to cyan
glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
/* Set the projection matrix */
// First get the aspect ratio (width/height)
float aspect = (float)renderer::get_instance().get_screen_width() /
(float)renderer::get_instance().get_screen_width();
// Use this to create projection matrix
auto projection = perspective(
degrees(quarter_pi<float>()), // FOV
aspect, // Aspect ratio
2.414f, // Near plane
10000.0f); // Far plane
// Set the projection matrix
renderer::get_instance().set_projection(projection);
// Set the view matrix
auto view = lookAt(
vec3(20.0f, 20.0f, 20.0f), // Camera position
vec3(0.0f, 0.0f, 0.0f), // Target
vec3(0.0f, 1.0f, 0.0f)); // Up vector
renderer::get_instance().set_view(view);
// Create Cube
auto object = geometry_builder::create_torus();
// Main render loop
while (renderer::get_instance().is_running())
{
// Check if running
if (renderer::get_instance().begin_render())
{
// Render Cube
renderer::get_instance().render(object);
// End the render
renderer::get_instance().end_render();
}
}
}
<|endoftext|> |
<commit_before>#include <cstdlib>
#include <sys/wait.h>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
//#include <stdio.h>
#include <errno.h>
//#include <stdlib.h>
using namespace std;
void connectors(string userinput, vector<int> &x, vector<int> &y, bool &first) {
for(unsigned int i = 0; i < userinput.size() - 1; i++) {
if((userinput.at(i) == '|') && (userinput.at(i + 1) == '|')) {
x.push_back(0);
y.push_back(i);
}
else if((userinput.at(i) == '&') && (userinput.at(i + 1) == '&')) {
x.push_back(1);
y.push_back(i);
}
else if((userinput.at(i) == ';')) {
x.push_back(2);
y.push_back(i);
}
}
y.push_back(0);
}
int main() {
string userinput;
string login;
if(!getlogin())
perror("getlogin");
else
login = getlogin();
char hostname[128];
if(gethostname(hostname, sizeof hostname))
perror("gethostname");
char limits[5] = ";&| ";
bool ext = false;
while(!ext) {
cout << getlogin() << "@" << hostname << " $ ";
char *command_a;
char *command;
getline(cin, userinput);
if(userinput.size() == 0)
userinput = {'#'};
command = new char[userinput.size()];
vector<int> c_pat;
vector<int> c_pos;
bool first = false;
userinput.size();
connectors(userinput, c_pat, c_pos, first);
int x = 0;
int b = 0;
int y = 0;
char *arg[100000];
if(userinput.size() != 0) {
while(c_pos.at(y) != 0) {
if(c_pat.size() == 0)
strcpy(command, userinput.c_str());
else
strcpy(command, userinput.substr(x, c_pos.at(y) - x).c_str());
command_a = strtok(command,limits);
while(command_a != NULL) {
if(command_a[0] == '#')
break;
arg[b] = command_a;
command_a = strtok(NULL, limits);
b++;
}
int i = fork();
if(i == -1)
perror("fork");
if(i == 0) {
if(execvp(arg[0], arg) == -1)
perror("execvp");
exit(0);
}
int status;
wait(&status);
x = c_pos.at(y);
for(unsigned int i = 0; i < b; i++)
arg[i] = NULL;
if(c_pat.at(y) == 0 && status != -1 && userinput.find("&&", y) != string::npos && userinput.find(";", y))
y++;
else if(c_pat.at(y) == 0 && status != -1) {
y++;
break;
}
else if(c_pat.at(y) == 1 && status == -1 && userinput.find("||", y) != string::npos && userinput.find(";", y))
y++;
else if(c_pat.at(y) == 1 && status == -1) {
y++;
break;
}
else
y++;
b = 0;
}
}
}
return 0;
}
<commit_msg>ned to fix connector priortity and syntax<commit_after>#include <cstdlib>
#include <sys/wait.h>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
//#include <stdio.h>
#include <errno.h>
//#include <stdlib.h>
using namespace std;
void connectors(string userinput, vector<int> &x, vector<int> &y, bool &first) {
for(unsigned int i = 0; i < userinput.size() - 1; i++) {
if((userinput.at(i) == '|') && (userinput.at(i + 1) == '|')) {
x.push_back(0);
y.push_back(i);
}
else if((userinput.at(i) == '&') && (userinput.at(i + 1) == '&')) {
x.push_back(1);
y.push_back(i);
}
else if((userinput.at(i) == ';')) {
x.push_back(2);
y.push_back(i);
}
}
y.push_back(0);
}
int main() {
string userinput;
string login;
if(!getlogin())
perror("getlogin");
else
login = getlogin();
char hostname[128];
if(gethostname(hostname, sizeof hostname))
perror("gethostname");
char limits[5] = ";&| ";
bool ext = false;
while(!ext) {
cout << getlogin() << "@" << hostname << " $ ";
char *command_a;
char *command;
getline(cin, userinput);
if(userinput.size() == 0)
userinput = {'#'};
command = new char[userinput.size()];
vector<int> c_pat;
vector<int> c_pos;
bool first = false;
userinput.size();
connectors(userinput, c_pat, c_pos, first);
int x = 0;
int b = 0;
int y = 0;
char *arg[100000];
while(c_pos.at(y) != 0) {
if(c_pat.size() == 0)
strcpy(command, userinput.c_str());
else
strcpy(command, userinput.substr(x, c_pos.at(y) - x).c_str());
command_a = strtok(command,limits);
while(command_a != NULL) {
if(command_a[0] == '#')
break;
arg[b] = command_a;
command_a = strtok(NULL, limits);
b++;
}
int i = fork();
if(i == -1)
perror("fork");
if(i == 0) {
if(execvp(arg[0], arg) == -1)
perror("execvp");
exit(0);
}
int status;
wait(&status);
x = c_pos.at(y);
for(unsigned int i = 0; i < b; i++)
arg[i] = NULL;
if(c_pat.at(y) == 0 && status != -1 && userinput.find("&&", y) != string::npos && userinput.find(";", y))
y++;
else if(c_pat.at(y) == 0 && status != -1) {
y++;
break;
}
else if(c_pat.at(y) == 1 && status == -1 && userinput.find("||", y) != string::npos && userinput.find(";", y))
y++;
else if(c_pat.at(y) == 1 && status == -1) {
y++;
break;
}
else
y++;
b = 0;
}
}
return 0;
}
<|endoftext|> |
<commit_before>/*
* test.cpp
*
* Created on: Nov 19, 2014
* Author: matheus
*/
#include <cstdlib>
#include <ctime>
#include "ConcreteGraph.hpp"
#include "Helpers.hpp"
#include "Time.hpp"
#include "GraphAlgorithms.hpp"
#include "ThreadManager.hpp"
using namespace std;
using namespace graph;
static int n_threads = 1;
static int delta = 1;
static int max_weight = 100;
static int order = 100;
static inline float readAndRun() {
IntArrayGraphMapNeighbourHood G;
scanDirectedGraph(G, stdin);
int* dist = new int[G.order() + 1];
Stopwatch sw;
IntParallelDeltaStepping().run(G, 1, dist);
float dt = sw.time();
delete[] dist;
return dt;
}
void test(int argc, char** argv) {
if (argc >= 2) {
sscanf(argv[1], "%d", &n_threads);
}
if (argc >= 3) {
sscanf(argv[2], "%d", &delta);
}
if (argc >= 4) {
sscanf(argv[3], "%d", &max_weight);
}
if (argc >= 5) {
sscanf(argv[4], "%d", &order);
}
srand(time(nullptr));
DeltaStepping::init(&delta);
ThreadManager::init(n_threads);
Stopwatch sw;
printf("%f\n", readAndRun());
printf("time with input: %f s\n", sw.time());
printf("total relaxations: %lu\n", DeltaStepping::relaxations());
ThreadManager::close();
DeltaStepping::close();
}
<commit_msg>Reading source from input<commit_after>/*
* test.cpp
*
* Created on: Nov 19, 2014
* Author: matheus
*/
#include <cstdlib>
#include <ctime>
#include "ConcreteGraph.hpp"
#include "Helpers.hpp"
#include "Time.hpp"
#include "GraphAlgorithms.hpp"
#include "ThreadManager.hpp"
using namespace std;
using namespace graph;
static int n_threads = 1;
static int delta = 1;
static int max_weight = 100;
static int order = 100;
static inline float readAndRun() {
IntArrayGraphMapNeighbourHood G;
scanDirectedGraph(G, stdin);
int source;
scanf("%d", &source);
int* dist = new int[G.order() + 1];
Stopwatch sw;
IntParallelDeltaStepping().run(G, source, dist);
float dt = sw.time();
delete[] dist;
return dt;
}
void test(int argc, char** argv) {
if (argc >= 2) {
sscanf(argv[1], "%d", &n_threads);
}
if (argc >= 3) {
sscanf(argv[2], "%d", &delta);
}
if (argc >= 4) {
sscanf(argv[3], "%d", &max_weight);
}
if (argc >= 5) {
sscanf(argv[4], "%d", &order);
}
srand(time(nullptr));
DeltaStepping::init(&delta);
ThreadManager::init(n_threads);
Stopwatch sw;
printf("%f s\n", readAndRun());
printf("time with input: %f s\n", sw.time());
printf("total relaxations: %lu\n", DeltaStepping::relaxations());
ThreadManager::close();
DeltaStepping::close();
}
<|endoftext|> |
<commit_before>/*************************************************************************
* Copyright (C) 2011-2012 by Paul-Louis Ageneau *
* paul-louis (at) ageneau (dot) org *
* *
* This file is part of TeapotNet. *
* *
* TeapotNet is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version. *
* *
* TeapotNet is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public *
* License along with TeapotNet. *
* If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
#include "time.h"
#include "exception.h"
#include "string.h"
namespace tpot
{
Mutex Time::TimeMutex;
Time Time::Now(void)
{
return Time();
}
uint64_t Time::Milliseconds(void)
{
timeval tv;
gettimeofday(&tv, NULL);
return uint64_t(tv.tv_sec)*1000 + uint64_t(tv.tv_usec)/1000;
}
void Time::Schedule(const Time &when, Thread *thread)
{
// TODO
}
Time::Time(void) :
mTime(0)
{
time(&mTime);
}
Time::Time(time_t time = 0) :
mTime(time)
{
}
// Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
// Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
// Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
//
Time::Time(const String &str)
{
const String months[] = {"jan","feb","mar","apr","may","jun","sep","oct","nov","dec"};
if(str.empty())
{
mTime = time_t(0);
return;
}
List<String> list;
str.explode(list, ' ');
struct tm tms;
std::memset(&tms, 0, sizeof(tms));
tms.tm_isdst = -1;
switch(list.size())
{
case 1: // Unix timestamp as integer
str.extract(mTime);
return;
case 4: // RFC 850
{
list.pop_front(); // we don't care about day of week
String tmp;
tmp = list.front(); list.pop_front();
List<String> dateParts;
tmp.explode(dateParts, '-');
Assert(dateParts.size() == 3);
tms.tm_mday = dateParts.front().toInt(); dateParts.pop_front();
tmp = dateParts.front().toInt(); dateParts.pop_front();
int m = 0; while(m < 12 && months[m] != tmp) ++m;
Assert(m < 12);
tms.tm_mon = m;
tms.tm_year = 1900 + dateParts.front().toInt(); dateParts.pop_front();
tmp = list.front(); list.pop_front();
List<String> hourParts;
tmp.explode(hourParts, '-');
Assert(hourParts.size() == 3);
tms.tm_hour = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_min = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_sec = hourParts.front().toInt(); hourParts.pop_front();
String utc = list.front().toLower(); list.pop_front();
tmp = utc.cut('+');
Assert(utc == "UTC" || utc == "GMT");
if(!tmp.empty()) tms.tm_hour = tms.tm_hour - tmp.toInt();
break;
}
case 5: // asctime() format
{
list.pop_front(); // we don't care about day of week
String tmp;
tmp = list.front().toLower(); list.pop_front();
int m = 0; while(m < 12 && months[m] != tmp) ++m;
Assert(m < 12);
tms.tm_mon = m;
tms.tm_mday = list.front().toInt(); list.pop_front();
tmp = list.front(); list.pop_front();
List<String> hourParts;
tmp.explode(hourParts, ':');
Assert(hourParts.size() == 3);
tms.tm_hour = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_min = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_sec = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_year = list.front().toInt(); list.pop_front();
break;
}
case 6: // RFC 1123
{
list.pop_front(); // we don't care about day of week
tms.tm_mday = list.front().toInt(); list.pop_front();
String tmp;
tmp = list.front().toLower(); list.pop_front();
int m = 0; while(m < 12 && months[m] != tmp) ++m;
Assert(m < 12);
tms.tm_mon = m;
tms.tm_year = list.front().toInt(); list.pop_front();
tmp = list.front(); list.pop_front();
List<String> hourParts;
tmp.explode(hourParts, ':');
Assert(hourParts.size() == 3);
tms.tm_hour = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_min = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_sec = hourParts.front().toInt(); hourParts.pop_front();
String utc = list.front().toUpper(); list.pop_front();
tmp = utc.cut('+');
Assert(utc == "UTC" || utc == "GMT");
if(!tmp.empty()) tms.tm_hour = tms.tm_hour - tmp.toInt();
break;
}
default:
throw Exception(String("Unknown date format: ") + str);
}
TimeMutex.lock();
char *tz = getenv("TZ");
putenv(const_cast<char*>("TZ=UTC"));
tzset();
mTime = std::mktime(&tms);
if(tz)
{
char *buf = reinterpret_cast<char*>(std::malloc(3 + strlen(tz) + 1));
if(buf)
{
std::strcpy(buf,"TZ=");
std::strcat(buf, tz);
putenv(buf);
}
}
else {
putenv(const_cast<char*>("TZ="));
}
tzset();
TimeMutex.unlock();
if(mTime == time_t(-1))
throw Exception(String("Invalid date: ") + str);
}
Time::~Time(void)
{
}
String Time::toDisplayDate(void) const
{
TimeMutex.lock();
char buffer[256];
strftime (buffer, 256, "%x %X", localtime(&mTime));
TimeMutex.unlock();
return String(buffer);
}
String Time::toHttpDate(void) const
{
TimeMutex.lock();
struct tm *tmptr = gmtime(&mTime); // not necessarily thread safe
char buffer[256];
strftime(buffer, 256, "%a, %d %b %Y %H:%M:%S", tmptr);
TimeMutex.unlock();
return String(buffer) + " GMT";
}
time_t Time::toUnixTime(void) const
{
return mTime;
}
unsigned Time::toDays(void) const
{
return unsigned((*this - Time(0))/86400);
}
unsigned Time::toHours(void) const
{
return unsigned((*this - Time(0))/3600);
}
double Time::operator - (const Time &t)
{
return difftime(mTime, t.mTime);
}
Time::operator time_t(void) const
{
return toUnixTime();
}
void Time::serialize(Serializer &s) const
{
s.output(int64_t(mTime));
}
bool Time::deserialize(Serializer &s)
{
int64_t tmp = 0;
s.input(tmp);
mTime = time_t(tmp);
return true;
}
bool operator < (const Time &t1, const Time &t2)
{
return (t1-t2 < 0.);
}
bool operator > (const Time &t1, const Time &t2)
{
return (t1-t2 > 0.);
}
bool operator == (const Time &t1, const Time &t2)
{
return t1.toUnixTime() == t2.toUnixTime();
}
bool operator != (const Time &t1, const Time &t2)
{
return !(t1 == t2);
}
}
<commit_msg>Potential problem when parsing an Unix timestamp<commit_after>/*************************************************************************
* Copyright (C) 2011-2012 by Paul-Louis Ageneau *
* paul-louis (at) ageneau (dot) org *
* *
* This file is part of TeapotNet. *
* *
* TeapotNet is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version. *
* *
* TeapotNet is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public *
* License along with TeapotNet. *
* If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
#include "time.h"
#include "exception.h"
#include "string.h"
namespace tpot
{
Mutex Time::TimeMutex;
Time Time::Now(void)
{
return Time();
}
uint64_t Time::Milliseconds(void)
{
timeval tv;
gettimeofday(&tv, NULL);
return uint64_t(tv.tv_sec)*1000 + uint64_t(tv.tv_usec)/1000;
}
void Time::Schedule(const Time &when, Thread *thread)
{
// TODO
}
Time::Time(void) :
mTime(0)
{
time(&mTime);
}
Time::Time(time_t time = 0) :
mTime(time)
{
}
// Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
// Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
// Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
//
Time::Time(const String &str)
{
const String months[] = {"jan","feb","mar","apr","may","jun","sep","oct","nov","dec"};
if(str.empty())
{
mTime = time_t(0);
return;
}
List<String> list;
str.trimmed().explode(list, ' ');
struct tm tms;
std::memset(&tms, 0, sizeof(tms));
tms.tm_isdst = -1;
switch(list.size())
{
case 1: // Unix timestamp as integer
str.extract(mTime);
return;
case 4: // RFC 850
{
list.pop_front(); // we don't care about day of week
String tmp;
tmp = list.front(); list.pop_front();
List<String> dateParts;
tmp.explode(dateParts, '-');
Assert(dateParts.size() == 3);
tms.tm_mday = dateParts.front().toInt(); dateParts.pop_front();
tmp = dateParts.front().toInt(); dateParts.pop_front();
int m = 0; while(m < 12 && months[m] != tmp) ++m;
Assert(m < 12);
tms.tm_mon = m;
tms.tm_year = 1900 + dateParts.front().toInt(); dateParts.pop_front();
tmp = list.front(); list.pop_front();
List<String> hourParts;
tmp.explode(hourParts, '-');
Assert(hourParts.size() == 3);
tms.tm_hour = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_min = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_sec = hourParts.front().toInt(); hourParts.pop_front();
String utc = list.front().toLower(); list.pop_front();
tmp = utc.cut('+');
Assert(utc == "UTC" || utc == "GMT");
if(!tmp.empty()) tms.tm_hour = tms.tm_hour - tmp.toInt();
break;
}
case 5: // asctime() format
{
list.pop_front(); // we don't care about day of week
String tmp;
tmp = list.front().toLower(); list.pop_front();
int m = 0; while(m < 12 && months[m] != tmp) ++m;
Assert(m < 12);
tms.tm_mon = m;
tms.tm_mday = list.front().toInt(); list.pop_front();
tmp = list.front(); list.pop_front();
List<String> hourParts;
tmp.explode(hourParts, ':');
Assert(hourParts.size() == 3);
tms.tm_hour = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_min = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_sec = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_year = list.front().toInt(); list.pop_front();
break;
}
case 6: // RFC 1123
{
list.pop_front(); // we don't care about day of week
tms.tm_mday = list.front().toInt(); list.pop_front();
String tmp;
tmp = list.front().toLower(); list.pop_front();
int m = 0; while(m < 12 && months[m] != tmp) ++m;
Assert(m < 12);
tms.tm_mon = m;
tms.tm_year = list.front().toInt(); list.pop_front();
tmp = list.front(); list.pop_front();
List<String> hourParts;
tmp.explode(hourParts, ':');
Assert(hourParts.size() == 3);
tms.tm_hour = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_min = hourParts.front().toInt(); hourParts.pop_front();
tms.tm_sec = hourParts.front().toInt(); hourParts.pop_front();
String utc = list.front().toUpper(); list.pop_front();
tmp = utc.cut('+');
Assert(utc == "UTC" || utc == "GMT");
if(!tmp.empty()) tms.tm_hour = tms.tm_hour - tmp.toInt();
break;
}
default:
throw Exception(String("Unknown date format: ") + str);
}
TimeMutex.lock();
char *tz = getenv("TZ");
putenv(const_cast<char*>("TZ=UTC"));
tzset();
mTime = std::mktime(&tms);
if(tz)
{
char *buf = reinterpret_cast<char*>(std::malloc(3 + strlen(tz) + 1));
if(buf)
{
std::strcpy(buf,"TZ=");
std::strcat(buf, tz);
putenv(buf);
}
}
else {
putenv(const_cast<char*>("TZ="));
}
tzset();
TimeMutex.unlock();
if(mTime == time_t(-1))
throw Exception(String("Invalid date: ") + str);
}
Time::~Time(void)
{
}
String Time::toDisplayDate(void) const
{
TimeMutex.lock();
char buffer[256];
strftime (buffer, 256, "%x %X", localtime(&mTime));
TimeMutex.unlock();
return String(buffer);
}
String Time::toHttpDate(void) const
{
TimeMutex.lock();
struct tm *tmptr = gmtime(&mTime); // not necessarily thread safe
char buffer[256];
strftime(buffer, 256, "%a, %d %b %Y %H:%M:%S", tmptr);
TimeMutex.unlock();
return String(buffer) + " GMT";
}
time_t Time::toUnixTime(void) const
{
return mTime;
}
unsigned Time::toDays(void) const
{
return unsigned((*this - Time(0))/86400);
}
unsigned Time::toHours(void) const
{
return unsigned((*this - Time(0))/3600);
}
double Time::operator - (const Time &t)
{
return difftime(mTime, t.mTime);
}
Time::operator time_t(void) const
{
return toUnixTime();
}
void Time::serialize(Serializer &s) const
{
s.output(int64_t(mTime));
}
bool Time::deserialize(Serializer &s)
{
int64_t tmp = 0;
s.input(tmp);
mTime = time_t(tmp);
return true;
}
bool operator < (const Time &t1, const Time &t2)
{
return (t1-t2 < 0.);
}
bool operator > (const Time &t1, const Time &t2)
{
return (t1-t2 > 0.);
}
bool operator == (const Time &t1, const Time &t2)
{
return t1.toUnixTime() == t2.toUnixTime();
}
bool operator != (const Time &t1, const Time &t2)
{
return !(t1 == t2);
}
}
<|endoftext|> |
<commit_before>// Project specific
#include <Manager/AI/AIPathManager.hpp>
#include <EntityComponent/EntityHandler.hpp>
#include <PlayerHandler.hpp>
#include <Helper/ProximityChecker.hpp>
#include <EntityComponent/Components/HealthComponent.hpp>
#include <EntityComponent/Components/RigidBodyComponent.hpp>
#include <EntityComponent/Components/TransformComponent.hpp>
#include <EntityComponent/Components/PotentialFieldComponent.hpp>
#include <EntityComponent/Components/MovementComponent.hpp>
#include <EntityComponent/Components/AIGroupComponent.hpp>
// Engine
#include <DoremiEngine/Physics/Include/PhysicsModule.hpp>
#include <DoremiEngine/Physics/Include/RigidBodyManager.hpp>
#include <DoremiEngine/AI/Include/Interface/PotentialField/PotentialFieldActor.hpp>
#include <DoremiEngine/AI/Include/Interface/PotentialField/PotentialField.hpp>
#include <DoremiEngine/AI/Include/Interface/PotentialField/PotentialGroup.hpp>
#include <DoremiEngine/AI/Include/Interface/SubModule/PotentialFieldSubModule.hpp>
#include <DoremiEngine/AI/Include/AIModule.hpp>
// Standard
#include <iostream>
#include <DirectXMath.h>
#include <set>
using namespace std;
namespace Doremi
{
namespace Core
{
AIPathManager::AIPathManager(const DoremiEngine::Core::SharedContext& p_sharedContext) : Manager(p_sharedContext)
{
// TODOKO do this in a better place, might not work to have here in the future
m_field = m_sharedContext.GetAIModule().GetPotentialFieldSubModule().CreateNewField(100, 100, 100, 100, XMFLOAT2(0, 0));
}
AIPathManager::~AIPathManager() {}
void AIPathManager::Update(double p_dt)
{
size_t playerID = PlayerHandler::GetInstance()->GetDefaultPlayerEntityID();
size_t length = EntityHandler::GetInstance().GetLastEntityIndex();
int mask = (int)ComponentType::AIAgent | (int)ComponentType::Transform | (int)ComponentType::Health;
// TODOKO Should be done in a better way...
if(firstUpdate)
{
int enemyID = -1;
firstUpdate = false;
// creating a invisible "wall", for testing only
DoremiEngine::AI::PotentialFieldActor* actorwall =
m_sharedContext.GetAIModule().GetPotentialFieldSubModule().CreateNewActor(XMFLOAT3(0, 0, 25), -10, 5);
m_sharedContext.GetAIModule().GetPotentialFieldSubModule().AttachActor(*m_field, actorwall);
m_field->Update();
for(size_t i = 0; i < length; i++)
{
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::PotentialField))
{
// adding actors to field
// DoremiEngine::AI::PotentialFieldActor* actor =
// EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
// m_sharedContext.GetAIModule().GetPotentialFieldSubModule().AttachActor(*m_field, actor);
}
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::AIGroup | (int)ComponentType::PotentialField))
{
enemyID = i;
DoremiEngine::AI::PotentialFieldActor* actor = EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
DoremiEngine::AI::PotentialGroup* group = EntityHandler::GetInstance().GetComponentFromStorage<AIGroupComponent>(i)->Group;
group->AddActor(actor);
}
}
if(enemyID != -1)
{
DoremiEngine::AI::PotentialFieldActor* actor =
EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(playerID)->ChargedActor;
DoremiEngine::AI::PotentialGroup* group = EntityHandler::GetInstance().GetComponentFromStorage<AIGroupComponent>(enemyID)->Group;
group->AddActor(actor);
}
}
// TO HERE
for(size_t i = 0; i < length; i++)
{
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::PotentialField | (int)ComponentType::Transform))
{
DoremiEngine::AI::PotentialFieldActor* actor = EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
XMFLOAT3 pos = EntityHandler::GetInstance().GetComponentFromStorage<TransformComponent>(i)->position;
actor->SetPosition(pos);
}
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::AIAgent | (int)ComponentType::Transform |
(int)ComponentType::Movement | (int)ComponentType::AIGroup))
{
XMFLOAT2 desiredPos;
XMFLOAT3 unitPos = EntityHandler::GetInstance().GetComponentFromStorage<TransformComponent>(i)->position;
DoremiEngine::AI::PotentialGroup* group = EntityHandler::GetInstance().GetComponentFromStorage<AIGroupComponent>(i)->Group;
DoremiEngine::AI::PotentialFieldActor* currentActor =
EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::PotentialField))
{
desiredPos = m_field->GetAttractionPosition(unitPos, currentActor, true);
}
else
{
desiredPos = m_field->GetAttractionPosition(unitPos, nullptr, true);
}
XMFLOAT3 desiredPos3D = XMFLOAT3(desiredPos.x, unitPos.y, desiredPos.y);
XMFLOAT3 groupImpact = group->GetForceDirection(unitPos, currentActor);
XMVECTOR groupImpactVec = XMLoadFloat3(&groupImpact);
XMVECTOR desiredPosVec = XMLoadFloat3(&desiredPos3D);
XMVECTOR unitPosVec = XMLoadFloat3(&unitPos);
XMVECTOR dirVec = desiredPosVec - unitPosVec;
dirVec = XMVector3Normalize(dirVec);
dirVec += groupImpactVec * 0.2f; // TODOKO remove this variable!! Its there to make the static field more influencial
dirVec = XMVector3Normalize(dirVec);
XMFLOAT3 direction;
XMStoreFloat3(&direction, dirVec * 0.2f); // TODOKO remove this hard coded shiat
MovementComponent* moveComp = EntityHandler::GetInstance().GetComponentFromStorage<MovementComponent>(i);
moveComp->movement = direction;
}
}
}
void AIPathManager::OnEvent(Event* p_event) {}
}
}<commit_msg>Made AI slower. Easier to debug<commit_after>// Project specific
#include <Manager/AI/AIPathManager.hpp>
#include <EntityComponent/EntityHandler.hpp>
#include <PlayerHandler.hpp>
#include <Helper/ProximityChecker.hpp>
#include <EntityComponent/Components/HealthComponent.hpp>
#include <EntityComponent/Components/RigidBodyComponent.hpp>
#include <EntityComponent/Components/TransformComponent.hpp>
#include <EntityComponent/Components/PotentialFieldComponent.hpp>
#include <EntityComponent/Components/MovementComponent.hpp>
#include <EntityComponent/Components/AIGroupComponent.hpp>
// Engine
#include <DoremiEngine/Physics/Include/PhysicsModule.hpp>
#include <DoremiEngine/Physics/Include/RigidBodyManager.hpp>
#include <DoremiEngine/AI/Include/Interface/PotentialField/PotentialFieldActor.hpp>
#include <DoremiEngine/AI/Include/Interface/PotentialField/PotentialField.hpp>
#include <DoremiEngine/AI/Include/Interface/PotentialField/PotentialGroup.hpp>
#include <DoremiEngine/AI/Include/Interface/SubModule/PotentialFieldSubModule.hpp>
#include <DoremiEngine/AI/Include/AIModule.hpp>
// Standard
#include <iostream>
#include <DirectXMath.h>
#include <set>
using namespace std;
namespace Doremi
{
namespace Core
{
AIPathManager::AIPathManager(const DoremiEngine::Core::SharedContext& p_sharedContext) : Manager(p_sharedContext)
{
// TODOKO do this in a better place, might not work to have here in the future
m_field = m_sharedContext.GetAIModule().GetPotentialFieldSubModule().CreateNewField(100, 100, 100, 100, XMFLOAT2(0, 0));
}
AIPathManager::~AIPathManager() {}
void AIPathManager::Update(double p_dt)
{
size_t playerID = PlayerHandler::GetInstance()->GetDefaultPlayerEntityID();
size_t length = EntityHandler::GetInstance().GetLastEntityIndex();
int mask = (int)ComponentType::AIAgent | (int)ComponentType::Transform | (int)ComponentType::Health;
// TODOKO Should be done in a better way...
if(firstUpdate)
{
int enemyID = -1;
firstUpdate = false;
// creating a invisible "wall", for testing only
DoremiEngine::AI::PotentialFieldActor* actorwall =
m_sharedContext.GetAIModule().GetPotentialFieldSubModule().CreateNewActor(XMFLOAT3(0, 0, 25), -10, 5);
m_sharedContext.GetAIModule().GetPotentialFieldSubModule().AttachActor(*m_field, actorwall);
m_field->Update();
for(size_t i = 0; i < length; i++)
{
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::PotentialField))
{
// adding actors to field
// DoremiEngine::AI::PotentialFieldActor* actor =
// EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
// m_sharedContext.GetAIModule().GetPotentialFieldSubModule().AttachActor(*m_field, actor);
}
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::AIGroup | (int)ComponentType::PotentialField))
{
enemyID = i;
DoremiEngine::AI::PotentialFieldActor* actor = EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
DoremiEngine::AI::PotentialGroup* group = EntityHandler::GetInstance().GetComponentFromStorage<AIGroupComponent>(i)->Group;
group->AddActor(actor);
}
}
if(enemyID != -1)
{
DoremiEngine::AI::PotentialFieldActor* actor =
EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(playerID)->ChargedActor;
DoremiEngine::AI::PotentialGroup* group = EntityHandler::GetInstance().GetComponentFromStorage<AIGroupComponent>(enemyID)->Group;
group->AddActor(actor);
}
}
// TO HERE
for(size_t i = 0; i < length; i++)
{
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::PotentialField | (int)ComponentType::Transform))
{
DoremiEngine::AI::PotentialFieldActor* actor = EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
XMFLOAT3 pos = EntityHandler::GetInstance().GetComponentFromStorage<TransformComponent>(i)->position;
actor->SetPosition(pos);
}
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::AIAgent | (int)ComponentType::Transform |
(int)ComponentType::Movement | (int)ComponentType::AIGroup))
{
XMFLOAT2 desiredPos;
XMFLOAT3 unitPos = EntityHandler::GetInstance().GetComponentFromStorage<TransformComponent>(i)->position;
DoremiEngine::AI::PotentialGroup* group = EntityHandler::GetInstance().GetComponentFromStorage<AIGroupComponent>(i)->Group;
DoremiEngine::AI::PotentialFieldActor* currentActor =
EntityHandler::GetInstance().GetComponentFromStorage<PotentialFieldComponent>(i)->ChargedActor;
if(EntityHandler::GetInstance().HasComponents(i, (int)ComponentType::PotentialField))
{
desiredPos = m_field->GetAttractionPosition(unitPos, currentActor, true);
}
else
{
desiredPos = m_field->GetAttractionPosition(unitPos, nullptr, true);
}
XMFLOAT3 desiredPos3D = XMFLOAT3(desiredPos.x, unitPos.y, desiredPos.y);
XMFLOAT3 groupImpact = group->GetForceDirection(unitPos, currentActor);
XMVECTOR groupImpactVec = XMLoadFloat3(&groupImpact);
XMVECTOR desiredPosVec = XMLoadFloat3(&desiredPos3D);
XMVECTOR unitPosVec = XMLoadFloat3(&unitPos);
XMVECTOR dirVec = desiredPosVec - unitPosVec;
dirVec = XMVector3Normalize(dirVec);
dirVec += groupImpactVec * 0.2f; // TODOKO remove this variable!! Its there to make the static field more influencial
dirVec = XMVector3Normalize(dirVec);
XMFLOAT3 direction;
XMStoreFloat3(&direction, dirVec * 0.02f); // TODOKO remove this hard coded shiat
MovementComponent* moveComp = EntityHandler::GetInstance().GetComponentFromStorage<MovementComponent>(i);
moveComp->movement = direction;
}
}
}
void AIPathManager::OnEvent(Event* p_event) {}
}
}<|endoftext|> |
<commit_before>// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2020 Intel Corporation. All Rights Reserved.
//#cmake:add-file ../../../src/algo/depth-to-rgb-calibration/*.cpp
#include "d2rgb-common.h"
#include "compare-to-bin-file.h"
#include "compare-scene.h"
TEST_CASE("Scene 2", "[d2rgb]")
{
//std::string scene_dir("C:\\work\\librealsense\\build\\unit-tests\\algo\\depth-to-rgb-calibration\\19.2.20");
//std::string scene_dir("..\\unit-tests\\algo\\depth-to-rgb-calibration\\19.2.20");
std::string scene_dir( "C:\\work\\autocal" );
scene_dir += "\\F9440687\\LongRange_D_768x1024_RGB_1920x1080\\2\\";
compare_scene( scene_dir );
}
<commit_msg>skip scene-2 unit-test unless dir exists, so Travis passes<commit_after>// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2020 Intel Corporation. All Rights Reserved.
//#cmake:add-file ../../../src/algo/depth-to-rgb-calibration/*.cpp
#include "d2rgb-common.h"
#include "compare-to-bin-file.h"
#include "compare-scene.h"
TEST_CASE("Scene 2", "[d2rgb]")
{
// TODO so Travis passes, until we fix the test-case
//std::string scene_dir("..\\unit-tests\\algo\\depth-to-rgb-calibration\\19.2.20");
std::string scene_dir( "C:\\work\\autocal" );
scene_dir += "\\F9440687\\LongRange_D_768x1024_RGB_1920x1080\\2\\";
std::ifstream f( bin_dir( scene_dir ) + "camera_params" );
if( f.good() )
compare_scene( scene_dir );
else
std::cout << "-I- skipping scene-2 test for now" << std::endl;
}
<|endoftext|> |
<commit_before>#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iterator>
#include <tuple>
#include <regex>
#include <array>
#include <valarray>
#define all(v)begin(v),end(v)
#define dump(v)copy(all(v),ostream_iterator<decltype(*v.begin())>(cout,"\n"))
#define rg(i,a,b)for(int i=a,i##e=b;i<i##e;++i)
#define fr(i,n)for(int i=0,i##e=n;i<i##e;++i)
#define rf(i,n)for(int i=n-1;i>=0;--i)
#define ei(a,m)for(auto&a:m)if(int a##i=&a-&*begin(m)+1)if(--a##i,1)
#define sz(v)int(v.size())
#define sr(v)sort(all(v))
#define rs(v)sort(all(v),greater<int>())
#define rev(v)reverse(all(v))
#define eb emplace_back
#define stst stringstream
#define big numeric_limits<int>::max()
#define g(t,i)get<i>(t)
#define cb(v,w)copy(all(v),back_inserter(w))
#define uni(v)sort(all(v));v.erase(unique(all(v)),end(v))
#define vt(...)vector<tuple<__VA_ARGS__>>
#define smx(a,b)a=max(a,b)
#define smn(a,b)a=min(a,b)
#define words(w,q)vector<string>w;[&w](string&&s){stringstream u(s);string r;while(u>>r)w.eb(r);}(q);
#define digits(d,n,s)vector<int>d;[&d](int m){while(m)d.eb(m%s),m/=s;}(n);
typedef long long ll;
using namespace std;
struct BreakingTheCode {
string decodingEncoding(string code, string m) {
string r;
if (isdigit(m[0])) {
ei(a, m) if (ai % 2) {
int p = m[ai - 1];
r += code[(p - '0') * 10 + a - '0'];
}
} else {
stst ss;
ei(a, m) {
int x = code.find(a);
ss << char(x / 10 + '0') << char(x % 10 + '0');
}
getline(ss, r);
}
return r;
}
};
// BEGIN KAWIGIEDIT TESTING
// Generated by KawigiEdit-pf 2.3.0
#include <iostream>
#include <string>
#include <vector>
#include <ctime>
#include <cmath>
using namespace std;
bool KawigiEdit_RunTest(int testNum, string p0, string p1, bool hasAnswer, string p2) {
cout << "Test " << testNum << ": [" << "\"" << p0 << "\"" << "," << "\"" << p1 << "\"";
cout << "]" << endl;
BreakingTheCode *obj;
string answer;
obj = new BreakingTheCode();
clock_t startTime = clock();
answer = obj->decodingEncoding(p0, p1);
clock_t endTime = clock();
delete obj;
bool res;
res = true;
cout << "Time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " seconds" << endl;
if (hasAnswer) {
cout << "Desired answer:" << endl;
cout << "\t" << "\"" << p2 << "\"" << endl;
}
cout << "Your answer:" << endl;
cout << "\t" << "\"" << answer << "\"" << endl;
if (hasAnswer) {
res = answer == p2;
}
if (!res) {
cout << "DOESN'T MATCH!!!!" << endl;
} else if (double(endTime - startTime) / CLOCKS_PER_SEC >= 2) {
cout << "FAIL the timeout" << endl;
res = false;
} else if (hasAnswer) {
cout << "Match :-)" << endl;
} else {
cout << "OK, but is it right?" << endl;
}
cout << "" << endl;
return res;
}
int main() {
bool all_right;
bool disabled;
bool tests_disabled;
all_right = true;
tests_disabled = false;
string p0;
string p1;
string p2;
// ----- test 0 -----
disabled = false;
p0 = "abcdefghijklmnopqrstuvwxyz";
p1 = "test";
p2 = "20051920";
all_right = (disabled || KawigiEdit_RunTest(0, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
// ----- test 1 -----
disabled = false;
p0 = "abcdefghijklmnopqrstuvwxyz";
p1 = "20051920";
p2 = "test";
all_right = (disabled || KawigiEdit_RunTest(1, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
// ----- test 2 -----
disabled = false;
p0 = "qesdfvujrockgpthzymbnxawli";
p1 = "mwiizkelza";
p2 = "19242626171202251723";
all_right = (disabled || KawigiEdit_RunTest(2, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
// ----- test 3 -----
disabled = false;
p0 = "faxmswrpnqdbygcthuvkojizle";
p1 = "02170308060416192402";
p2 = "ahxpwmtvza";
all_right = (disabled || KawigiEdit_RunTest(3, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
if (all_right) {
if (tests_disabled) {
cout << "You're a stud (but some test cases were disabled)!" << endl;
} else {
cout << "You're a stud (at least on given cases)!" << endl;
}
} else {
cout << "Some of the test cases had errors." << endl;
}
return 0;
}
// END KAWIGIEDIT TESTING
<commit_msg>BreakingTheCode<commit_after>#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iterator>
#include <tuple>
#include <regex>
#include <array>
#include <valarray>
#define all(v)begin(v),end(v)
#define dump(v)copy(all(v),ostream_iterator<decltype(*v.begin())>(cout,"\n"))
#define rg(i,a,b)for(int i=a,i##e=b;i<i##e;++i)
#define fr(i,n)for(int i=0,i##e=n;i<i##e;++i)
#define rf(i,n)for(int i=n-1;i>=0;--i)
#define ei(a,m)for(auto&a:m)if(int a##i=&a-&*begin(m)+1)if(--a##i,1)
#define sz(v)int(v.size())
#define sr(v)sort(all(v))
#define rs(v)sort(all(v),greater<int>())
#define rev(v)reverse(all(v))
#define eb emplace_back
#define stst stringstream
#define big numeric_limits<int>::max()
#define g(t,i)get<i>(t)
#define cb(v,w)copy(all(v),back_inserter(w))
#define uni(v)sort(all(v));v.erase(unique(all(v)),end(v))
#define vt(...)vector<tuple<__VA_ARGS__>>
#define smx(a,b)a=max(a,b)
#define smn(a,b)a=min(a,b)
#define words(w,q)vector<string>w;[&w](string&&s){stringstream u(s);string r;while(u>>r)w.eb(r);}(q);
#define digits(d,n,s)vector<int>d;[&d](int m){while(m)d.eb(m%s),m/=s;}(n);
typedef long long ll;
using namespace std;
struct BreakingTheCode {
string decodingEncoding(string code, string m) {
string r;
if (isdigit(m[0])) {
ei(a, m) if (ai % 2) {
int p = m[ai - 1];
r += code[(p - '0') * 10 + a - '0' - 1];
}
} else {
stst ss;
ei(a, m) {
int x = code.find(a) + 1;
ss << char(x / 10 + '0') << char(x % 10 + '0');
}
getline(ss, r);
}
return r;
}
};
// BEGIN KAWIGIEDIT TESTING
// Generated by KawigiEdit-pf 2.3.0
#include <iostream>
#include <string>
#include <vector>
#include <ctime>
#include <cmath>
using namespace std;
bool KawigiEdit_RunTest(int testNum, string p0, string p1, bool hasAnswer, string p2) {
cout << "Test " << testNum << ": [" << "\"" << p0 << "\"" << "," << "\"" << p1 << "\"";
cout << "]" << endl;
BreakingTheCode *obj;
string answer;
obj = new BreakingTheCode();
clock_t startTime = clock();
answer = obj->decodingEncoding(p0, p1);
clock_t endTime = clock();
delete obj;
bool res;
res = true;
cout << "Time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " seconds" << endl;
if (hasAnswer) {
cout << "Desired answer:" << endl;
cout << "\t" << "\"" << p2 << "\"" << endl;
}
cout << "Your answer:" << endl;
cout << "\t" << "\"" << answer << "\"" << endl;
if (hasAnswer) {
res = answer == p2;
}
if (!res) {
cout << "DOESN'T MATCH!!!!" << endl;
} else if (double(endTime - startTime) / CLOCKS_PER_SEC >= 2) {
cout << "FAIL the timeout" << endl;
res = false;
} else if (hasAnswer) {
cout << "Match :-)" << endl;
} else {
cout << "OK, but is it right?" << endl;
}
cout << "" << endl;
return res;
}
int main() {
bool all_right;
bool disabled;
bool tests_disabled;
all_right = true;
tests_disabled = false;
string p0;
string p1;
string p2;
// ----- test 0 -----
disabled = false;
p0 = "abcdefghijklmnopqrstuvwxyz";
p1 = "test";
p2 = "20051920";
all_right = (disabled || KawigiEdit_RunTest(0, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
// ----- test 1 -----
disabled = false;
p0 = "abcdefghijklmnopqrstuvwxyz";
p1 = "20051920";
p2 = "test";
all_right = (disabled || KawigiEdit_RunTest(1, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
// ----- test 2 -----
disabled = false;
p0 = "qesdfvujrockgpthzymbnxawli";
p1 = "mwiizkelza";
p2 = "19242626171202251723";
all_right = (disabled || KawigiEdit_RunTest(2, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
// ----- test 3 -----
disabled = false;
p0 = "faxmswrpnqdbygcthuvkojizle";
p1 = "02170308060416192402";
p2 = "ahxpwmtvza";
all_right = (disabled || KawigiEdit_RunTest(3, p0, p1, true, p2) ) && all_right;
tests_disabled = tests_disabled || disabled;
// ------------------
if (all_right) {
if (tests_disabled) {
cout << "You're a stud (but some test cases were disabled)!" << endl;
} else {
cout << "You're a stud (at least on given cases)!" << endl;
}
} else {
cout << "Some of the test cases had errors." << endl;
}
return 0;
}
// END KAWIGIEDIT TESTING
<|endoftext|> |
<commit_before>/*************************************************************************
*
* $RCSfile: ComponentDefinition.cxx,v $
*
* $Revision: 1.2 $
*
* last change: $Author: hr $ $Date: 2004-08-02 15:05:39 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef DBA_COREDATAACESS_COMPONENTDEFINITION_HXX
#include "ComponentDefinition.hxx"
#endif
#ifndef _DBASHARED_APITOOLS_HXX_
#include "apitools.hxx"
#endif
#ifndef DBACCESS_SHARED_DBASTRINGS_HRC
#include "dbastrings.hrc"
#endif
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
#include <com/sun/star/beans/PropertyAttribute.hpp>
#endif
#ifndef _COMPHELPER_PROPERTY_HXX_
#include <comphelper/property.hxx>
#endif
#ifndef _DBACORE_DEFINITIONCOLUMN_HXX_
#include "definitioncolumn.hxx"
#endif
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::osl;
using namespace ::comphelper;
using namespace ::cppu;
extern "C" void SAL_CALL createRegistryInfo_OComponentDefinition()
{
static ::dbaccess::OMultiInstanceAutoRegistration< ::dbaccess::OComponentDefinition > aAutoRegistration;
}
//........................................................................
namespace dbaccess
{
//........................................................................
//==========================================================================
//= OComponentDefinition
//==========================================================================
//--------------------------------------------------------------------------
DBG_NAME(OComponentDefinition)
//--------------------------------------------------------------------------
void OComponentDefinition::registerProperties()
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Illegal impl struct!");
ODataSettings::registerProperties(pItem);
registerProperty(PROPERTY_NAME, PROPERTY_ID_NAME, PropertyAttribute::BOUND | PropertyAttribute::READONLY|PropertyAttribute::CONSTRAINED,
&pItem->m_aProps.aTitle, ::getCppuType(&pItem->m_aProps.aTitle));
if ( m_bTable )
{
registerProperty(PROPERTY_SCHEMANAME, PROPERTY_ID_SCHEMANAME, PropertyAttribute::BOUND,
&pItem->m_sSchemaName, ::getCppuType(&pItem->m_sSchemaName));
registerProperty(PROPERTY_CATALOGNAME, PROPERTY_ID_CATALOGNAME, PropertyAttribute::BOUND,
&pItem->m_sCatalogName, ::getCppuType(&pItem->m_sCatalogName));
}
}
//--------------------------------------------------------------------------
OComponentDefinition::OComponentDefinition(const Reference< XMultiServiceFactory >& _xORB
,const Reference< XInterface >& _xParentContainer
,const TContentPtr& _pImpl
,sal_Bool _bTable)
:ODataSettings(m_aBHelper)
,OContentHelper(_xORB,_xParentContainer,_pImpl)
,m_bTable(_bTable)
{
DBG_CTOR(OComponentDefinition, NULL);
registerProperties();
}
//--------------------------------------------------------------------------
OComponentDefinition::~OComponentDefinition()
{
DBG_DTOR(OComponentDefinition, NULL);
}
//--------------------------------------------------------------------------
OComponentDefinition::OComponentDefinition( const Reference< XInterface >& _rxContainer
,const ::rtl::OUString& _rElementName
,const Reference< XMultiServiceFactory >& _xORB
,const TContentPtr& _pImpl
,sal_Bool _bTable)
:ODataSettings(m_aBHelper)
,OContentHelper(_xORB,_rxContainer,_pImpl)
,m_bTable(_bTable)
{
DBG_CTOR(OComponentDefinition, NULL);
registerProperties();
m_pImpl->m_aProps.aTitle = _rElementName;
DBG_ASSERT(m_pImpl->m_aProps.aTitle.getLength() != 0, "OComponentDefinition::OComponentDefinition : invalid name !");
}
//--------------------------------------------------------------------------
IMPLEMENT_IMPLEMENTATION_ID(OComponentDefinition);
IMPLEMENT_GETTYPES3(OComponentDefinition,ODataSettings,OContentHelper,OComponentDefinition_BASE);
IMPLEMENT_FORWARD_XINTERFACE3( OComponentDefinition,OContentHelper,ODataSettings,OComponentDefinition_BASE)
//--------------------------------------------------------------------------
::rtl::OUString OComponentDefinition::getImplementationName_Static( ) throw(RuntimeException)
{
return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.dba.OComponentDefinition"));
}
//--------------------------------------------------------------------------
::rtl::OUString SAL_CALL OComponentDefinition::getImplementationName( ) throw(RuntimeException)
{
return getImplementationName_Static();
}
//--------------------------------------------------------------------------
Sequence< ::rtl::OUString > OComponentDefinition::getSupportedServiceNames_Static( ) throw(RuntimeException)
{
Sequence< ::rtl::OUString > aServices(2);
aServices.getArray()[0] = SERVICE_SDB_TABLEDEFINITION;
aServices.getArray()[1] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.ucb.Content"));
return aServices;
}
//--------------------------------------------------------------------------
Sequence< ::rtl::OUString > SAL_CALL OComponentDefinition::getSupportedServiceNames( ) throw(RuntimeException)
{
return getSupportedServiceNames_Static();
}
//------------------------------------------------------------------------------
Reference< XInterface > OComponentDefinition::Create(const Reference< XMultiServiceFactory >& _rxFactory)
{
return *(new OComponentDefinition(_rxFactory,NULL,TContentPtr(new OComponentDefinition_Impl)));
}
// -----------------------------------------------------------------------------
void SAL_CALL OComponentDefinition::disposing()
{
OContentHelper::disposing();
if ( m_pColumns.get() )
m_pColumns->disposing();
}
// -----------------------------------------------------------------------------
IPropertyArrayHelper& OComponentDefinition::getInfoHelper()
{
return *getArrayHelper();
}
//--------------------------------------------------------------------------
IPropertyArrayHelper* OComponentDefinition::createArrayHelper( ) const
{
Sequence< Property > aProps;
describeProperties(aProps);
return new OPropertyArrayHelper(aProps);
}
//--------------------------------------------------------------------------
Reference< XPropertySetInfo > SAL_CALL OComponentDefinition::getPropertySetInfo( ) throw(RuntimeException)
{
Reference<XPropertySetInfo> xInfo( createPropertySetInfo( getInfoHelper() ) );
return xInfo;
}
// -----------------------------------------------------------------------------
Reference< XNameAccess> OComponentDefinition::getColumns() throw (RuntimeException)
{
::osl::MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OContentHelper::rBHelper.bDisposed);
if ( !m_pColumns.get() )
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
::std::vector< ::rtl::OUString> aNames;
aNames.reserve(pItem->m_aColumnNames.size());
OComponentDefinition_Impl::TColumnsIndexAccess::iterator aIter = pItem->m_aColumns.begin();
OComponentDefinition_Impl::TColumnsIndexAccess::iterator aEnd = pItem->m_aColumns.end();
for (; aIter != aEnd; ++aIter)
{
aNames.push_back((*aIter)->first);
}
m_pColumns.reset(new OColumns(*this, m_aMutex, sal_True, aNames, this,NULL,sal_True,sal_False,sal_False));
m_pColumns->setParent(*this);
}
return m_pColumns.get();
}
// -----------------------------------------------------------------------------
OColumn* OComponentDefinition::createColumn(const ::rtl::OUString& _rName) const
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
OComponentDefinition_Impl::TColumns::iterator aFind = pItem->m_aColumnNames.find(_rName);
if ( aFind != pItem->m_aColumnNames.end() )
return new OTableColumnWrapper(aFind->second,aFind->second,sal_True);
return new OTableColumn(_rName);
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::beans::XPropertySet > OComponentDefinition::createEmptyObject()
{
return new OTableColumnDescriptor();
}
// -----------------------------------------------------------------------------
void OComponentDefinition::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
{
ODataSettings::setFastPropertyValue_NoBroadcast(nHandle,rValue);
notifyDataSourceModified();
}
// -----------------------------------------------------------------------------
void OComponentDefinition::columnDropped(const ::rtl::OUString& _sName)
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
OComponentDefinition_Impl::TColumns::iterator aFind = pItem->m_aColumnNames.find(_sName);
if ( aFind != pItem->m_aColumnNames.end() )
{
pItem->m_aColumns.erase(::std::find(pItem->m_aColumns.begin(),pItem->m_aColumns.end(),aFind));
pItem->m_aColumnNames.erase(aFind);
}
notifyDataSourceModified();
}
// -----------------------------------------------------------------------------
void OComponentDefinition::columnCloned(const Reference< XPropertySet >& _xClone)
{
OSL_ENSURE(_xClone.is(),"Ivalid column!");
::rtl::OUString sName;
_xClone->getPropertyValue(PROPERTY_NAME) >>= sName;
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
Reference<XPropertySet> xProp = new OTableColumnDescriptor();
::comphelper::copyProperties(_xClone,xProp);
pItem->m_aColumns.push_back(pItem->m_aColumnNames.insert(OComponentDefinition_Impl::TColumns::value_type(sName,xProp)).first);
// helptext etc. may be modified
notifyDataSourceModified();
}
//........................................................................
} // namespace dbaccess
//........................................................................
<commit_msg>INTEGRATION: CWS dba16 (1.2.10); FILE MERGED 2004/10/11 11:38:22 oj 1.2.10.3: #i30220# enable having, group by for queries 2004/10/11 06:55:08 oj 1.2.10.2: #i32931# remove the weak interface, refcount handled by parent 2004/08/27 12:40:30 oj 1.2.10.1: #i33482# setParent and queryInterface corrected<commit_after>/*************************************************************************
*
* $RCSfile: ComponentDefinition.cxx,v $
*
* $Revision: 1.3 $
*
* last change: $Author: rt $ $Date: 2004-10-22 08:58:21 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef DBA_COREDATAACESS_COMPONENTDEFINITION_HXX
#include "ComponentDefinition.hxx"
#endif
#ifndef _DBASHARED_APITOOLS_HXX_
#include "apitools.hxx"
#endif
#ifndef DBACCESS_SHARED_DBASTRINGS_HRC
#include "dbastrings.hrc"
#endif
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
#include <com/sun/star/beans/PropertyAttribute.hpp>
#endif
#ifndef _COMPHELPER_PROPERTY_HXX_
#include <comphelper/property.hxx>
#endif
#ifndef _DBACORE_DEFINITIONCOLUMN_HXX_
#include "definitioncolumn.hxx"
#endif
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::osl;
using namespace ::comphelper;
using namespace ::cppu;
extern "C" void SAL_CALL createRegistryInfo_OComponentDefinition()
{
static ::dbaccess::OMultiInstanceAutoRegistration< ::dbaccess::OComponentDefinition > aAutoRegistration;
}
//........................................................................
namespace dbaccess
{
//........................................................................
//==========================================================================
//= OComponentDefinition
//==========================================================================
//--------------------------------------------------------------------------
DBG_NAME(OComponentDefinition)
//--------------------------------------------------------------------------
void OComponentDefinition::registerProperties()
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Illegal impl struct!");
ODataSettings::registerProperties(pItem);
registerProperty(PROPERTY_NAME, PROPERTY_ID_NAME, PropertyAttribute::BOUND | PropertyAttribute::READONLY|PropertyAttribute::CONSTRAINED,
&pItem->m_aProps.aTitle, ::getCppuType(&pItem->m_aProps.aTitle));
if ( m_bTable )
{
registerProperty(PROPERTY_SCHEMANAME, PROPERTY_ID_SCHEMANAME, PropertyAttribute::BOUND,
&pItem->m_sSchemaName, ::getCppuType(&pItem->m_sSchemaName));
registerProperty(PROPERTY_CATALOGNAME, PROPERTY_ID_CATALOGNAME, PropertyAttribute::BOUND,
&pItem->m_sCatalogName, ::getCppuType(&pItem->m_sCatalogName));
}
}
//--------------------------------------------------------------------------
OComponentDefinition::OComponentDefinition(const Reference< XMultiServiceFactory >& _xORB
,const Reference< XInterface >& _xParentContainer
,const TContentPtr& _pImpl
,sal_Bool _bTable)
:ODataSettings(m_aBHelper,!_bTable)
,OContentHelper(_xORB,_xParentContainer,_pImpl)
,m_bTable(_bTable)
{
DBG_CTOR(OComponentDefinition, NULL);
registerProperties();
}
//--------------------------------------------------------------------------
OComponentDefinition::~OComponentDefinition()
{
DBG_DTOR(OComponentDefinition, NULL);
}
//--------------------------------------------------------------------------
OComponentDefinition::OComponentDefinition( const Reference< XInterface >& _rxContainer
,const ::rtl::OUString& _rElementName
,const Reference< XMultiServiceFactory >& _xORB
,const TContentPtr& _pImpl
,sal_Bool _bTable)
:ODataSettings(m_aBHelper)
,OContentHelper(_xORB,_rxContainer,_pImpl)
,m_bTable(_bTable)
{
DBG_CTOR(OComponentDefinition, NULL);
registerProperties();
m_pImpl->m_aProps.aTitle = _rElementName;
DBG_ASSERT(m_pImpl->m_aProps.aTitle.getLength() != 0, "OComponentDefinition::OComponentDefinition : invalid name !");
}
//--------------------------------------------------------------------------
IMPLEMENT_IMPLEMENTATION_ID(OComponentDefinition);
IMPLEMENT_GETTYPES3(OComponentDefinition,ODataSettings,OContentHelper,OComponentDefinition_BASE);
IMPLEMENT_FORWARD_XINTERFACE3( OComponentDefinition,OContentHelper,ODataSettings,OComponentDefinition_BASE)
//--------------------------------------------------------------------------
::rtl::OUString OComponentDefinition::getImplementationName_Static( ) throw(RuntimeException)
{
return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.dba.OComponentDefinition"));
}
//--------------------------------------------------------------------------
::rtl::OUString SAL_CALL OComponentDefinition::getImplementationName( ) throw(RuntimeException)
{
return getImplementationName_Static();
}
//--------------------------------------------------------------------------
Sequence< ::rtl::OUString > OComponentDefinition::getSupportedServiceNames_Static( ) throw(RuntimeException)
{
Sequence< ::rtl::OUString > aServices(2);
aServices.getArray()[0] = SERVICE_SDB_TABLEDEFINITION;
aServices.getArray()[1] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.ucb.Content"));
return aServices;
}
//--------------------------------------------------------------------------
Sequence< ::rtl::OUString > SAL_CALL OComponentDefinition::getSupportedServiceNames( ) throw(RuntimeException)
{
return getSupportedServiceNames_Static();
}
//------------------------------------------------------------------------------
Reference< XInterface > OComponentDefinition::Create(const Reference< XMultiServiceFactory >& _rxFactory)
{
return *(new OComponentDefinition(_rxFactory,NULL,TContentPtr(new OComponentDefinition_Impl)));
}
// -----------------------------------------------------------------------------
void SAL_CALL OComponentDefinition::disposing()
{
OContentHelper::disposing();
if ( m_pColumns.get() )
m_pColumns->disposing();
}
// -----------------------------------------------------------------------------
IPropertyArrayHelper& OComponentDefinition::getInfoHelper()
{
return *getArrayHelper();
}
//--------------------------------------------------------------------------
IPropertyArrayHelper* OComponentDefinition::createArrayHelper( ) const
{
Sequence< Property > aProps;
describeProperties(aProps);
return new OPropertyArrayHelper(aProps);
}
//--------------------------------------------------------------------------
Reference< XPropertySetInfo > SAL_CALL OComponentDefinition::getPropertySetInfo( ) throw(RuntimeException)
{
Reference<XPropertySetInfo> xInfo( createPropertySetInfo( getInfoHelper() ) );
return xInfo;
}
// -----------------------------------------------------------------------------
Reference< XNameAccess> OComponentDefinition::getColumns() throw (RuntimeException)
{
::osl::MutexGuard aGuard(m_aMutex);
::connectivity::checkDisposed(OContentHelper::rBHelper.bDisposed);
if ( !m_pColumns.get() )
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
::std::vector< ::rtl::OUString> aNames;
aNames.reserve(pItem->m_aColumnNames.size());
OComponentDefinition_Impl::TColumnsIndexAccess::iterator aIter = pItem->m_aColumns.begin();
OComponentDefinition_Impl::TColumnsIndexAccess::iterator aEnd = pItem->m_aColumns.end();
for (; aIter != aEnd; ++aIter)
{
aNames.push_back((*aIter)->first);
}
m_pColumns.reset(new OColumns(*this, m_aMutex, sal_True, aNames, this,NULL,sal_True,sal_False,sal_False));
m_pColumns->setParent(*this);
}
return m_pColumns.get();
}
// -----------------------------------------------------------------------------
OColumn* OComponentDefinition::createColumn(const ::rtl::OUString& _rName) const
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
OComponentDefinition_Impl::TColumns::iterator aFind = pItem->m_aColumnNames.find(_rName);
if ( aFind != pItem->m_aColumnNames.end() )
return new OTableColumnWrapper(aFind->second,aFind->second,sal_True);
return new OTableColumn(_rName);
}
// -----------------------------------------------------------------------------
Reference< ::com::sun::star::beans::XPropertySet > OComponentDefinition::createEmptyObject()
{
return new OTableColumnDescriptor();
}
// -----------------------------------------------------------------------------
void OComponentDefinition::setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,const Any& rValue) throw (Exception)
{
ODataSettings::setFastPropertyValue_NoBroadcast(nHandle,rValue);
notifyDataSourceModified();
}
// -----------------------------------------------------------------------------
void OComponentDefinition::columnDropped(const ::rtl::OUString& _sName)
{
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
OComponentDefinition_Impl::TColumns::iterator aFind = pItem->m_aColumnNames.find(_sName);
if ( aFind != pItem->m_aColumnNames.end() )
{
pItem->m_aColumns.erase(::std::find(pItem->m_aColumns.begin(),pItem->m_aColumns.end(),aFind));
pItem->m_aColumnNames.erase(aFind);
}
notifyDataSourceModified();
}
// -----------------------------------------------------------------------------
void OComponentDefinition::columnCloned(const Reference< XPropertySet >& _xClone)
{
OSL_ENSURE(_xClone.is(),"Ivalid column!");
::rtl::OUString sName;
_xClone->getPropertyValue(PROPERTY_NAME) >>= sName;
OComponentDefinition_Impl* pItem = static_cast<OComponentDefinition_Impl*>(m_pImpl.get());
OSL_ENSURE(pItem,"Invalid impl data!");
Reference<XPropertySet> xProp = new OTableColumnDescriptor();
::comphelper::copyProperties(_xClone,xProp);
pItem->m_aColumns.push_back(pItem->m_aColumnNames.insert(OComponentDefinition_Impl::TColumns::value_type(sName,xProp)).first);
Reference<XChild> xChild(xProp,UNO_QUERY);
if ( xChild.is() )
xChild->setParent(static_cast<XChild*>(static_cast<TXChild*>((m_pColumns.get()))));
// helptext etc. may be modified
notifyDataSourceModified();
}
//........................................................................
} // namespace dbaccess
//........................................................................
<|endoftext|> |
<commit_before>/*
* Copyright (C) 2014 Cloudius Systems, Ltd.
*/
#ifndef BITOPS_HH_
#define BITOPS_HH_
inline
unsigned count_leading_zeros(unsigned x) {
return __builtin_clz(x);
}
inline
unsigned count_leading_zeros(unsigned long x) {
return __builtin_clzl(x);
}
inline
unsigned count_leading_zeros(unsigned long long x) {
return __builtin_clzll(x);
}
inline
unsigned count_trailing_zeros(unsigned x) {
return __builtin_ctz(x);
}
inline
unsigned count_trailing_zeros(unsigned long x) {
return __builtin_ctzl(x);
}
inline
unsigned count_trailing_zeros(unsigned long long x) {
return __builtin_ctzll(x);
}
#endif /* BITOPS_HH_ */
<commit_msg>bitops: mark functions as constexpr<commit_after>/*
* Copyright (C) 2014 Cloudius Systems, Ltd.
*/
#ifndef BITOPS_HH_
#define BITOPS_HH_
inline
constexpr unsigned count_leading_zeros(unsigned x) {
return __builtin_clz(x);
}
inline
constexpr unsigned count_leading_zeros(unsigned long x) {
return __builtin_clzl(x);
}
inline
constexpr unsigned count_leading_zeros(unsigned long long x) {
return __builtin_clzll(x);
}
inline
constexpr unsigned count_trailing_zeros(unsigned x) {
return __builtin_ctz(x);
}
inline
constexpr unsigned count_trailing_zeros(unsigned long x) {
return __builtin_ctzl(x);
}
inline
constexpr unsigned count_trailing_zeros(unsigned long long x) {
return __builtin_ctzll(x);
}
#endif /* BITOPS_HH_ */
<|endoftext|> |
<commit_before>/* <src/capi.cpp>
*
* This file is part of the x0 web server project and is released under GPL-3.
* http://www.xzero.io/
*
* (c) 2009-2013 Christian Parpart <[email protected]>
*/
#include <x0/capi.h>
#include <x0/http/HttpServer.h>
#include <x0/http/HttpWorker.h>
#include <x0/http/HttpRequest.h>
#include <x0/io/BufferSource.h>
#include <cstdarg>
using namespace x0;
struct x0_server_s
{
HttpServer server;
x0_server_s(struct ev_loop* loop) :
server(loop)
{}
};
struct x0_request_s
{
x0_server_t* server;
HttpRequest* request;
x0_request_body_fn body_cb;
void* body_userdata;
void bodyCallback(const BufferRef& ref) {
if (body_cb) {
body_cb(this, ref.data(), ref.size(), body_userdata);
}
}
};
x0_server_t* x0_server_create(struct ev_loop* loop)
{
auto s = new x0_server_t(loop);
s->server.requestHandler = [](HttpRequest* r) -> bool {
BufferSource body("Hello, I am lazy to serve anything; I wasn't configured properly\n");
r->status = HttpStatus::InternalServerError;
char buf[40];
snprintf(buf, sizeof(buf), "%zu", body.size());
r->responseHeaders.push_back("Content-Length", buf);
r->responseHeaders.push_back("Content-Type", "plain/text");
r->write<BufferSource>(body);
r->finish();
return true;
};
return s;
}
int x0_listener_add(x0_server_t* server, const char* bind, int port, int backlog)
{
auto listener = server->server.setupListener(bind, port, 128);
if (listener == nullptr)
return -1;
return 0;
}
void x0_server_destroy(x0_server_t* server, int kill)
{
if (!kill) {
// TODO wait until all current connections have been finished, if more than one worker has been set up
}
delete server;
}
void x0_server_stop(x0_server_t* server)
{
server->server.stop();
}
void x0_setup_handler(x0_server_t* server, x0_request_handler_fn handler, void* userdata)
{
server->server.requestHandler = [=](HttpRequest* r) -> bool {
auto rr = new x0_request_t;
rr->request = r;
rr->server = server;
handler(rr, userdata);
return true;
};
}
void x0_request_body_callback(x0_request_t* r, x0_request_body_fn handler, void* userdata)
{
r->request->setBodyCallback<x0_request_t, &x0_request_t::bodyCallback>(r);
}
void x0_setup_connection_limit(x0_server_t* li, size_t limit)
{
li->server.maxConnections = limit;
}
void x0_setup_timeouts(x0_server_t* server, int read, int write)
{
server->server.maxReadIdle = TimeSpan::fromSeconds(read);
server->server.maxWriteIdle = TimeSpan::fromSeconds(write);
}
void x0_setup_keepalive(x0_server_t* server, int count, int timeout)
{
server->server.maxKeepAliveRequests = count;
server->server.maxKeepAlive = TimeSpan::fromSeconds(timeout);
}
// --------------------------------------------------------------------------
// REQUEST
int x0_request_method(x0_request_t* r)
{
if (r->request->method == "GET")
return X0_REQUEST_METHOD_GET;
if (r->request->method == "POST")
return X0_REQUEST_METHOD_POST;
if (r->request->method == "PUT")
return X0_REQUEST_METHOD_PUT;
if (r->request->method == "DELETE")
return X0_REQUEST_METHOD_DELETE;
return X0_REQUEST_METHOD_UNKNOWN;
}
size_t x0_request_method_str(x0_request_t* r, char* buf, size_t size)
{
if (!size)
return 0;
size_t n = std::min(r->request->method.size(), size - 1);
memcpy(buf, r->request->method.data(), n);
buf[n] = '\0';
return n;
}
size_t x0_request_path(x0_request_t* r, char* buf, size_t size)
{
size_t rsize = std::min(size - 1, r->request->path.size());
memcpy(buf, r->request->path.data(), rsize);
buf[rsize] = '\0';
return rsize + 1;
}
int x0_request_version(x0_request_t* r)
{
static const struct {
int major;
int minor;
int code;
} versions[] = {
{ 0, 9, X0_HTTP_VERSION_0_9 },
{ 1, 0, X0_HTTP_VERSION_1_0 },
{ 1, 1, X0_HTTP_VERSION_1_1 },
{ 2, 0, X0_HTTP_VERSION_2_0 },
};
int major = r->request->httpVersionMajor;
int minor = r->request->httpVersionMinor;
for (const auto& version: versions)
if (version.major == major && version.minor == minor)
return version.code;
return X0_HTTP_VERSION_UNKNOWN;
}
int x0_request_header_exists(x0_request_t* r, const char* name)
{
for (const auto& header: r->request->requestHeaders)
if (header.name == name)
return 1;
return 0;
}
int x0_request_header_get(x0_request_t* r, const char* name, char* buf, size_t size)
{
if (size) {
for (const auto& header: r->request->requestHeaders) {
if (header.name == name) {
size_t len = std::min(header.value.size(), size - 1);
memcpy(buf, header.value.data(), len);
buf[len] = '\0';
return len;
}
}
}
return 0;
}
int x0_request_cookie_get(x0_request_t* r, const char* cookie, char* buf, size_t size)
{
return 0; // TODO cookie retrieval
}
int x0_request_header_count(x0_request_t* r)
{
return r->request->requestHeaders.size();
}
int x0_request_header_geti(x0_request_t* r, off_t index, char* buf, size_t size)
{
if (size && index < r->request->requestHeaders.size()) {
const auto& header = r->request->requestHeaders[index];
size_t len = std::min(header.value.size(), size - 1);
memcpy(buf, header.value.data(), len);
buf[len] = '\0';
return len;
}
return 0;
}
// --------------------------------------------------------------------------
// RESPONSE
void x0_response_status_set(x0_request_t* r, int code)
{
r->request->status = static_cast<HttpStatus>(code);
}
void x0_response_header_set(x0_request_t* r, const char* name, const char* value)
{
r->request->responseHeaders.overwrite(name, value);
}
void x0_response_write(x0_request_t* r, const char* buf, size_t size)
{
Buffer b;
b.push_back(buf, size);
r->request->write<BufferSource>(b);
}
void x0_response_printf(x0_request_t* r, const char* fmt, ...)
{
Buffer b;
va_list ap;
va_start(ap, fmt);
b.vprintf(fmt, ap);
va_end(ap);
r->request->write<BufferSource>(b);
}
void x0_response_vprintf(x0_request_t* r, const char* fmt, va_list args)
{
Buffer b;
va_list va;
va_copy(va, args);
b.vprintf(fmt, va);
va_end(va);
r->request->write<BufferSource>(b);
}
void x0_response_finish(x0_request_t* r)
{
r->request->finish();
delete r;
}
void x0_response_sendfile(x0_request_t* r, const char* path)
{
r->request->sendfile(path);
}
<commit_msg>capi: fixes<commit_after>/* <src/capi.cpp>
*
* This file is part of the x0 web server project and is released under GPL-3.
* http://www.xzero.io/
*
* (c) 2009-2013 Christian Parpart <[email protected]>
*/
#include <x0/capi.h>
#include <x0/http/HttpServer.h>
#include <x0/http/HttpWorker.h>
#include <x0/http/HttpRequest.h>
#include <x0/io/BufferSource.h>
#include <cstdarg>
using namespace x0;
struct x0_server_s
{
HttpServer server;
x0_server_s(struct ev_loop* loop) :
server(loop)
{}
};
struct x0_request_s
{
x0_server_t* server;
HttpRequest* request;
x0_request_body_fn body_cb;
void* body_userdata;
x0_request_s(HttpRequest* r, x0_server_t* s) :
server(s),
request(r),
body_cb(nullptr),
body_userdata(nullptr)
{
}
void bodyCallback(const BufferRef& ref) {
if (body_cb) {
body_cb(this, ref.data(), ref.size(), body_userdata);
}
}
};
x0_server_t* x0_server_create(struct ev_loop* loop)
{
auto s = new x0_server_t(loop);
s->server.requestHandler = [](HttpRequest* r) -> bool {
BufferSource body("Hello, I am lazy to serve anything; I wasn't configured properly\n");
r->status = HttpStatus::InternalServerError;
char buf[40];
snprintf(buf, sizeof(buf), "%zu", body.size());
r->responseHeaders.push_back("Content-Length", buf);
r->responseHeaders.push_back("Content-Type", "plain/text");
r->write<BufferSource>(body);
r->finish();
return true;
};
return s;
}
int x0_listener_add(x0_server_t* server, const char* bind, int port, int backlog)
{
auto listener = server->server.setupListener(bind, port, 128);
if (listener == nullptr)
return -1;
return 0;
}
void x0_server_destroy(x0_server_t* server, int kill)
{
if (!kill) {
// TODO wait until all current connections have been finished, if more than one worker has been set up
}
delete server;
}
void x0_server_stop(x0_server_t* server)
{
server->server.stop();
}
void x0_setup_handler(x0_server_t* server, x0_request_handler_fn handler, void* userdata)
{
server->server.requestHandler = [=](HttpRequest* r) -> bool {
auto rr = new x0_request_t(r, server);
handler(rr, userdata);
return true;
};
}
void x0_request_body_callback(x0_request_t* r, x0_request_body_fn handler, void* userdata)
{
r->request->setBodyCallback<x0_request_t, &x0_request_t::bodyCallback>(r);
}
void x0_setup_connection_limit(x0_server_t* li, size_t limit)
{
li->server.maxConnections = limit;
}
void x0_setup_timeouts(x0_server_t* server, int read, int write)
{
server->server.maxReadIdle = TimeSpan::fromSeconds(read);
server->server.maxWriteIdle = TimeSpan::fromSeconds(write);
}
void x0_setup_keepalive(x0_server_t* server, int count, int timeout)
{
server->server.maxKeepAliveRequests = count;
server->server.maxKeepAlive = TimeSpan::fromSeconds(timeout);
}
// --------------------------------------------------------------------------
// REQUEST
int x0_request_method(x0_request_t* r)
{
if (r->request->method == "GET")
return X0_REQUEST_METHOD_GET;
if (r->request->method == "POST")
return X0_REQUEST_METHOD_POST;
if (r->request->method == "PUT")
return X0_REQUEST_METHOD_PUT;
if (r->request->method == "DELETE")
return X0_REQUEST_METHOD_DELETE;
return X0_REQUEST_METHOD_UNKNOWN;
}
size_t x0_request_method_str(x0_request_t* r, char* buf, size_t size)
{
if (!size)
return 0;
size_t n = std::min(r->request->method.size(), size - 1);
memcpy(buf, r->request->method.data(), n);
buf[n] = '\0';
return n;
}
size_t x0_request_path(x0_request_t* r, char* buf, size_t size)
{
size_t rsize = std::min(size - 1, r->request->path.size());
memcpy(buf, r->request->path.data(), rsize);
buf[rsize] = '\0';
return rsize + 1;
}
int x0_request_version(x0_request_t* r)
{
static const struct {
int major;
int minor;
int code;
} versions[] = {
{ 0, 9, X0_HTTP_VERSION_0_9 },
{ 1, 0, X0_HTTP_VERSION_1_0 },
{ 1, 1, X0_HTTP_VERSION_1_1 },
{ 2, 0, X0_HTTP_VERSION_2_0 },
};
int major = r->request->httpVersionMajor;
int minor = r->request->httpVersionMinor;
for (const auto& version: versions)
if (version.major == major && version.minor == minor)
return version.code;
return X0_HTTP_VERSION_UNKNOWN;
}
int x0_request_header_exists(x0_request_t* r, const char* name)
{
for (const auto& header: r->request->requestHeaders)
if (header.name == name)
return 1;
return 0;
}
int x0_request_header_get(x0_request_t* r, const char* name, char* buf, size_t size)
{
if (size) {
for (const auto& header: r->request->requestHeaders) {
if (header.name == name) {
size_t len = std::min(header.value.size(), size - 1);
memcpy(buf, header.value.data(), len);
buf[len] = '\0';
return len;
}
}
}
return 0;
}
int x0_request_cookie_get(x0_request_t* r, const char* cookie, char* buf, size_t size)
{
return 0; // TODO cookie retrieval
}
int x0_request_header_count(x0_request_t* r)
{
return r->request->requestHeaders.size();
}
int x0_request_header_geti(x0_request_t* r, off_t index, char* buf, size_t size)
{
if (size && index < r->request->requestHeaders.size()) {
const auto& header = r->request->requestHeaders[index];
size_t len = std::min(header.value.size(), size - 1);
memcpy(buf, header.value.data(), len);
buf[len] = '\0';
return len;
}
return 0;
}
// --------------------------------------------------------------------------
// RESPONSE
void x0_response_status_set(x0_request_t* r, int code)
{
r->request->status = static_cast<HttpStatus>(code);
}
void x0_response_header_set(x0_request_t* r, const char* name, const char* value)
{
r->request->responseHeaders.overwrite(name, value);
}
void x0_response_write(x0_request_t* r, const char* buf, size_t size)
{
Buffer b;
b.push_back(buf, size);
r->request->write<BufferSource>(b);
}
void x0_response_printf(x0_request_t* r, const char* fmt, ...)
{
Buffer b;
va_list ap;
va_start(ap, fmt);
b.vprintf(fmt, ap);
va_end(ap);
r->request->write<BufferSource>(b);
}
void x0_response_vprintf(x0_request_t* r, const char* fmt, va_list args)
{
Buffer b;
va_list va;
va_copy(va, args);
b.vprintf(fmt, va);
va_end(va);
r->request->write<BufferSource>(b);
}
void x0_response_finish(x0_request_t* r)
{
r->request->finish();
delete r;
}
void x0_response_sendfile(x0_request_t* r, const char* path)
{
r->request->sendfile(path);
}
<|endoftext|> |
<commit_before>/*
* Copyright 2016 Christian Lockley
*
* 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.
*/
#include "watchdogd.hpp"
#include "sub.hpp"
#include "main.hpp"
#include "init.hpp"
#include "configfile.hpp"
#include "threads.hpp"
#include "identify.hpp"
#include "bootstatus.hpp"
#include "multicall.hpp"
extern "C" {
#include "dbusapi.h"
}
#include <systemd/sd-event.h>
const bool DISARM_WATCHDOG_BEFORE_REBOOT = true;
static volatile sig_atomic_t quit = 0;
volatile sig_atomic_t stop = 0;
volatile sig_atomic_t stopPing = 0;
ProcessList processes;
static void PrintConfiguration(struct cfgoptions *const cfg)
{
Logmsg(LOG_INFO,
"int=%is realtime=%s sync=%s softboot=%s force=%s mla=%.2f mem=%li pid=%li",
cfg->sleeptime, cfg->options & REALTIME ? "yes" : "no",
cfg->options & SYNC ? "yes" : "no",
cfg->options & SOFTBOOT ? "yes" : "no",
cfg->options & FORCE ? "yes" : "no", cfg->maxLoadOne, cfg->minfreepages, getppid());
if (cfg->options & ENABLEPING) {
for (int cnt = 0; cnt < config_setting_length(cfg->ipAddresses); cnt++) {
const char *ipAddress = config_setting_get_string_elem(cfg->ipAddresses,
cnt);
assert(ipAddress != NULL);
Logmsg(LOG_INFO, "ping: %s", ipAddress);
}
} else {
Logmsg(LOG_INFO, "ping: no ip adresses to ping");
}
if (cfg->options & ENABLEPIDCHECKER) {
for (int cnt = 0; cnt < config_setting_length(cfg->pidFiles); cnt++) {
const char *pidFilePathName = config_setting_get_string_elem(cfg->pidFiles, cnt);
assert(pidFilePathName != NULL);
Logmsg(LOG_DEBUG, "pidfile: %s", pidFilePathName);
}
} else {
Logmsg(LOG_INFO, "pidfile: no server process to check");
}
Logmsg(LOG_INFO, "test=%s(%i) repair=%s(%i) no_act=%s",
cfg->testexepathname == NULL ? "no" : cfg->testexepathname,
cfg->testBinTimeout,
cfg->exepathname == NULL ? "no" : cfg->exepathname,
cfg->repairBinTimeout, cfg->options & NOACTION ? "yes" : "no");
}
static void BlockSignals()
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGUSR2);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGHUP);
pthread_sigmask(SIG_BLOCK, &set, NULL);
}
static int SignalHandler(sd_event_source * s, const signalfd_siginfo * si, void *cxt)
{
switch (sd_event_source_get_signal(s)) {
case SIGTERM:
case SIGINT:
quit = 1;
sd_event_exit((sd_event *) cxt, 0);
break;
case SIGHUP:
//reload;
break;
}
return 1;
}
static void InstallSignalHandlers(sd_event * event)
{
int r1 = sd_event_add_signal(event, NULL, SIGTERM, SignalHandler, event);
int r2 = sd_event_add_signal(event, NULL, SIGHUP, SignalHandler, event);
int r3 = sd_event_add_signal(event, NULL, SIGUSR2, SignalHandler, event);
int r4 = sd_event_add_signal(event, NULL, SIGINT, SignalHandler, event);
if (r1 < 0 || r2 < 0 || r3 < 0 || r4 < 0) {
abort();
}
}
static int Pinger(sd_event_source * s, uint64_t usec, void *cxt)
{
Watchdog *watchdog = (Watchdog *) cxt;
watchdog->Ping();
sd_event_now(sd_event_source_get_event(s), CLOCK_REALTIME, &usec);
usec += watchdog->GetPingInterval() * 1000000;
sd_event_add_time(sd_event_source_get_event(s), &s, CLOCK_REALTIME, usec, 1, Pinger, (void *)cxt);
return 0;
}
static bool InstallPinger(sd_event * e, int time, Watchdog * w)
{
sd_event_source *s = NULL;
uint64_t usec = 0;
w->SetPingInterval(time);
sd_event_now(e, CLOCK_REALTIME, &usec);
sd_event_add_time(e, &s, CLOCK_REALTIME, usec, 1, Pinger, (void *)w);
return true;
}
int ServiceMain(int argc, char **argv, int fd, bool restarted)
{
cfgoptions options;
Watchdog watchdog;
cfgoptions *tmp = &options;
Watchdog *tmp2 = &watchdog;
struct dbusinfo temp = {.config = &tmp,.wdt = &tmp2 };;
temp.fd = fd;
if (MyStrerrorInit() == false) {
std::perror("Unable to create a new locale object");
return EXIT_FAILURE;
}
int ret = ParseCommandLine(&argc, argv, &options);
if (ret < 0) {
return EXIT_FAILURE;
} else if (ret != 0) {
return EXIT_SUCCESS;
}
if (strcasecmp(GetExeName(), "wd_identify") == 0 || strcasecmp(GetExeName(), "wd_identify.sh") == 0) {
options.options |= IDENTIFY;
}
if (ReadConfigurationFile(&options) < 0) {
return EXIT_FAILURE;
}
if (options.options & IDENTIFY) {
watchdog.Open(options.devicepath);
ret = Identify(watchdog.GetRawTimeout(), (const char *)watchdog.GetIdentity(),
options.devicepath, options.options & VERBOSE);
watchdog.Close();
return ret;
}
if (PingInit(&options) < 0) {
return EXIT_FAILURE;
}
if (restarted) {
Logmsg(LOG_INFO,"restarting service (%s)", PACKAGE_VERSION);
} else {
Logmsg(LOG_INFO, "starting service (%s)", PACKAGE_VERSION);
}
PrintConfiguration(&options);
if (ExecuteRepairScriptsPreFork(&processes, &options) == false) {
Logmsg(LOG_ERR, "ExecuteRepairScriptsPreFork failed");
FatalError(&options);
}
sd_event *event = NULL;
sd_event_default(&event);
BlockSignals();
InstallSignalHandlers(event);
if (StartHelperThreads(&options) != 0) {
FatalError(&options);
}
pthread_t dbusThread;
if (!(options.options & NOACTION)) {
errno = 0;
ret = watchdog.Open(options.devicepath);
if (errno == EBUSY && ret < 0) {
Logmsg(LOG_ERR, "Unable to open watchdog device");
return EXIT_FAILURE;
} else if (ret <= -1) {
LoadKernelModule();
ret = watchdog.Open(options.devicepath);
}
if (ret <= -1) {
FatalError(&options);
}
if (watchdog.ConfigureWatchdogTimeout(options.watchdogTimeout)
< 0 && options.watchdogTimeout != -1) {
Logmsg(LOG_ERR, "unable to set watchdog device timeout\n");
Logmsg(LOG_ERR, "program exiting\n");
EndDaemon(&options, false);
watchdog.Close();
return EXIT_FAILURE;
}
if (options.sleeptime == -1) {
options.sleeptime = watchdog.GetOptimalPingInterval();
Logmsg(LOG_INFO, "ping interval autodetect: %i", options.sleeptime);
}
if (options.watchdogTimeout != -1 && watchdog.CheckWatchdogTimeout(options.sleeptime) == true) {
Logmsg(LOG_ERR, "WDT timeout is less than or equal watchdog daemon ping interval");
Logmsg(LOG_ERR, "Using this interval may result in spurious reboots");
if (!(options.options & FORCE)) {
watchdog.Close();
Logmsg(LOG_WARNING, "use the -f option to force this configuration");
return EXIT_FAILURE;
}
}
WriteBootStatus(watchdog.GetStatus(), "/run/watchdogd.status", options.sleeptime,
watchdog.GetRawTimeout());
static struct identinfo i;
strncpy(i.name, (char *)watchdog.GetIdentity(), sizeof(i.name) - 1);
i.timeout = watchdog.GetRawTimeout();
strncpy(i.daemonVersion, PACKAGE_VERSION, sizeof(i.daemonVersion) - 1);
strncpy(i.deviceName, options.devicepath, sizeof(i.deviceName) - 1);
i.flags = watchdog.GetStatus();
i.firmwareVersion = watchdog.GetFirmwareVersion();
CreateDetachedThread(IdentityThread, &i);
pthread_create(&dbusThread, NULL, DbusHelper, &temp);
InstallPinger(event, options.sleeptime, &watchdog);
write(fd, "", sizeof(char));
}
if (SetupAuxManagerThread(&options) < 0) {
FatalError(&options);
}
if (PlatformInit() != true) {
FatalError(&options);
}
sd_event_loop(event);
if (stop == 1) {
while (true) {
if (stopPing == 1) {
if (DISARM_WATCHDOG_BEFORE_REBOOT) {
watchdog.Close();
}
} else {
watchdog.Ping();
}
sleep(1);
}
}
if (!(options.options & NOACTION)) {
pthread_cancel(dbusThread);
pthread_join(dbusThread, NULL);
}
watchdog.Close();
unlink("/run/watchdogd.status");
if (EndDaemon(&options, false) < 0) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int sock[2] = { 0 };
socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sock);
pid_t pid = fork();
if (pid == 0) {
OnParentDeathSend(SIGKILL);
close(sock[1]);
DbusApiInit(sock[0]);
_Exit(0);
}
close(sock[0]);
sigset_t mask;
bool restarted = false;
char name[64] = {0};
sd_bus *bus = NULL;
sd_bus_message *m = NULL;
sd_bus_error error = {0};
int fildes[2] = {0};
sigemptyset(&mask);
sigaddset(&mask, SIGTERM);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGHUP);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
int sfd = signalfd (-1, &mask, 0);
init:
pipe(fildes);
pid = fork();
if (pid == 0) {
close(sfd);
ResetSignalHandlers(64);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
close(fildes[1]);
read(fildes[0], fildes+1, sizeof(int));
close(fildes[0]);
_Exit(ServiceMain(argc, argv, sock[1], restarted));
} else {
sd_bus_open_system(&bus);
sprintf(name, "watchdogd.%li.scope", pid);
sd_bus_message_new_method_call(bus, &m, "org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartTransientUnit");
sd_bus_message_append(m, "ss", name, "fail");
sd_bus_message_open_container(m, 'a', "(sv)");
sd_bus_message_append(m, "(sv)", "Description", "s", " ");
sd_bus_message_append(m, "(sv)", "KillSignal", "i", SIGKILL);
sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, (uint32_t) pid);
sd_bus_message_close_container(m);
sd_bus_message_append(m, "a(sa(sv))", 0);
sd_bus_message * reply;
sd_bus_call(bus, m, 0, &error, &reply);
close(fildes[0]);
close(fildes[1]);
sd_bus_flush_close_unref(bus);
}
sd_notifyf(0, "READY=1\n" "MAINPID=%lu", (unsigned long)getpid());
while (true) {
struct signalfd_siginfo si = {0};
ssize_t ret = read (sfd, &si, sizeof(si));
switch (si.ssi_signo) {
case SIGHUP:
sd_bus_open_system(&bus);
sd_bus_call_method(bus, "org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager", "StopUnit", &error,
NULL, "ss", name, "ignore-dependencies");
sd_bus_flush_close_unref(bus);
restarted = true;
si.ssi_signo = 0;
goto init;
break;
case SIGINT:
case SIGTERM:
case SIGCHLD:
sd_bus_open_system(&bus);
sd_bus_call_method(bus, "org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager", "StopUnit", &error,
NULL, "ss", name, "ignore-dependencies");
sd_bus_flush_close_unref(bus);
_Exit(si.ssi_status);
break;
}
}
}
<commit_msg>cleanup<commit_after>/*
* Copyright 2016 Christian Lockley
*
* 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.
*/
#include "watchdogd.hpp"
#include "sub.hpp"
#include "main.hpp"
#include "init.hpp"
#include "configfile.hpp"
#include "threads.hpp"
#include "identify.hpp"
#include "bootstatus.hpp"
#include "multicall.hpp"
extern "C" {
#include "dbusapi.h"
}
#include <systemd/sd-event.h>
const bool DISARM_WATCHDOG_BEFORE_REBOOT = true;
static volatile sig_atomic_t quit = 0;
volatile sig_atomic_t stop = 0;
volatile sig_atomic_t stopPing = 0;
ProcessList processes;
static void PrintConfiguration(struct cfgoptions *const cfg)
{
Logmsg(LOG_INFO,
"int=%is realtime=%s sync=%s softboot=%s force=%s mla=%.2f mem=%li pid=%li",
cfg->sleeptime, cfg->options & REALTIME ? "yes" : "no",
cfg->options & SYNC ? "yes" : "no",
cfg->options & SOFTBOOT ? "yes" : "no",
cfg->options & FORCE ? "yes" : "no", cfg->maxLoadOne, cfg->minfreepages, getppid());
if (cfg->options & ENABLEPING) {
for (int cnt = 0; cnt < config_setting_length(cfg->ipAddresses); cnt++) {
const char *ipAddress = config_setting_get_string_elem(cfg->ipAddresses,
cnt);
assert(ipAddress != NULL);
Logmsg(LOG_INFO, "ping: %s", ipAddress);
}
} else {
Logmsg(LOG_INFO, "ping: no ip adresses to ping");
}
if (cfg->options & ENABLEPIDCHECKER) {
for (int cnt = 0; cnt < config_setting_length(cfg->pidFiles); cnt++) {
const char *pidFilePathName = config_setting_get_string_elem(cfg->pidFiles, cnt);
assert(pidFilePathName != NULL);
Logmsg(LOG_DEBUG, "pidfile: %s", pidFilePathName);
}
} else {
Logmsg(LOG_INFO, "pidfile: no server process to check");
}
Logmsg(LOG_INFO, "test=%s(%i) repair=%s(%i) no_act=%s",
cfg->testexepathname == NULL ? "no" : cfg->testexepathname,
cfg->testBinTimeout,
cfg->exepathname == NULL ? "no" : cfg->exepathname,
cfg->repairBinTimeout, cfg->options & NOACTION ? "yes" : "no");
}
static void BlockSignals()
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGUSR2);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGHUP);
pthread_sigmask(SIG_BLOCK, &set, NULL);
}
static int SignalHandler(sd_event_source * s, const signalfd_siginfo * si, void *cxt)
{
switch (sd_event_source_get_signal(s)) {
case SIGTERM:
case SIGINT:
quit = 1;
sd_event_exit((sd_event *) cxt, 0);
break;
case SIGHUP:
//reload;
break;
}
return 1;
}
static void InstallSignalHandlers(sd_event * event)
{
int r1 = sd_event_add_signal(event, NULL, SIGTERM, SignalHandler, event);
int r2 = sd_event_add_signal(event, NULL, SIGHUP, SignalHandler, event);
int r3 = sd_event_add_signal(event, NULL, SIGUSR2, SignalHandler, event);
int r4 = sd_event_add_signal(event, NULL, SIGINT, SignalHandler, event);
if (r1 < 0 || r2 < 0 || r3 < 0 || r4 < 0) {
abort();
}
}
static int Pinger(sd_event_source * s, uint64_t usec, void *cxt)
{
Watchdog *watchdog = (Watchdog *) cxt;
watchdog->Ping();
sd_event_now(sd_event_source_get_event(s), CLOCK_REALTIME, &usec);
usec += watchdog->GetPingInterval() * 1000000;
sd_event_add_time(sd_event_source_get_event(s), &s, CLOCK_REALTIME, usec, 1, Pinger, (void *)cxt);
return 0;
}
static bool InstallPinger(sd_event * e, int time, Watchdog * w)
{
sd_event_source *s = NULL;
uint64_t usec = 0;
w->SetPingInterval(time);
sd_event_now(e, CLOCK_REALTIME, &usec);
sd_event_add_time(e, &s, CLOCK_REALTIME, usec, 1, Pinger, (void *)w);
return true;
}
int ServiceMain(int argc, char **argv, int fd, bool restarted)
{
cfgoptions options;
Watchdog watchdog;
cfgoptions *tmp = &options;
Watchdog *tmp2 = &watchdog;
struct dbusinfo temp = {.config = &tmp,.wdt = &tmp2 };;
temp.fd = fd;
if (MyStrerrorInit() == false) {
std::perror("Unable to create a new locale object");
return EXIT_FAILURE;
}
int ret = ParseCommandLine(&argc, argv, &options);
if (ret < 0) {
return EXIT_FAILURE;
} else if (ret != 0) {
return EXIT_SUCCESS;
}
if (strcasecmp(GetExeName(), "wd_identify") == 0 || strcasecmp(GetExeName(), "wd_identify.sh") == 0) {
options.options |= IDENTIFY;
}
if (ReadConfigurationFile(&options) < 0) {
return EXIT_FAILURE;
}
if (options.options & IDENTIFY) {
watchdog.Open(options.devicepath);
ret = Identify(watchdog.GetRawTimeout(), (const char *)watchdog.GetIdentity(),
options.devicepath, options.options & VERBOSE);
watchdog.Close();
return ret;
}
if (PingInit(&options) < 0) {
return EXIT_FAILURE;
}
if (restarted) {
Logmsg(LOG_INFO,"restarting service (%s)", PACKAGE_VERSION);
} else {
Logmsg(LOG_INFO, "starting service (%s)", PACKAGE_VERSION);
}
PrintConfiguration(&options);
if (ExecuteRepairScriptsPreFork(&processes, &options) == false) {
Logmsg(LOG_ERR, "ExecuteRepairScriptsPreFork failed");
FatalError(&options);
}
sd_event *event = NULL;
sd_event_default(&event);
BlockSignals();
InstallSignalHandlers(event);
if (StartHelperThreads(&options) != 0) {
FatalError(&options);
}
pthread_t dbusThread;
if (!(options.options & NOACTION)) {
errno = 0;
ret = watchdog.Open(options.devicepath);
if (errno == EBUSY && ret < 0) {
Logmsg(LOG_ERR, "Unable to open watchdog device");
return EXIT_FAILURE;
} else if (ret <= -1) {
LoadKernelModule();
ret = watchdog.Open(options.devicepath);
}
if (ret <= -1) {
FatalError(&options);
}
if (watchdog.ConfigureWatchdogTimeout(options.watchdogTimeout)
< 0 && options.watchdogTimeout != -1) {
Logmsg(LOG_ERR, "unable to set watchdog device timeout\n");
Logmsg(LOG_ERR, "program exiting\n");
EndDaemon(&options, false);
watchdog.Close();
return EXIT_FAILURE;
}
if (options.sleeptime == -1) {
options.sleeptime = watchdog.GetOptimalPingInterval();
Logmsg(LOG_INFO, "ping interval autodetect: %i", options.sleeptime);
}
if (options.watchdogTimeout != -1 && watchdog.CheckWatchdogTimeout(options.sleeptime) == true) {
Logmsg(LOG_ERR, "WDT timeout is less than or equal watchdog daemon ping interval");
Logmsg(LOG_ERR, "Using this interval may result in spurious reboots");
if (!(options.options & FORCE)) {
watchdog.Close();
Logmsg(LOG_WARNING, "use the -f option to force this configuration");
return EXIT_FAILURE;
}
}
WriteBootStatus(watchdog.GetStatus(), "/run/watchdogd.status", options.sleeptime,
watchdog.GetRawTimeout());
static struct identinfo i;
strncpy(i.name, (char *)watchdog.GetIdentity(), sizeof(i.name) - 1);
i.timeout = watchdog.GetRawTimeout();
strncpy(i.daemonVersion, PACKAGE_VERSION, sizeof(i.daemonVersion) - 1);
strncpy(i.deviceName, options.devicepath, sizeof(i.deviceName) - 1);
i.flags = watchdog.GetStatus();
i.firmwareVersion = watchdog.GetFirmwareVersion();
CreateDetachedThread(IdentityThread, &i);
pthread_create(&dbusThread, NULL, DbusHelper, &temp);
InstallPinger(event, options.sleeptime, &watchdog);
write(fd, "", sizeof(char));
}
if (SetupAuxManagerThread(&options) < 0) {
FatalError(&options);
}
if (PlatformInit() != true) {
FatalError(&options);
}
sd_event_loop(event);
if (stop == 1) {
while (true) {
if (stopPing == 1) {
if (DISARM_WATCHDOG_BEFORE_REBOOT) {
watchdog.Close();
}
} else {
watchdog.Ping();
}
sleep(1);
}
}
if (!(options.options & NOACTION)) {
pthread_cancel(dbusThread);
pthread_join(dbusThread, NULL);
}
watchdog.Close();
unlink("/run/watchdogd.status");
if (EndDaemon(&options, false) < 0) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int sock[2] = { 0 };
socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sock);
pid_t pid = fork();
if (pid == 0) {
OnParentDeathSend(SIGKILL);
close(sock[1]);
DbusApiInit(sock[0]);
_Exit(0);
}
close(sock[0]);
sigset_t mask;
bool restarted = false;
char name[64] = {0};
sd_bus *bus = NULL;
sd_bus_message *m = NULL;
sd_bus_error error = {0};
int fildes[2] = {0};
sigemptyset(&mask);
sigaddset(&mask, SIGTERM);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGHUP);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
int sfd = signalfd (-1, &mask, SFD_CLOEXEC);
init:
waitpid(-1, NULL, WNOHANG);
pipe(fildes);
pid = fork();
if (pid == 0) {
close(sfd);
ResetSignalHandlers(64);
sigfillset(&mask);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
close(fildes[1]);
read(fildes[0], fildes+1, sizeof(int));
close(fildes[0]);
_Exit(ServiceMain(argc, argv, sock[1], restarted));
}
sd_bus_open_system(&bus);
sprintf(name, "watchdogd.%li.scope", pid);
sd_bus_message_new_method_call(bus, &m, "org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartTransientUnit");
sd_bus_message_append(m, "ss", name, "fail");
sd_bus_message_open_container(m, 'a', "(sv)");
sd_bus_message_append(m, "(sv)", "Description", "s", " ");
sd_bus_message_append(m, "(sv)", "KillSignal", "i", SIGKILL);
sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, (uint32_t) pid);
sd_bus_message_close_container(m);
sd_bus_message_append(m, "a(sa(sv))", 0);
sd_bus_message * reply;
sd_bus_call(bus, m, 0, &error, &reply);
sd_bus_flush_close_unref(bus);
close(fildes[0]);
close(fildes[1]);
sd_notifyf(0, "READY=1\n" "MAINPID=%lu", (unsigned long)getpid());
while (true) {
struct signalfd_siginfo si = {0};
ssize_t ret = read (sfd, &si, sizeof(si));
switch (si.ssi_signo) {
case SIGHUP:
sd_bus_open_system(&bus);
sd_bus_call_method(bus, "org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager", "StopUnit", &error,
NULL, "ss", name, "ignore-dependencies");
sd_bus_flush_close_unref(bus);
restarted = true;
si.ssi_signo = 0;
goto init;
break;
case SIGINT:
case SIGTERM:
case SIGCHLD:
sd_bus_open_system(&bus);
sd_bus_call_method(bus, "org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager", "StopUnit", &error,
NULL, "ss", name, "ignore-dependencies");
sd_bus_flush_close_unref(bus);
_Exit(si.ssi_status);
break;
}
}
}
<|endoftext|> |
<commit_before>/* Copyright 2014 Andrew Schwartzmeyer
*
* Source file for derived genetic algorithm class
*/
#include <algorithm>
#include <iostream>
#include <iterator>
#include "genetic_algorithm.hpp"
#include "random_generator.hpp"
const Individual Genetic::mutate(const Individual & subject) const {
// unit Gaussian distribution for delta
Individual mutant = subject;
int_dist percent(1, 100);
normal_dist delta_dist(mean, stddev);
for (parameter & gene : mutant)
if (problem.chance || percent(rg.engine) < int(100 * problem.chance))
mutant.mutate(gene, gene * delta_dist(rg.engine));
// update fitness
mutant.fitness = problem.fitness(mutant);
return mutant;
}
const Individual Genetic::selection(const Genetic::population & contestants) const {
// return best Individual from a set of contestants
return *std::max_element(contestants.begin(), contestants.end());
}
const Genetic::population Genetic::crossover(const Genetic::population & mates) const {
// return two offspring for two mates
return mates;
}
const Individual Genetic::solve() const {
while(true) {
// create initial population
population generation;
for (int i = 0; i < population_size; ++i)
generation.emplace_back(problem.potential());
// generations loop
for (long i = 0; i < problem.iterations; ++i) {
// find generation's best member (general form of selection)
const Individual best = selection(generation);
// terminating condition
if (best.fitness > problem.goal) return best;
// std::cout << best.fitness << '\n';
// selection and mutation stage
population offspring;
while(offspring.size() != population_size) {
// tournament selection of parents
population parents;
for (int i = 0; i < crossover_size; ++i) {
population contestants;
int_dist population_dist(0, population_size-1); // closed interval
// create tournament of random members drawn from generation
for (int i = 0; i < tournament_size; ++i)
contestants.emplace_back(generation[population_dist(rg.engine)]);
// select best member from each tournament
parents.emplace_back(selection(contestants));
}
// crossover
population children = crossover(parents);
// add mutated children to offspring
for (const Individual child : children) offspring.emplace_back(mutate(child));
}
// replace generation with offspring
generation.swap(offspring);
}
std::cout << "Exhausted generations!\n";
}
}
<commit_msg>Implementing arithmetic corssover<commit_after>/* Copyright 2014 Andrew Schwartzmeyer
*
* Source file for derived genetic algorithm class
*/
#include <algorithm>
#include <iostream>
#include <iterator>
#include "genetic_algorithm.hpp"
#include "random_generator.hpp"
const Individual Genetic::mutate(const Individual & subject) const {
// unit Gaussian distribution for delta
Individual mutant = subject;
int_dist percent(1, 100);
normal_dist delta_dist(mean, stddev);
for (parameter & gene : mutant)
if (problem.chance || percent(rg.engine) < int(100 * problem.chance))
mutant.mutate(gene, gene * delta_dist(rg.engine));
// update fitness
mutant.fitness = problem.fitness(mutant);
return mutant;
}
const Individual Genetic::selection(const Genetic::population & contestants) const {
// return best Individual from a set of contestants
return *std::max_element(contestants.begin(), contestants.end());
}
const Genetic::population Genetic::crossover(const Genetic::population & parents) const {
population children = parents;
// arithmetic binary crossover
if (crossover_size == 2) {
real_dist alpha_dist(-0.1, 1.1);
parameter alpha = alpha_dist(rg.engine);
for (unsigned long i = 0; i < parents[0].size(); ++i) {
children[0][i] = alpha * parents[0][i] + (1 - alpha) * parents[1][i];
children[1][i] = (1 - alpha) * parents[0][i] + alpha * parents[1][i];
}
}
else {
// implement uniform crossover
}
// update fitnesses
for (Individual & child : children) child.fitness = problem.fitness(child);
return children;
}
const Individual Genetic::solve() const {
while(true) {
// create initial population
population generation;
for (int i = 0; i < population_size; ++i)
generation.emplace_back(problem.potential());
// generations loop
for (long i = 0; i < problem.iterations; ++i) {
// find generation's best member (general form of selection)
const Individual best = selection(generation);
// terminating condition
if (best.fitness > problem.goal) return best;
// std::cout << best.fitness << '\n';
// selection and mutation stage
population offspring;
while(offspring.size() != population_size) {
// tournament selection of parents
population parents;
for (int i = 0; i < crossover_size; ++i) {
population contestants;
int_dist population_dist(0, population_size-1); // closed interval
// create tournament of random members drawn from generation
for (int i = 0; i < tournament_size; ++i)
contestants.emplace_back(generation[population_dist(rg.engine)]);
// select best member from each tournament
parents.emplace_back(selection(contestants));
}
// crossover
population children = crossover(parents);
// add mutated children to offspring
for (const Individual child : children) offspring.emplace_back(mutate(child));
}
// replace generation with offspring
generation.swap(offspring);
}
std::cout << "Exhausted generations!\n";
}
}
<|endoftext|> |
<commit_before>//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "shaderGen/GLSL/shaderCompGLSL.h"
#include "shaderGen/shaderComp.h"
#include "shaderGen/langElement.h"
#include "gfx/gfxDevice.h"
Var * AppVertConnectorGLSL::getElement( RegisterType type,
U32 numElements,
U32 numRegisters )
{
switch( type )
{
case RT_POSITION:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vPosition" );
return newVar;
}
case RT_NORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vNormal" );
return newVar;
}
case RT_BINORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vBinormal" );
return newVar;
}
case RT_COLOR:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vColor" );
return newVar;
}
case RT_TANGENT:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vTangent" );
return newVar;
}
case RT_TANGENTW:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vTangentW" );
return newVar;
}
case RT_TEXCOORD:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
char out[32];
dSprintf( (char*)out, sizeof(out), "vTexCoord%d", mCurTexElem );
newVar->setConnectName( out );
newVar->constNum = mCurTexElem;
newVar->arraySize = numElements;
if ( numRegisters != -1 )
mCurTexElem += numRegisters;
else
mCurTexElem += numElements;
return newVar;
}
default:
break;
}
return NULL;
}
void AppVertConnectorGLSL::sortVars()
{
// Not required in GLSL
}
void AppVertConnectorGLSL::setName( char *newName )
{
dStrcpy( (char*)mName, newName );
}
void AppVertConnectorGLSL::reset()
{
for( U32 i=0; i<mElementList.size(); i++ )
{
mElementList[i] = NULL;
}
mElementList.setSize( 0 );
mCurTexElem = 0;
}
void AppVertConnectorGLSL::print( Stream &stream, bool isVertexShader )
{
if(!isVertexShader)
return;
U8 output[256];
// print struct
dSprintf( (char*)output, sizeof(output), "struct VertexData\r\n" );
stream.write( dStrlen((char*)output), output );
dSprintf( (char*)output, sizeof(output), "{\r\n" );
stream.write( dStrlen((char*)output), output );
for( U32 i=0; i<mElementList.size(); i++ )
{
Var *var = mElementList[i];
if( var->arraySize == 1)
{
dSprintf( (char*)output, sizeof(output), " %s %s;\r\n", var->type, (char*)var->name );
stream.write( dStrlen((char*)output), output );
}
else
{
dSprintf( (char*)output, sizeof(output), " %s %s[%d];\r\n", var->type, (char*)var->name, var->arraySize );
stream.write( dStrlen((char*)output), output );
}
}
dSprintf( (char*)output, sizeof(output), "} IN;\r\n\r\n" );
stream.write( dStrlen((char*)output), output );
// print in elements
for( U32 i=0; i<mElementList.size(); i++ )
{
Var *var = mElementList[i];
for(int j = 0; j < var->arraySize; ++j)
{
const char *name = j == 0 ? var->connectName : avar("vTexCoord%d", var->constNum + j) ;
dSprintf( (char*)output, sizeof(output), "in %s %s;\r\n", var->type, name );
stream.write( dStrlen((char*)output), output );
}
dSprintf( (char*)output, sizeof(output), "#define IN_%s IN.%s\r\n", var->name, var->name ); // TODO REMOVE
stream.write( dStrlen((char*)output), output );
}
const char* newLine ="\r\n";
stream.write( dStrlen((char*)newLine), newLine );
}
Var * VertPixelConnectorGLSL::getElement( RegisterType type,
U32 numElements,
U32 numRegisters )
{
switch( type )
{
case RT_POSITION:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "POSITION" );
return newVar;
}
case RT_NORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "NORMAL" );
return newVar;
}
case RT_COLOR:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "COLOR" );
return newVar;
}
/*case RT_BINORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "BINORMAL" );
return newVar;
}
case RT_TANGENT:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "TANGENT" );
return newVar;
} */
case RT_TEXCOORD:
case RT_BINORMAL:
case RT_TANGENT:
{
Var *newVar = new Var;
newVar->arraySize = numElements;
char out[32];
dSprintf( (char*)out, sizeof(out), "TEXCOORD%d", mCurTexElem );
newVar->setConnectName( out );
if ( numRegisters != -1 )
mCurTexElem += numRegisters;
else
mCurTexElem += numElements;
mElementList.push_back( newVar );
return newVar;
}
default:
break;
}
return NULL;
}
void VertPixelConnectorGLSL::sortVars()
{
// Not needed in GLSL
}
void VertPixelConnectorGLSL::setName( char *newName )
{
dStrcpy( (char*)mName, newName );
}
void VertPixelConnectorGLSL::reset()
{
for( U32 i=0; i<mElementList.size(); i++ )
{
mElementList[i] = NULL;
}
mElementList.setSize( 0 );
mCurTexElem = 0;
}
void VertPixelConnectorGLSL::print( Stream &stream, bool isVerterShader )
{
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
U8 output[256];
Var *var = mElementList[i];
if(!dStrcmp((const char*)var->name, "gl_Position"))
continue;
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), "%s %s _%s_;\r\n", (isVerterShader ? "out" : "in"), var->type, var->connectName);
else
dSprintf((char*)output, sizeof(output), "%s %s _%s_[%d];\r\n", (isVerterShader ? "out" : "in"),var->type, var->connectName, var->arraySize);
stream.write( dStrlen((char*)output), output );
}
printStructDefines(stream, !isVerterShader);
}
void VertPixelConnectorGLSL::printOnMain( Stream &stream, bool isVerterShader )
{
if(isVerterShader)
return;
const char *newLine = "\r\n";
const char *header = " //-------------------------\r\n";
stream.write( dStrlen((char*)newLine), newLine );
stream.write( dStrlen((char*)header), header );
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
U8 output[256];
Var *var = mElementList[i];
if(!dStrcmp((const char*)var->name, "gl_Position"))
continue;
dSprintf((char*)output, sizeof(output), " %s IN_%s = _%s_;\r\n", var->type, var->name, var->connectName);
stream.write( dStrlen((char*)output), output );
}
stream.write( dStrlen((char*)header), header );
stream.write( dStrlen((char*)newLine), newLine );
}
void AppVertConnectorGLSL::printOnMain( Stream &stream, bool isVerterShader )
{
if(!isVerterShader)
return;
const char *newLine = "\r\n";
const char *header = " //-------------------------\r\n";
stream.write( dStrlen((char*)newLine), newLine );
stream.write( dStrlen((char*)header), header );
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
Var *var = mElementList[i];
U8 output[256];
if(var->arraySize <= 1)
{
dSprintf((char*)output, sizeof(output), " IN.%s = %s;\r\n", var->name, var->connectName);
stream.write( dStrlen((char*)output), output );
}
else
{
for(int j = 0; j < var->arraySize; ++j)
{
const char *name = j == 0 ? var->connectName : avar("vTexCoord%d", var->constNum + j) ;
dSprintf((char*)output, sizeof(output), " IN.%s[%d] = %s;\r\n", var->name, j, name );
stream.write( dStrlen((char*)output), output );
}
}
}
stream.write( dStrlen((char*)header), header );
stream.write( dStrlen((char*)newLine), newLine );
}
Vector<String> initDeprecadedDefines()
{
Vector<String> vec;
vec.push_back( "isBack");
return vec;
}
void VertPixelConnectorGLSL::printStructDefines( Stream &stream, bool in )
{
const char* connectionDir;
if(in)
{
connectionDir = "IN";
}
else
{
connectionDir = "OUT";
}
static Vector<String> deprecatedDefines = initDeprecadedDefines();
const char *newLine = "\r\n";
const char *header = "// Struct defines\r\n";
stream.write( dStrlen((char*)newLine), newLine );
stream.write( dStrlen((char*)header), header );
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
U8 output[256];
Var *var = mElementList[i];
if(!dStrcmp((const char*)var->name, "gl_Position"))
continue;
if(!in)
{
dSprintf((char*)output, sizeof(output), "#define %s_%s _%s_\r\n", connectionDir, var->name, var->connectName);
stream.write( dStrlen((char*)output), output );
continue;
}
if( deprecatedDefines.contains((char*)var->name))
continue;
dSprintf((char*)output, sizeof(output), "#define %s %s_%s\r\n", var->name, connectionDir, var->name);
stream.write( dStrlen((char*)output), output );
}
stream.write( dStrlen((char*)newLine), newLine );
}
void VertexParamsDefGLSL::print( Stream &stream, bool isVerterShader )
{
// find all the uniform variables and print them out
for( U32 i=0; i<LangElement::elementList.size(); i++)
{
Var *var = dynamic_cast<Var*>(LangElement::elementList[i]);
if( var )
{
if( var->uniform )
{
U8 output[256];
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s;\r\n", var->type, var->name);
else
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s[%d];\r\n", var->type, var->name, var->arraySize);
stream.write( dStrlen((char*)output), output );
}
}
}
const char *closer = "\r\n\r\nvoid main()\r\n{\r\n";
stream.write( dStrlen(closer), closer );
}
void PixelParamsDefGLSL::print( Stream &stream, bool isVerterShader )
{
// find all the uniform variables and print them out
for( U32 i=0; i<LangElement::elementList.size(); i++)
{
Var *var = dynamic_cast<Var*>(LangElement::elementList[i]);
if( var )
{
if( var->uniform )
{
U8 output[256];
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s;\r\n", var->type, var->name);
else
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s[%d];\r\n", var->type, var->name, var->arraySize);
stream.write( dStrlen((char*)output), output );
}
}
}
const char *closer = "\r\nvoid main()\r\n{\r\n";
stream.write( dStrlen(closer), closer );
for( U32 i=0; i<LangElement::elementList.size(); i++)
{
Var *var = dynamic_cast<Var*>(LangElement::elementList[i]);
if( var )
{
if( var->uniform && !var->sampler)
{
U8 output[256];
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), " %s %s = %s;\r\n", var->type, var->name, var->name);
else
dSprintf((char*)output, sizeof(output), " %s %s[%d] = %s;\r\n", var->type, var->name, var->arraySize, var->name);
stream.write( dStrlen((char*)output), output );
}
}
}
}
<commit_msg>Remove some dead code from OpenGL shadergen.<commit_after>//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "shaderGen/GLSL/shaderCompGLSL.h"
#include "shaderGen/shaderComp.h"
#include "shaderGen/langElement.h"
#include "gfx/gfxDevice.h"
Var * AppVertConnectorGLSL::getElement( RegisterType type,
U32 numElements,
U32 numRegisters )
{
switch( type )
{
case RT_POSITION:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vPosition" );
return newVar;
}
case RT_NORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vNormal" );
return newVar;
}
case RT_BINORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vBinormal" );
return newVar;
}
case RT_COLOR:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vColor" );
return newVar;
}
case RT_TANGENT:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vTangent" );
return newVar;
}
case RT_TANGENTW:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "vTangentW" );
return newVar;
}
case RT_TEXCOORD:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
char out[32];
dSprintf( (char*)out, sizeof(out), "vTexCoord%d", mCurTexElem );
newVar->setConnectName( out );
newVar->constNum = mCurTexElem;
newVar->arraySize = numElements;
if ( numRegisters != -1 )
mCurTexElem += numRegisters;
else
mCurTexElem += numElements;
return newVar;
}
default:
break;
}
return NULL;
}
void AppVertConnectorGLSL::sortVars()
{
// Not required in GLSL
}
void AppVertConnectorGLSL::setName( char *newName )
{
dStrcpy( (char*)mName, newName );
}
void AppVertConnectorGLSL::reset()
{
for( U32 i=0; i<mElementList.size(); i++ )
{
mElementList[i] = NULL;
}
mElementList.setSize( 0 );
mCurTexElem = 0;
}
void AppVertConnectorGLSL::print( Stream &stream, bool isVertexShader )
{
if(!isVertexShader)
return;
U8 output[256];
// print struct
dSprintf( (char*)output, sizeof(output), "struct VertexData\r\n" );
stream.write( dStrlen((char*)output), output );
dSprintf( (char*)output, sizeof(output), "{\r\n" );
stream.write( dStrlen((char*)output), output );
for( U32 i=0; i<mElementList.size(); i++ )
{
Var *var = mElementList[i];
if( var->arraySize == 1)
{
dSprintf( (char*)output, sizeof(output), " %s %s;\r\n", var->type, (char*)var->name );
stream.write( dStrlen((char*)output), output );
}
else
{
dSprintf( (char*)output, sizeof(output), " %s %s[%d];\r\n", var->type, (char*)var->name, var->arraySize );
stream.write( dStrlen((char*)output), output );
}
}
dSprintf( (char*)output, sizeof(output), "} IN;\r\n\r\n" );
stream.write( dStrlen((char*)output), output );
// print in elements
for( U32 i=0; i<mElementList.size(); i++ )
{
Var *var = mElementList[i];
for(int j = 0; j < var->arraySize; ++j)
{
const char *name = j == 0 ? var->connectName : avar("vTexCoord%d", var->constNum + j) ;
dSprintf( (char*)output, sizeof(output), "in %s %s;\r\n", var->type, name );
stream.write( dStrlen((char*)output), output );
}
dSprintf( (char*)output, sizeof(output), "#define IN_%s IN.%s\r\n", var->name, var->name ); // TODO REMOVE
stream.write( dStrlen((char*)output), output );
}
const char* newLine ="\r\n";
stream.write( dStrlen((char*)newLine), newLine );
}
Var * VertPixelConnectorGLSL::getElement( RegisterType type,
U32 numElements,
U32 numRegisters )
{
switch( type )
{
case RT_POSITION:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "POSITION" );
return newVar;
}
case RT_NORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "NORMAL" );
return newVar;
}
case RT_COLOR:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "COLOR" );
return newVar;
}
/*case RT_BINORMAL:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "BINORMAL" );
return newVar;
}
case RT_TANGENT:
{
Var *newVar = new Var;
mElementList.push_back( newVar );
newVar->setConnectName( "TANGENT" );
return newVar;
} */
case RT_TEXCOORD:
case RT_BINORMAL:
case RT_TANGENT:
{
Var *newVar = new Var;
newVar->arraySize = numElements;
char out[32];
dSprintf( (char*)out, sizeof(out), "TEXCOORD%d", mCurTexElem );
newVar->setConnectName( out );
if ( numRegisters != -1 )
mCurTexElem += numRegisters;
else
mCurTexElem += numElements;
mElementList.push_back( newVar );
return newVar;
}
default:
break;
}
return NULL;
}
void VertPixelConnectorGLSL::sortVars()
{
// Not needed in GLSL
}
void VertPixelConnectorGLSL::setName( char *newName )
{
dStrcpy( (char*)mName, newName );
}
void VertPixelConnectorGLSL::reset()
{
for( U32 i=0; i<mElementList.size(); i++ )
{
mElementList[i] = NULL;
}
mElementList.setSize( 0 );
mCurTexElem = 0;
}
void VertPixelConnectorGLSL::print( Stream &stream, bool isVerterShader )
{
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
U8 output[256];
Var *var = mElementList[i];
if(!dStrcmp((const char*)var->name, "gl_Position"))
continue;
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), "%s %s _%s_;\r\n", (isVerterShader ? "out" : "in"), var->type, var->connectName);
else
dSprintf((char*)output, sizeof(output), "%s %s _%s_[%d];\r\n", (isVerterShader ? "out" : "in"),var->type, var->connectName, var->arraySize);
stream.write( dStrlen((char*)output), output );
}
printStructDefines(stream, !isVerterShader);
}
void VertPixelConnectorGLSL::printOnMain( Stream &stream, bool isVerterShader )
{
if(isVerterShader)
return;
const char *newLine = "\r\n";
const char *header = " //-------------------------\r\n";
stream.write( dStrlen((char*)newLine), newLine );
stream.write( dStrlen((char*)header), header );
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
U8 output[256];
Var *var = mElementList[i];
if(!dStrcmp((const char*)var->name, "gl_Position"))
continue;
dSprintf((char*)output, sizeof(output), " %s IN_%s = _%s_;\r\n", var->type, var->name, var->connectName);
stream.write( dStrlen((char*)output), output );
}
stream.write( dStrlen((char*)header), header );
stream.write( dStrlen((char*)newLine), newLine );
}
void AppVertConnectorGLSL::printOnMain( Stream &stream, bool isVerterShader )
{
if(!isVerterShader)
return;
const char *newLine = "\r\n";
const char *header = " //-------------------------\r\n";
stream.write( dStrlen((char*)newLine), newLine );
stream.write( dStrlen((char*)header), header );
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
Var *var = mElementList[i];
U8 output[256];
if(var->arraySize <= 1)
{
dSprintf((char*)output, sizeof(output), " IN.%s = %s;\r\n", var->name, var->connectName);
stream.write( dStrlen((char*)output), output );
}
else
{
for(int j = 0; j < var->arraySize; ++j)
{
const char *name = j == 0 ? var->connectName : avar("vTexCoord%d", var->constNum + j) ;
dSprintf((char*)output, sizeof(output), " IN.%s[%d] = %s;\r\n", var->name, j, name );
stream.write( dStrlen((char*)output), output );
}
}
}
stream.write( dStrlen((char*)header), header );
stream.write( dStrlen((char*)newLine), newLine );
}
Vector<String> initDeprecadedDefines()
{
Vector<String> vec;
vec.push_back( "isBack");
return vec;
}
void VertPixelConnectorGLSL::printStructDefines( Stream &stream, bool in )
{
const char* connectionDir = in ? "IN" : "OUT";
static Vector<String> deprecatedDefines = initDeprecadedDefines();
const char *newLine = "\r\n";
const char *header = "// Struct defines\r\n";
stream.write( dStrlen((char*)newLine), newLine );
stream.write( dStrlen((char*)header), header );
// print out elements
for( U32 i=0; i<mElementList.size(); i++ )
{
U8 output[256];
Var *var = mElementList[i];
if(!dStrcmp((const char*)var->name, "gl_Position"))
continue;
if(!in)
{
dSprintf((char*)output, sizeof(output), "#define %s_%s _%s_\r\n", connectionDir, var->name, var->connectName);
stream.write( dStrlen((char*)output), output );
continue;
}
}
stream.write( dStrlen((char*)newLine), newLine );
}
void VertexParamsDefGLSL::print( Stream &stream, bool isVerterShader )
{
// find all the uniform variables and print them out
for( U32 i=0; i<LangElement::elementList.size(); i++)
{
Var *var = dynamic_cast<Var*>(LangElement::elementList[i]);
if( var )
{
if( var->uniform )
{
U8 output[256];
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s;\r\n", var->type, var->name);
else
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s[%d];\r\n", var->type, var->name, var->arraySize);
stream.write( dStrlen((char*)output), output );
}
}
}
const char *closer = "\r\n\r\nvoid main()\r\n{\r\n";
stream.write( dStrlen(closer), closer );
}
void PixelParamsDefGLSL::print( Stream &stream, bool isVerterShader )
{
// find all the uniform variables and print them out
for( U32 i=0; i<LangElement::elementList.size(); i++)
{
Var *var = dynamic_cast<Var*>(LangElement::elementList[i]);
if( var )
{
if( var->uniform )
{
U8 output[256];
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s;\r\n", var->type, var->name);
else
dSprintf((char*)output, sizeof(output), "uniform %-8s %-15s[%d];\r\n", var->type, var->name, var->arraySize);
stream.write( dStrlen((char*)output), output );
}
}
}
const char *closer = "\r\nvoid main()\r\n{\r\n";
stream.write( dStrlen(closer), closer );
for( U32 i=0; i<LangElement::elementList.size(); i++)
{
Var *var = dynamic_cast<Var*>(LangElement::elementList[i]);
if( var )
{
if( var->uniform && !var->sampler)
{
U8 output[256];
if(var->arraySize <= 1)
dSprintf((char*)output, sizeof(output), " %s %s = %s;\r\n", var->type, var->name, var->name);
else
dSprintf((char*)output, sizeof(output), " %s %s[%d] = %s;\r\n", var->type, var->name, var->arraySize, var->name);
stream.write( dStrlen((char*)output), output );
}
}
}
}
<|endoftext|> |
<commit_before>// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "txdb.h"
#include "chainparams.h"
#include "hash.h"
#include "pow.h"
#include "uint256.h"
#include <stdint.h>
#include <boost/thread.hpp>
static const char DB_COINS = 'c';
static const char DB_BLOCK_FILES = 'f';
static const char DB_TXINDEX = 't';
static const char DB_BLOCK_INDEX = 'b';
static const char DB_BEST_BLOCK = 'B';
static const char DB_FLAG = 'F';
static const char DB_REINDEX_FLAG = 'R';
static const char DB_LAST_BLOCK = 'l';
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe, true)
{
}
bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) const {
return db.Read(std::make_pair(DB_COINS, txid), coins);
}
bool CCoinsViewDB::HaveCoins(const uint256 &txid) const {
return db.Exists(std::make_pair(DB_COINS, txid));
}
uint256 CCoinsViewDB::GetBestBlock() const {
uint256 hashBestChain;
if (!db.Read(DB_BEST_BLOCK, hashBestChain))
return uint256();
return hashBestChain;
}
bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
CDBBatch batch(db);
size_t count = 0;
size_t changed = 0;
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
if (it->second.flags & CCoinsCacheEntry::DIRTY) {
if (it->second.coins.IsPruned())
batch.Erase(std::make_pair(DB_COINS, it->first));
else
batch.Write(std::make_pair(DB_COINS, it->first), it->second.coins);
changed++;
}
count++;
CCoinsMap::iterator itOld = it++;
mapCoins.erase(itOld);
}
if (!hashBlock.IsNull())
batch.Write(DB_BEST_BLOCK, hashBlock);
LogPrint("coindb", "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
return db.WriteBatch(batch);
}
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
}
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
}
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
if (fReindexing)
return Write(DB_REINDEX_FLAG, '1');
else
return Erase(DB_REINDEX_FLAG);
}
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
fReindexing = Exists(DB_REINDEX_FLAG);
return true;
}
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
return Read(DB_LAST_BLOCK, nFile);
}
CCoinsViewCursor *CCoinsViewDB::Cursor() const
{
CCoinsViewDBCursor *i = new CCoinsViewDBCursor(const_cast<CDBWrapper*>(&db)->NewIterator(), GetBestBlock());
/* It seems that there are no "const iterators" for LevelDB. Since we
only need read operations on it, use a const-cast to get around
that restriction. */
i->pcursor->Seek(DB_COINS);
// Cache key of first record
i->pcursor->GetKey(i->keyTmp);
return i;
}
bool CCoinsViewDBCursor::GetKey(uint256 &key) const
{
// Return cached key
if (keyTmp.first == DB_COINS) {
key = keyTmp.second;
return true;
}
return false;
}
bool CCoinsViewDBCursor::GetValue(CCoins &coins) const
{
return pcursor->GetValue(coins);
}
unsigned int CCoinsViewDBCursor::GetValueSize() const
{
return pcursor->GetValueSize();
}
bool CCoinsViewDBCursor::Valid() const
{
return keyTmp.first == DB_COINS;
}
void CCoinsViewDBCursor::Next()
{
pcursor->Next();
if (!pcursor->Valid() || !pcursor->GetKey(keyTmp))
keyTmp.first = 0; // Invalidate cached key after last record so that Valid() and GetKey() return false
}
bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
CDBBatch batch(*this);
for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
batch.Write(std::make_pair(DB_BLOCK_FILES, it->first), *it->second);
}
batch.Write(DB_LAST_BLOCK, nLastFile);
for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) {
batch.Write(std::make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it));
}
return WriteBatch(batch, true);
}
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
return Read(std::make_pair(DB_TXINDEX, txid), pos);
}
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
CDBBatch batch(*this);
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
batch.Write(std::make_pair(DB_TXINDEX, it->first), it->second);
return WriteBatch(batch);
}
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
}
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
char ch;
if (!Read(std::make_pair(DB_FLAG, name), ch))
return false;
fValue = ch == '1';
return true;
}
bool CBlockTreeDB::LoadBlockIndexGuts(boost::function<CBlockIndex*(const uint256&)> insertBlockIndex)
{
std::unique_ptr<CDBIterator> pcursor(NewIterator());
pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
// Load mapBlockIndex
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
std::pair<char, uint256> key;
if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
CDiskBlockIndex diskindex;
if (pcursor->GetValue(diskindex)) {
// Construct block index object
CBlockIndex* pindexNew = insertBlockIndex(diskindex.GetBlockHash());
pindexNew->pprev = insertBlockIndex(diskindex.hashPrev);
pindexNew->nHeight = diskindex.nHeight;
pindexNew->nFile = diskindex.nFile;
pindexNew->nDataPos = diskindex.nDataPos;
pindexNew->nUndoPos = diskindex.nUndoPos;
pindexNew->nVersion = diskindex.nVersion;
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
pindexNew->nTime = diskindex.nTime;
pindexNew->nBits = diskindex.nBits;
pindexNew->nNonce = diskindex.nNonce;
pindexNew->nStatus = diskindex.nStatus;
pindexNew->nTx = diskindex.nTx;
pindexNew->hashStateRoot = diskindex.hashStateRoot; // qtum
if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString());
pcursor->Next();
} else {
return error("LoadBlockIndex() : failed to read value");
}
} else {
break;
}
}
return true;
}
<commit_msg>Update the transaction db with the block index parameters for PoS<commit_after>// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "txdb.h"
#include "chainparams.h"
#include "hash.h"
#include "pow.h"
#include "uint256.h"
#include <stdint.h>
#include <boost/thread.hpp>
static const char DB_COINS = 'c';
static const char DB_BLOCK_FILES = 'f';
static const char DB_TXINDEX = 't';
static const char DB_BLOCK_INDEX = 'b';
static const char DB_BEST_BLOCK = 'B';
static const char DB_FLAG = 'F';
static const char DB_REINDEX_FLAG = 'R';
static const char DB_LAST_BLOCK = 'l';
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe, true)
{
}
bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) const {
return db.Read(std::make_pair(DB_COINS, txid), coins);
}
bool CCoinsViewDB::HaveCoins(const uint256 &txid) const {
return db.Exists(std::make_pair(DB_COINS, txid));
}
uint256 CCoinsViewDB::GetBestBlock() const {
uint256 hashBestChain;
if (!db.Read(DB_BEST_BLOCK, hashBestChain))
return uint256();
return hashBestChain;
}
bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
CDBBatch batch(db);
size_t count = 0;
size_t changed = 0;
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
if (it->second.flags & CCoinsCacheEntry::DIRTY) {
if (it->second.coins.IsPruned())
batch.Erase(std::make_pair(DB_COINS, it->first));
else
batch.Write(std::make_pair(DB_COINS, it->first), it->second.coins);
changed++;
}
count++;
CCoinsMap::iterator itOld = it++;
mapCoins.erase(itOld);
}
if (!hashBlock.IsNull())
batch.Write(DB_BEST_BLOCK, hashBlock);
LogPrint("coindb", "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
return db.WriteBatch(batch);
}
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
}
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
}
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
if (fReindexing)
return Write(DB_REINDEX_FLAG, '1');
else
return Erase(DB_REINDEX_FLAG);
}
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
fReindexing = Exists(DB_REINDEX_FLAG);
return true;
}
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
return Read(DB_LAST_BLOCK, nFile);
}
CCoinsViewCursor *CCoinsViewDB::Cursor() const
{
CCoinsViewDBCursor *i = new CCoinsViewDBCursor(const_cast<CDBWrapper*>(&db)->NewIterator(), GetBestBlock());
/* It seems that there are no "const iterators" for LevelDB. Since we
only need read operations on it, use a const-cast to get around
that restriction. */
i->pcursor->Seek(DB_COINS);
// Cache key of first record
i->pcursor->GetKey(i->keyTmp);
return i;
}
bool CCoinsViewDBCursor::GetKey(uint256 &key) const
{
// Return cached key
if (keyTmp.first == DB_COINS) {
key = keyTmp.second;
return true;
}
return false;
}
bool CCoinsViewDBCursor::GetValue(CCoins &coins) const
{
return pcursor->GetValue(coins);
}
unsigned int CCoinsViewDBCursor::GetValueSize() const
{
return pcursor->GetValueSize();
}
bool CCoinsViewDBCursor::Valid() const
{
return keyTmp.first == DB_COINS;
}
void CCoinsViewDBCursor::Next()
{
pcursor->Next();
if (!pcursor->Valid() || !pcursor->GetKey(keyTmp))
keyTmp.first = 0; // Invalidate cached key after last record so that Valid() and GetKey() return false
}
bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
CDBBatch batch(*this);
for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
batch.Write(std::make_pair(DB_BLOCK_FILES, it->first), *it->second);
}
batch.Write(DB_LAST_BLOCK, nLastFile);
for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) {
batch.Write(std::make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it));
}
return WriteBatch(batch, true);
}
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
return Read(std::make_pair(DB_TXINDEX, txid), pos);
}
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
CDBBatch batch(*this);
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
batch.Write(std::make_pair(DB_TXINDEX, it->first), it->second);
return WriteBatch(batch);
}
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
}
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
char ch;
if (!Read(std::make_pair(DB_FLAG, name), ch))
return false;
fValue = ch == '1';
return true;
}
bool CBlockTreeDB::LoadBlockIndexGuts(boost::function<CBlockIndex*(const uint256&)> insertBlockIndex)
{
std::unique_ptr<CDBIterator> pcursor(NewIterator());
pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
// Load mapBlockIndex
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
std::pair<char, uint256> key;
if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
CDiskBlockIndex diskindex;
if (pcursor->GetValue(diskindex)) {
// Construct block index object
CBlockIndex* pindexNew = insertBlockIndex(diskindex.GetBlockHash());
pindexNew->pprev = insertBlockIndex(diskindex.hashPrev);
pindexNew->nHeight = diskindex.nHeight;
pindexNew->nFile = diskindex.nFile;
pindexNew->nDataPos = diskindex.nDataPos;
pindexNew->nUndoPos = diskindex.nUndoPos;
pindexNew->nVersion = diskindex.nVersion;
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
pindexNew->nTime = diskindex.nTime;
pindexNew->nBits = diskindex.nBits;
pindexNew->nNonce = diskindex.nNonce;
pindexNew->nStatus = diskindex.nStatus;
pindexNew->nTx = diskindex.nTx;
pindexNew->hashStateRoot = diskindex.hashStateRoot; // qtum
pindexNew->fStake = diskindex.fStake;
pindexNew->nStakeModifier = diskindex.nStakeModifier;
pindexNew->prevoutStake = diskindex.prevoutStake;
pindexNew->nStakeTime = diskindex.nStakeTime; // qtum
if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString());
pcursor->Next();
} else {
return error("LoadBlockIndex() : failed to read value");
}
} else {
break;
}
}
return true;
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2015, Eric Arnebäck([email protected])
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <float.h>
using std::string;
using std::cout;
using std::endl;
using std::cerr;
using std::ifstream;
using std::vector;
using std::stringstream;
using std::stof;
using std::invalid_argument;
using std::ostream;
struct Vector {
public:
float x,y,z;
Vector(float x_, float y_, float z_) {
x = x_;
y = y_;
z = z_;
}
Vector() {
x = y = z = 0;
}
static float Dot(const Vector& v1, const Vector& v2) {
return
v1.x * v2.x +
v1.y * v2.y +
v1.z * v2.z;
}
friend ostream& operator<<(ostream& os, const Vector& v) {
os << "(" << v.x << "," << v.y << "," << v.z << ")";
return os;
}
};
string StripFileExtension(const string& str);
void PrintHelp();
// split a string on whitespace character.
vector<string> Split(string str);
int main(int argc, char *argv[] ) {
/*
Parse command line arguments:
*/
if(argc < 2) { // not enough arguments.
PrintHelp();
exit(1);
}
for (int i = 1; i < argc; i++) {
if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 ) {
PrintHelp();
exit(0);
}
}
// last arguent is input file
const string inputFile = string(argv[argc-1]);
cout << "input file: " << inputFile << endl;
ifstream file (inputFile);
if(file.fail()) {
cerr << "Error: " << strerror(errno) << endl;
}
string line;
Vector axes[] = {
Vector(1,0,0),
Vector(0,1,0),
Vector(0,0,1),
};
Vector vmin[3];
Vector vmax[3];
float minproj[3] = {FLT_MAX, FLT_MAX, FLT_MAX };
float maxproj[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX };
while(getline(file, line)) {
// we are only interested in the vertices of the model.
// all other information(such as normals) we ignore.
if(line[0] != 'v' || line[1] != ' ')
continue;
vector<string> tokens = Split(line);
if(tokens.size() != 4) {
cerr << "Invalid obj-file: every vertex line must have three integers:" << endl;
cerr << line << endl;
exit(1);
}
Vector pt;
try {
pt.x = stof(tokens[1], NULL);
pt.y = stof(tokens[2], NULL);
pt.z = stof(tokens[3], NULL);
} catch(const invalid_argument& e) {
cerr << "Invalid obj-file: found vertex with invalid numbers:" << endl;
cerr << line << endl;
exit(1);
}
for(int iaxis = 0; iaxis < 3; ++iaxis) {
Vector axis = axes[iaxis];
float proj = Vector::Dot(pt, axis);
if (proj < minproj[iaxis]) {
minproj[iaxis] = proj;
vmin[iaxis] = pt;
}
// Keep track of most distant point along direction vector
if (proj > maxproj[iaxis]) {
maxproj[iaxis] = proj;
vmax[iaxis] = pt;
// *imax = i;
}
}
}
cout << "xmin " << vmin[0] << endl;
cout << "xmax " << vmax[0] << endl;
cout << "ymin " << vmin[1] << endl;
cout << "ymax " << vmax[1] << endl;
cout << "zmin " << vmin[2] << endl;
cout << "zmax " << vmax[2] << endl;
}
string StripFileExtension(const string& str) {
size_t last_dot = str.find_last_of(".");
return str.substr(0,last_dot);
}
void PrintHelp() {
printf("Usage:\n");
printf("aabb_create [FLAGS] input-file\n\n");
// printf("Flags:\n");
// printf("\t-h,--help\t\tPrint this message\n");
// printf( "\t-fs,--font-size\t\tFont size. Default value: %d\n", FONT_SIZE_DEFALT );
}
vector<string> Split(string str) {
string buffer;
stringstream ss(str);
vector<string> tokens;
while (ss >> buffer)
tokens.push_back(buffer);
return tokens;
}
<commit_msg>finished the program.<commit_after>/*
Copyright (c) 2015, Eric Arnebäck([email protected])
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <float.h>
using std::string;
using std::cout;
using std::endl;
using std::cerr;
using std::ifstream;
using std::vector;
using std::stringstream;
using std::stof;
using std::invalid_argument;
using std::ostream;
using std::ofstream;
struct Vector {
public:
float x,y,z;
Vector(float x_, float y_, float z_) {
x = x_;
y = y_;
z = z_;
}
Vector() {
x = y = z = 0;
}
static float Dot(const Vector& v1, const Vector& v2) {
return
v1.x * v2.x +
v1.y * v2.y +
v1.z * v2.z;
}
friend ostream& operator<<(ostream& os, const Vector& v) {
os << v.x << " " << v.y << " " << v.z;
return os;
}
};
string StripFileExtension(const string& str);
void PrintHelp();
// split a string on whitespace character.
vector<string> Split(string str);
int main(int argc, char *argv[] ) {
/*
Parse command line arguments:
*/
if(argc < 2) { // not enough arguments.
PrintHelp();
exit(1);
}
for (int i = 1; i < argc; i++) {
if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 ) {
PrintHelp();
exit(0);
}
}
// last arguent is input file
const string inputFile = string(argv[argc-1]);
const string outputFile = StripFileExtension(inputFile) + ".aabb";
ifstream file (inputFile);
if(file.fail()) {
cerr << "Error: " << strerror(errno) << endl;
}
string line;
Vector axes[] = {
Vector(1,0,0),
Vector(0,1,0),
Vector(0,0,1),
};
Vector vmin[3];
Vector vmax[3];
float minproj[3] = {FLT_MAX, FLT_MAX, FLT_MAX };
float maxproj[3] = {-FLT_MAX, -FLT_MAX, -FLT_MAX };
while(getline(file, line)) {
// we are only interested in the vertices of the model.
// all other information(such as normals) we ignore.
if(line[0] != 'v' || line[1] != ' ')
continue;
vector<string> tokens = Split(line);
if(tokens.size() != 4) {
cerr << "Invalid obj-file: every vertex line must have three integers:" << endl;
cerr << line << endl;
exit(1);
}
Vector pt;
try {
pt.x = stof(tokens[1], NULL);
pt.y = stof(tokens[2], NULL);
pt.z = stof(tokens[3], NULL);
} catch(const invalid_argument& e) {
cerr << "Invalid obj-file: found vertex with invalid numbers:" << endl;
cerr << line << endl;
exit(1);
}
for(int iaxis = 0; iaxis < 3; ++iaxis) {
Vector axis = axes[iaxis];
float proj = Vector::Dot(pt, axis);
if (proj < minproj[iaxis]) {
minproj[iaxis] = proj;
vmin[iaxis] = pt;
}
// Keep track of most distant point along direction vector
if (proj > maxproj[iaxis]) {
maxproj[iaxis] = proj;
vmax[iaxis] = pt;
}
}
}
/*
Output AABB
*/
Vector min(vmin[0].x, vmin[1].y, vmin[2].z);
Vector max(vmax[0].x, vmax[1].y, vmax[2].z);
ofstream outFile(outputFile);
outFile << "max " << max << endl;
outFile << "min " << min << endl;
outFile.close();
}
string StripFileExtension(const string& str) {
size_t last_dot = str.find_last_of(".");
return str.substr(0,last_dot);
}
void PrintHelp() {
printf("Usage:\n");
printf("aabb_create input-file\n\n");
}
vector<string> Split(string str) {
string buffer;
stringstream ss(str);
vector<string> tokens;
while (ss >> buffer)
tokens.push_back(buffer);
return tokens;
}
<|endoftext|> |
<commit_before>/*
*
* TP 1 Técnicas de programación concurrentes I
* Integrantes:
* Bogado, Sebastián
* Martty, Juan
* Pereira, Fernando
*
*/
int main(int argc, char* argv[]) {
// Init Logger (static)
// Parse command line (--cant-surtidores --cant-empleados ¿fifo name?)
// create jefeEstacion child process
// create empleados child process
return 0;
}
<commit_msg>Agrego un main dummy donde esta la utilizacion del Logger<commit_after>/*
*
* TP 1 Técnicas de programación concurrentes I
* Integrantes:
* Bogado, Sebastián
* Martty, Juan
* Pereira, Fernando
*
*/
#include "logger/Logger.h"
const char* logFile = "/home/ferno/ferno/FIUBA/Concurrentes/TP1/log.txt";
int main(int argc, char* argv[]) {
// Init Logger
Logger::initialize(logFile,Logger::LOG_DEBUG);
// Parse command line (--cant-surtidores --cant-empleados ¿--log-filename?)
Logger::log("Se ha parseado la linea de comandos",Logger::LOG_DEBUG);
// Fork&Exev jefeEstacion
Logger::log("Se ha creado el hijo Jefe De Estacion",Logger::LOG_NOTICE);
// Fork&Execv Employees
Logger::log("Se han creado los child process",Logger::LOG_CRITICAL);
Logger::destroy();
return 0;
}
<|endoftext|> |
<commit_before>// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "txdb.h"
#include "main.h"
#include "auxpow.h"
#include "hash.h"
using namespace std;
void static BatchWriteCoins(CLevelDBBatch &batch, const uint256 &hash, const CCoins &coins) {
if (coins.IsPruned())
batch.Erase(make_pair('c', hash));
else
batch.Write(make_pair('c', hash), coins);
}
void static BatchWriteHashBestChain(CLevelDBBatch &batch, const uint256 &hash) {
batch.Write('B', hash);
}
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe) {
}
bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) {
return db.Read(make_pair('c', txid), coins);
}
bool CCoinsViewDB::SetCoins(const uint256 &txid, const CCoins &coins) {
CLevelDBBatch batch;
BatchWriteCoins(batch, txid, coins);
return db.WriteBatch(batch);
}
bool CCoinsViewDB::HaveCoins(const uint256 &txid) {
return db.Exists(make_pair('c', txid));
}
CBlockIndex *CCoinsViewDB::GetBestBlock() {
uint256 hashBestChain;
if (!db.Read('B', hashBestChain))
return NULL;
std::map<uint256, CBlockIndex*>::iterator it = mapBlockIndex.find(hashBestChain);
if (it == mapBlockIndex.end())
return NULL;
return it->second;
}
bool CCoinsViewDB::SetBestBlock(CBlockIndex *pindex) {
CLevelDBBatch batch;
BatchWriteHashBestChain(batch, pindex->GetBlockHash());
return db.WriteBatch(batch);
}
bool CCoinsViewDB::BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex) {
printf("Committing %u changed transactions to coin database...\n", (unsigned int)mapCoins.size());
CLevelDBBatch batch;
for (std::map<uint256, CCoins>::const_iterator it = mapCoins.begin(); it != mapCoins.end(); it++)
BatchWriteCoins(batch, it->first, it->second);
if (pindex)
BatchWriteHashBestChain(batch, pindex->GetBlockHash());
return db.WriteBatch(batch);
}
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CLevelDB(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
}
bool CBlockTreeDB::WriteDiskBlockIndex(const CDiskBlockIndex& diskblockindex)
{
return Write(boost::tuples::make_tuple('b', *diskblockindex.phashBlock, 'a'), diskblockindex);
}
bool CBlockTreeDB::WriteBlockIndex(const CBlockIndex& blockindex)
{
return Write(boost::tuples::make_tuple('b', blockindex.GetBlockHash(), 'b'), blockindex);
}
bool CBlockTreeDB::ReadDiskBlockIndex(const uint256 &blkid, CDiskBlockIndex &diskblockindex) {
return Read(boost::tuples::make_tuple('b', blkid, 'a'), diskblockindex);
}
bool CBlockTreeDB::ReadBestInvalidWork(CBigNum& bnBestInvalidWork)
{
return Read('I', bnBestInvalidWork);
}
bool CBlockTreeDB::WriteBestInvalidWork(const CBigNum& bnBestInvalidWork)
{
return Write('I', bnBestInvalidWork);
}
bool CBlockTreeDB::WriteBlockFileInfo(int nFile, const CBlockFileInfo &info) {
return Write(make_pair('f', nFile), info);
}
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
return Read(make_pair('f', nFile), info);
}
bool CBlockTreeDB::WriteLastBlockFile(int nFile) {
return Write('l', nFile);
}
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
if (fReindexing)
return Write('R', '1');
else
return Erase('R');
}
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
fReindexing = Exists('R');
return true;
}
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
return Read('l', nFile);
}
bool CCoinsViewDB::GetStats(CCoinsStats &stats) {
boost::scoped_ptr<leveldb::Iterator> pcursor(db.NewIterator());
pcursor->SeekToFirst();
CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
stats.hashBlock = GetBestBlock()->GetBlockHash();
ss << stats.hashBlock;
int64 nTotalAmount = 0;
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
try {
leveldb::Slice slKey = pcursor->key();
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION);
char chType;
ssKey >> chType;
if (chType == 'c') {
leveldb::Slice slValue = pcursor->value();
CDataStream ssValue(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
CCoins coins;
ssValue >> coins;
uint256 txhash;
ssKey >> txhash;
ss << txhash;
ss << VARINT(coins.nVersion);
ss << (coins.fCoinBase ? 'c' : 'n');
ss << VARINT(coins.nHeight);
stats.nTransactions++;
for (unsigned int i=0; i<coins.vout.size(); i++) {
const CTxOut &out = coins.vout[i];
if (!out.IsNull()) {
stats.nTransactionOutputs++;
ss << VARINT(i+1);
ss << out;
nTotalAmount += out.nValue;
}
}
stats.nSerializedSize += 32 + slValue.size();
ss << VARINT(0);
}
pcursor->Next();
} catch (std::exception &e) {
return error("%s() : deserialize error", __PRETTY_FUNCTION__);
}
}
delete pcursor;
stats.nHeight = GetBestBlock()->nHeight;
stats.hashSerialized = ss.GetHash();
stats.nTotalAmount = nTotalAmount;
return true;
}
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
return Read(make_pair('t', txid), pos);
}
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
CLevelDBBatch batch;
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
batch.Write(make_pair('t', it->first), it->second);
return WriteBatch(batch);
}
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
return Write(std::make_pair('F', name), fValue ? '1' : '0');
}
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
char ch;
if (!Read(std::make_pair('F', name), ch))
return false;
fValue = ch == '1';
return true;
}
bool CBlockTreeDB::LoadBlockIndexGuts()
{
boost::scoped_ptr<leveldb::Iterator> pcursor(NewIterator());
CDataStream ssKeySet(SER_DISK, CLIENT_VERSION);
ssKeySet << boost::tuples::make_tuple('b', uint256(0), 'a'); // 'b' is the prefix for BlockIndex, 'a' sigifies the first part
uint256 hash;
char cType;
pcursor->Seek(ssKeySet.str());
// Load mapBlockIndex
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
try {
leveldb::Slice slKey = pcursor->key();
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION);
ssKey >> cType;
if (cType == 'b') {
if (slKey.size() < ssKeySet.size()) {
return error("Database key size is %d expected %d, require reindex to upgrade.", slKey.size(), ssKeySet.size());
}
ssKey >> hash;
leveldb::Slice slValue = pcursor->value();
CDataStream ssValue_immutable(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
CDiskBlockIndex diskindex;
ssValue_immutable >> diskindex; // read all immutable data
// Construct immutable parts of block index object
CBlockIndex* pindexNew = InsertBlockIndex(hash);
assert(diskindex.CalcBlockHash() == *pindexNew->phashBlock); // paranoia check
pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev);
pindexNew->nHeight = diskindex.nHeight;
pindexNew->nVersion = diskindex.nVersion;
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
pindexNew->nTime = diskindex.nTime;
pindexNew->nBits = diskindex.nBits;
pindexNew->nNonce = diskindex.nNonce;
pindexNew->nTx = diskindex.nTx;
CTransaction::hashData = true;
if(pindexNew->nHeight >= GetAuxPowStartBlock())
{
CTransaction::hashData = false;
}
// Watch for genesis block
if (pindexGenesisBlock == NULL && pindexNew->GetBlockHash() == hashGenesisBlock)
pindexGenesisBlock = pindexNew;
// CheckIndex needs phashBlock to be set
diskindex.phashBlock = pindexNew->phashBlock;
if (!diskindex.CheckIndex())
return error("LoadBlockIndex() : CheckIndex failed: %s", pindexNew->ToString().c_str());
pcursor->Next(); // now we should be on the 'b' subkey
assert(pcursor->Valid());
slValue = pcursor->value();
CDataStream ssValue_mutable(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
ssValue_mutable >> *pindexNew; // read all mutable data
pcursor->Next();
} else {
break; // if shutdown requested or finished loading block index
}
} catch (std::exception &e) {
return error("%s() : deserialize error", __PRETTY_FUNCTION__);
}
}
return true;
}
<commit_msg>typo caught during compile<commit_after>// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "txdb.h"
#include "main.h"
#include "auxpow.h"
#include "hash.h"
using namespace std;
void static BatchWriteCoins(CLevelDBBatch &batch, const uint256 &hash, const CCoins &coins) {
if (coins.IsPruned())
batch.Erase(make_pair('c', hash));
else
batch.Write(make_pair('c', hash), coins);
}
void static BatchWriteHashBestChain(CLevelDBBatch &batch, const uint256 &hash) {
batch.Write('B', hash);
}
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe) {
}
bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) {
return db.Read(make_pair('c', txid), coins);
}
bool CCoinsViewDB::SetCoins(const uint256 &txid, const CCoins &coins) {
CLevelDBBatch batch;
BatchWriteCoins(batch, txid, coins);
return db.WriteBatch(batch);
}
bool CCoinsViewDB::HaveCoins(const uint256 &txid) {
return db.Exists(make_pair('c', txid));
}
CBlockIndex *CCoinsViewDB::GetBestBlock() {
uint256 hashBestChain;
if (!db.Read('B', hashBestChain))
return NULL;
std::map<uint256, CBlockIndex*>::iterator it = mapBlockIndex.find(hashBestChain);
if (it == mapBlockIndex.end())
return NULL;
return it->second;
}
bool CCoinsViewDB::SetBestBlock(CBlockIndex *pindex) {
CLevelDBBatch batch;
BatchWriteHashBestChain(batch, pindex->GetBlockHash());
return db.WriteBatch(batch);
}
bool CCoinsViewDB::BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex) {
printf("Committing %u changed transactions to coin database...\n", (unsigned int)mapCoins.size());
CLevelDBBatch batch;
for (std::map<uint256, CCoins>::const_iterator it = mapCoins.begin(); it != mapCoins.end(); it++)
BatchWriteCoins(batch, it->first, it->second);
if (pindex)
BatchWriteHashBestChain(batch, pindex->GetBlockHash());
return db.WriteBatch(batch);
}
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CLevelDB(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
}
bool CBlockTreeDB::WriteDiskBlockIndex(const CDiskBlockIndex& diskblockindex)
{
return Write(boost::tuples::make_tuple('b', *diskblockindex.phashBlock, 'a'), diskblockindex);
}
bool CBlockTreeDB::WriteBlockIndex(const CBlockIndex& blockindex)
{
return Write(boost::tuples::make_tuple('b', blockindex.GetBlockHash(), 'b'), blockindex);
}
bool CBlockTreeDB::ReadDiskBlockIndex(const uint256 &blkid, CDiskBlockIndex &diskblockindex) {
return Read(boost::tuples::make_tuple('b', blkid, 'a'), diskblockindex);
}
bool CBlockTreeDB::ReadBestInvalidWork(CBigNum& bnBestInvalidWork)
{
return Read('I', bnBestInvalidWork);
}
bool CBlockTreeDB::WriteBestInvalidWork(const CBigNum& bnBestInvalidWork)
{
return Write('I', bnBestInvalidWork);
}
bool CBlockTreeDB::WriteBlockFileInfo(int nFile, const CBlockFileInfo &info) {
return Write(make_pair('f', nFile), info);
}
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
return Read(make_pair('f', nFile), info);
}
bool CBlockTreeDB::WriteLastBlockFile(int nFile) {
return Write('l', nFile);
}
bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
if (fReindexing)
return Write('R', '1');
else
return Erase('R');
}
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
fReindexing = Exists('R');
return true;
}
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
return Read('l', nFile);
}
bool CCoinsViewDB::GetStats(CCoinsStats &stats) {
boost::scoped_ptr<leveldb::Iterator> pcursor(db.NewIterator());
pcursor->SeekToFirst();
CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
stats.hashBlock = GetBestBlock()->GetBlockHash();
ss << stats.hashBlock;
int64 nTotalAmount = 0;
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
try {
leveldb::Slice slKey = pcursor->key();
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION);
char chType;
ssKey >> chType;
if (chType == 'c') {
leveldb::Slice slValue = pcursor->value();
CDataStream ssValue(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
CCoins coins;
ssValue >> coins;
uint256 txhash;
ssKey >> txhash;
ss << txhash;
ss << VARINT(coins.nVersion);
ss << (coins.fCoinBase ? 'c' : 'n');
ss << VARINT(coins.nHeight);
stats.nTransactions++;
for (unsigned int i=0; i<coins.vout.size(); i++) {
const CTxOut &out = coins.vout[i];
if (!out.IsNull()) {
stats.nTransactionOutputs++;
ss << VARINT(i+1);
ss << out;
nTotalAmount += out.nValue;
}
}
stats.nSerializedSize += 32 + slValue.size();
ss << VARINT(0);
}
pcursor->Next();
} catch (std::exception &e) {
return error("%s() : deserialize error", __PRETTY_FUNCTION__);
}
stats.nHeight = GetBestBlock()->nHeight;
stats.hashSerialized = ss.GetHash();
stats.nTotalAmount = nTotalAmount;
return true;
}
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
return Read(make_pair('t', txid), pos);
}
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
CLevelDBBatch batch;
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
batch.Write(make_pair('t', it->first), it->second);
return WriteBatch(batch);
}
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
return Write(std::make_pair('F', name), fValue ? '1' : '0');
}
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
char ch;
if (!Read(std::make_pair('F', name), ch))
return false;
fValue = ch == '1';
return true;
}
bool CBlockTreeDB::LoadBlockIndexGuts()
{
boost::scoped_ptr<leveldb::Iterator> pcursor(NewIterator());
CDataStream ssKeySet(SER_DISK, CLIENT_VERSION);
ssKeySet << boost::tuples::make_tuple('b', uint256(0), 'a'); // 'b' is the prefix for BlockIndex, 'a' sigifies the first part
uint256 hash;
char cType;
pcursor->Seek(ssKeySet.str());
// Load mapBlockIndex
while (pcursor->Valid()) {
boost::this_thread::interruption_point();
try {
leveldb::Slice slKey = pcursor->key();
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION);
ssKey >> cType;
if (cType == 'b') {
if (slKey.size() < ssKeySet.size()) {
return error("Database key size is %d expected %d, require reindex to upgrade.", slKey.size(), ssKeySet.size());
}
ssKey >> hash;
leveldb::Slice slValue = pcursor->value();
CDataStream ssValue_immutable(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
CDiskBlockIndex diskindex;
ssValue_immutable >> diskindex; // read all immutable data
// Construct immutable parts of block index object
CBlockIndex* pindexNew = InsertBlockIndex(hash);
assert(diskindex.CalcBlockHash() == *pindexNew->phashBlock); // paranoia check
pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev);
pindexNew->nHeight = diskindex.nHeight;
pindexNew->nVersion = diskindex.nVersion;
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
pindexNew->nTime = diskindex.nTime;
pindexNew->nBits = diskindex.nBits;
pindexNew->nNonce = diskindex.nNonce;
pindexNew->nTx = diskindex.nTx;
CTransaction::hashData = true;
if(pindexNew->nHeight >= GetAuxPowStartBlock())
{
CTransaction::hashData = false;
}
// Watch for genesis block
if (pindexGenesisBlock == NULL && pindexNew->GetBlockHash() == hashGenesisBlock)
pindexGenesisBlock = pindexNew;
// CheckIndex needs phashBlock to be set
diskindex.phashBlock = pindexNew->phashBlock;
if (!diskindex.CheckIndex())
return error("LoadBlockIndex() : CheckIndex failed: %s", pindexNew->ToString().c_str());
pcursor->Next(); // now we should be on the 'b' subkey
assert(pcursor->Valid());
slValue = pcursor->value();
CDataStream ssValue_mutable(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION);
ssValue_mutable >> *pindexNew; // read all mutable data
pcursor->Next();
} else {
break; // if shutdown requested or finished loading block index
}
} catch (std::exception &e) {
return error("%s() : deserialize error", __PRETTY_FUNCTION__);
}
}
return true;
}
<|endoftext|> |
<commit_before>#include <fstream>
#include <regex>
#include <string>
#include <sstream>
#include <boost/program_options/cmdline.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/variant/get.hpp>
#include <llvm/Bitcode/ReaderWriter.h>
#include <llvm/IR/IRBuilder.h>
#include "llvm/IR/LLVMContext.h"
#include <llvm/IR/Module.h>
#include <llvm/Support/raw_ostream.h>
#include "parser.h"
#include "codegen.h"
using namespace marklar;
using namespace parser;
using namespace llvm;
using namespace std;
namespace po = boost::program_options;
bool generateOutput(const string& inputFilename, const string& outputBitCodeName) {
ifstream in(inputFilename.c_str());
const string fileContents(static_cast<stringstream const&>(stringstream() << in.rdbuf()).str());
// Parse the source file
cout << "Parsing..." << endl;
base_expr_node rootAst;
if (!parse(fileContents, rootAst)) {
cerr << "Failed to parse source file!" << endl;
return false;
}
// Generate the code
cout << "Generating code..." << endl;
LLVMContext &context = getGlobalContext();
unique_ptr<Module> module(new Module("", context));
IRBuilder<> builder(getGlobalContext());
ast_codegen codeGenerator(module.get(), builder);
// Generate code for each expression at the root level
const base_expr* expr = boost::get<base_expr>(&rootAst);
for (auto& itr : expr->children) {
boost::apply_visitor(codeGenerator, itr);
}
// Perform an LLVM verify as a sanity check
string errorInfo;
raw_string_ostream errorOut(errorInfo);
if (verifyModule(*module, &errorOut)) {
cerr << "Failed to generate LLVM IR: " << errorInfo << endl;
module->print(errorOut, nullptr);
cerr << "Module:" << endl << errorInfo << endl;
return false;
}
// Dump the LLVM IR to a file
llvm::raw_fd_ostream outStream(outputBitCodeName.c_str(), errorInfo, llvm::sys::fs::F_Binary);
llvm::WriteBitcodeToFile(module.get(), outStream);
return true;
}
bool optimizeAndLink(const string& bitCodeFilename, const string& exeName = "") {
// Optimize the generated bitcode with LLVM 'opt'
{
cout << "Optimizing..." << endl;
}
// Transform the bitcode into an object file with LLVM 'llc'
{
cout << "Linking..." << endl;
const string tmpObjName = "output.o";
const string llcCmd = "llc-3.5 -filetype=obj output.bc -o " + tmpObjName;
const int retval = system(llcCmd.c_str());
if (retval != 0) {
cerr << "Error running 'llc'" << endl;
return false;
}
}
// Leverage gcc here to link the object file into the final executable
// this is mainly to bypass the more complicated options that the system 'ld' needs
{
const string outputExeName = (exeName.empty() ? "a.out" : exeName);
const string gccCmd = "gcc -o " + outputExeName + " output.o";
const int retval = system(gccCmd.c_str());
if (retval != 0) {
cerr << "Error running 'gcc': \"" << gccCmd << "\"" << " -- returned: " << retval << endl;
return false;
}
}
return true;
}
int main(int argc, char** argv) {
// Build the supported options
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("input-file,i", po::value<string>(), "input file")
("output-file,o", po::value<string>(), "output file")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help") > 0) {
cout << desc << endl;
return 1;
}
if (vm.count("input-file") > 0) {
const string inputFilename = vm["input-file"].as<string>();
const string tmpBitCodeFile = "output.bc";
string outputFilename = "a.out";
if (vm.count("output-file") > 0) {
outputFilename = vm["output-file"].as<string>();
}
if (!generateOutput(inputFilename, tmpBitCodeFile)) {
return 2;
}
if (!optimizeAndLink(tmpBitCodeFile, outputFilename)) {
return 3;
}
}
cout << "Executable complete!" << endl;
return 0;
}
<commit_msg>Added llvm bitcode optimizations to the main driver<commit_after>#include <fstream>
#include <regex>
#include <string>
#include <sstream>
#include <boost/program_options/cmdline.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/variant/get.hpp>
#include <llvm/Bitcode/ReaderWriter.h>
#include <llvm/IR/IRBuilder.h>
#include "llvm/IR/LLVMContext.h"
#include <llvm/IR/Module.h>
#include <llvm/Support/raw_ostream.h>
#include "parser.h"
#include "codegen.h"
using namespace marklar;
using namespace parser;
using namespace llvm;
using namespace std;
namespace po = boost::program_options;
bool generateOutput(const string& inputFilename, const string& outputBitCodeName) {
ifstream in(inputFilename.c_str());
const string fileContents(static_cast<stringstream const&>(stringstream() << in.rdbuf()).str());
// Parse the source file
cout << "Parsing..." << endl;
base_expr_node rootAst;
if (!parse(fileContents, rootAst)) {
cerr << "Failed to parse source file!" << endl;
return false;
}
// Generate the code
cout << "Generating code..." << endl;
LLVMContext &context = getGlobalContext();
unique_ptr<Module> module(new Module("", context));
IRBuilder<> builder(getGlobalContext());
ast_codegen codeGenerator(module.get(), builder);
// Generate code for each expression at the root level
const base_expr* expr = boost::get<base_expr>(&rootAst);
for (auto& itr : expr->children) {
boost::apply_visitor(codeGenerator, itr);
}
// Perform an LLVM verify as a sanity check
string errorInfo;
raw_string_ostream errorOut(errorInfo);
if (verifyModule(*module, &errorOut)) {
cerr << "Failed to generate LLVM IR: " << errorInfo << endl;
module->print(errorOut, nullptr);
cerr << "Module:" << endl << errorInfo << endl;
return false;
}
// Dump the LLVM IR to a file
llvm::raw_fd_ostream outStream(outputBitCodeName.c_str(), errorInfo, llvm::sys::fs::F_Binary);
llvm::WriteBitcodeToFile(module.get(), outStream);
return true;
}
bool optimizeAndLink(const string& bitCodeFilename, const string& exeName = "") {
const string tmpOptBCName = "output_opt.bc";
const string tmpObjName = "output.o";
// Optimize the generated bitcode with LLVM 'opt', produces an optimized bitcode file
{
cout << "Optimizing..." << endl;
const string optCmd = "opt-3.5 -filetype=obj -o " + tmpOptBCName + " output.bc";
const int retval = system(optCmd.c_str());
if (retval != 0) {
cerr << "Error running 'opt': \"" << optCmd << "\"" << endl;
return false;
}
}
// Transform the bitcode into an object file with LLVM 'llc'
{
cout << "Linking..." << endl;
const string llcCmd = "llc-3.5 -filetype=obj -o " + tmpObjName + " " + tmpOptBCName;
const int retval = system(llcCmd.c_str());
if (retval != 0) {
cerr << "Error running 'llc': \"" << llcCmd << "\"" << endl;
return false;
}
}
// Leverage gcc here to link the object file into the final executable
// this is mainly to bypass the more complicated options that the system 'ld' needs
{
const string outputExeName = (exeName.empty() ? "a.out" : exeName);
const string gccCmd = "gcc -o " + outputExeName + " " + tmpObjName;
const int retval = system(gccCmd.c_str());
if (retval != 0) {
cerr << "Error running 'gcc': \"" << gccCmd << "\"" << " -- returned: " << retval << endl;
return false;
}
}
return true;
}
int main(int argc, char** argv) {
// Build the supported options
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("input-file,i", po::value<string>(), "input file")
("output-file,o", po::value<string>(), "output file")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help") > 0) {
cout << desc << endl;
return 1;
}
if (vm.count("input-file") > 0) {
const string inputFilename = vm["input-file"].as<string>();
const string tmpBitCodeFile = "output.bc";
string outputFilename = "a.out";
if (vm.count("output-file") > 0) {
outputFilename = vm["output-file"].as<string>();
}
if (!generateOutput(inputFilename, tmpBitCodeFile)) {
return 2;
}
if (!optimizeAndLink(tmpBitCodeFile, outputFilename)) {
return 3;
}
}
cout << "Executable complete!" << endl;
return 0;
}
<|endoftext|> |
<commit_before>#include "shell-readline.hpp"
#include "shell_bison.hh"
#include "command.hpp"
extern FILE * yyin;
extern FILE * yyout;
extern int yylex();
extern int yyparse();
extern void yyrestart (FILE * in);
extern void yyerror(const char * s);
extern read_line reader;
int main()
{
bool is_interactive = false;
Command::currentCommand.set_interactive((is_interactive = isatty(0)));
std::string expanded_home = tilde_expand("~/.yashrc");
char * rcfile = strndup(expanded_home.c_str(), expanded_home.size());
yyin = fopen(rcfile, "r"); free(rcfile);
/* From Brian P. Hays */
if (yyin != NULL) {
Command::currentCommand.printPrompt = false;
yyparse();
fclose(yyin);
yyin = stdin;
yyrestart(yyin);
Command::currentCommand.printPrompt = true;
}
if (is_interactive) {
/* loop until we are in the foreground */
for (; tcgetpgrp(STDIN_FILENO) != (Command::currentCommand.m_pgid = getpgrp());) {
kill(- Command::currentCommand.m_pgid, SIGTTIN);
}
/* Ignore interactive and job-control signals */
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
/* go to our process group */
pid_t shell_pgid = getpid();
Command::currentCommand.m_pgid = shell_pgid;
if (setpgid(shell_pgid, shell_pgid) < 0) {
perror("setpgid");
std::cerr<<"pgid: "<<shell_pgid<<std::endl;
/* exit(1); */
}
}
Command::currentCommand.prompt();
yyparse();
return 0;
}
<commit_msg>Uh -- ok. I'm not sure about anything anymore.<commit_after>#include "shell-readline.hpp"
#include "shell_bison.hh"
#include "command.hpp"
extern FILE * yyin;
extern FILE * yyout;
extern int yylex();
extern int yyparse();
extern void yyrestart (FILE * in);
extern void yyerror(const char * s);
extern read_line reader;
int main()
{
bool is_interactive = false;
Command::currentCommand.set_interactive((is_interactive = isatty(0)));
std::string expanded_home = tilde_expand("~/.yashrc");
char * rcfile = strndup(expanded_home.c_str(), expanded_home.size());
yyin = fopen(rcfile, "r"); free(rcfile);
/* From Brian P. Hays */
if (yyin != NULL) {
Command::currentCommand.printPrompt = false;
yyparse();
fclose(yyin);
yyin = stdin;
yyrestart(yyin);
Command::currentCommand.printPrompt = true;
}
if (is_interactive) {
/* loop until we are in the foreground */
for (; tcgetpgrp(STDIN_FILENO) != (Command::currentCommand.m_pgid = getpgrp());) {
kill(- Command::currentCommand.m_pgid, SIGTTIN);
}
/* go to our process group */
pid_t shell_pgid = getpid();
if ((getpgrp() != getpid()) && (setpgid(shell_pgid, shell_pgid) < 0)) {
perror("setpgid");
std::cerr<<"pgid: "<<getpgrp()<<std::endl;
std::cerr<<"pid: "<<getpid()<<std::endl;
/* exit(1); */
}
Command::currentCommand.m_pgid = shell_pgid;
/* Ignore interactive and job-control signals */
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
}
Command::currentCommand.prompt();
yyparse();
return 0;
}
<|endoftext|> |
<commit_before>#include "../ui/mainwindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
#ifdef Q_OS_LINUX
QCoreApplication::addLibraryPath("/usr/lib/viqo");
#endif
QApplication a(argc, argv);
QCoreApplication::setApplicationName("Viqo");
QCoreApplication::setApplicationVersion("2.0");
QCommandLineParser parser;
parser.setApplicationDescription(
QStringLiteral("Qt で作成されたマルチプラットフォームコメントビューワです"));
parser.addHelpOption();
parser.addVersionOption();
// Process the actual command line arguments given by the user
parser.process(a);
MainWindow w;
w.show();
return a.exec();
}
<commit_msg>update version info to 2.1<commit_after>#include "../ui/mainwindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
#ifdef Q_OS_LINUX
QCoreApplication::addLibraryPath("/usr/lib/viqo");
#endif
QApplication a(argc, argv);
QCoreApplication::setApplicationName("Viqo");
QCoreApplication::setApplicationVersion("2.1");
QCommandLineParser parser;
parser.setApplicationDescription(
QStringLiteral("Qt で作成されたマルチプラットフォームコメントビューワです"));
parser.addHelpOption();
parser.addVersionOption();
// Process the actual command line arguments given by the user
parser.process(a);
MainWindow w;
w.show();
return a.exec();
}
<|endoftext|> |
<commit_before>#include <tr1/memory>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <signal.h>
#include <getopt.h>
#include "barrier.h"
#include "stream.h"
#include "socket.h"
#include <unistd.h>
using std::vector;
using std::tr1::shared_ptr;
static bool run = true;
static void terminate(void)
{
run = false;
}
int main(int argc, char** argv)
{
unsigned num_conns = 1;
unsigned remote_port = 0;
unsigned local_port = 0;
unsigned interval = 0;
unsigned length = 0;
// Parse program arguments and options
int opt;
while ((opt = getopt(argc, argv, ":hc:p:q:n:i:")) != -1) {
char* ptr;
switch (opt) {
// Missing a value for the option
case ':':
fprintf(stderr, "Option %s requires a value\n", argv[optind-1]);
return ':';
// Unknown option was given
case '?':
fprintf(stderr, "Ignoring unknown option '%c'\n", optopt);
break;
// Print program usage and quit
case 'h':
// TODO: Give usage
return 'h';
// Set number of connections
case 'c':
ptr = NULL;
if ((num_conns = strtoul(optarg, &ptr, 0)) > 1024 || num_conns < 1 || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -c requires a valid number of connections [1-1024]\n");
return 'c';
}
break;
// Set the remote starting port
case 'p':
ptr = NULL;
if ((remote_port = strtoul(optarg, &ptr, 0)) > 0xffff || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -p requires a valid port number [0-65535]\n");
return 'p';
}
break;
// Set the local starting port
case 'q':
ptr = NULL;
if ((local_port = strtoul(optarg, &ptr, 0)) > 0xffff || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -q requires a valid port number [0-65535]\n");
return 'p';
}
break;
// Set the size of the byte chunk to be sent
case 'n':
ptr = NULL;
if ((length = strtoul(optarg, &ptr, 0)) > BUFFER_SIZE || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -n requires a chunk size in bytes [1-%d] or 0 for off\n", BUFFER_SIZE);
return 'n';
}
break;
// Set the interval between each time a chunk is sent
case 'i':
ptr = NULL;
if ((interval = strtoul(optarg, &ptr, 0)) > 0xffff || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -i requires an interval in milliseconds [1-65535] or 0 for off\n");
return 'i';
}
break;
}
}
// Check if all mandatory options were set
if (optind < argc && remote_port == 0) {
fprintf(stderr, "Option -p is required for client\n");
return 'p';
} else if (optind == argc && local_port == 0) {
fprintf(stderr, "Option -q is required for server\n");
return 'q';
}
// Handle interrupt signal
signal(SIGINT, (void (*)(int)) &terminate);
// Create a barrier
Barrier barrier(num_conns + 1);
// Start connections
vector<shared_ptr<Stream> > conns;
for (unsigned i = 0; i < num_conns; ++i) {
if (optind < argc) {
Client* client = new Client(barrier, argv[optind], remote_port);
if (local_port > 0) {
client->bind(local_port + i);
}
conns.push_back(shared_ptr<Stream>( static_cast<Stream*>(client) ));
} else {
conns.push_back(shared_ptr<Stream>( new Server(barrier, local_port + i) ));
}
}
// Synchronize with connections
barrier.wait();
// Run until completion
while (run);
return 0;
}
<commit_msg>forgot call to start<commit_after>#include <tr1/memory>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <signal.h>
#include <getopt.h>
#include "barrier.h"
#include "stream.h"
#include "socket.h"
#include <unistd.h>
using std::vector;
using std::tr1::shared_ptr;
static bool run = true;
static void terminate(void)
{
run = false;
}
int main(int argc, char** argv)
{
unsigned num_conns = 1;
unsigned remote_port = 0;
unsigned local_port = 0;
unsigned interval = 0;
unsigned length = 0;
// Parse program arguments and options
int opt;
while ((opt = getopt(argc, argv, ":hc:p:q:n:i:")) != -1) {
char* ptr;
switch (opt) {
// Missing a value for the option
case ':':
fprintf(stderr, "Option %s requires a value\n", argv[optind-1]);
return ':';
// Unknown option was given
case '?':
fprintf(stderr, "Ignoring unknown option '%c'\n", optopt);
break;
// Print program usage and quit
case 'h':
// TODO: Give usage
return 'h';
// Set number of connections
case 'c':
ptr = NULL;
if ((num_conns = strtoul(optarg, &ptr, 0)) > 1024 || num_conns < 1 || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -c requires a valid number of connections [1-1024]\n");
return 'c';
}
break;
// Set the remote starting port
case 'p':
ptr = NULL;
if ((remote_port = strtoul(optarg, &ptr, 0)) > 0xffff || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -p requires a valid port number [0-65535]\n");
return 'p';
}
break;
// Set the local starting port
case 'q':
ptr = NULL;
if ((local_port = strtoul(optarg, &ptr, 0)) > 0xffff || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -q requires a valid port number [0-65535]\n");
return 'p';
}
break;
// Set the size of the byte chunk to be sent
case 'n':
ptr = NULL;
if ((length = strtoul(optarg, &ptr, 0)) > BUFFER_SIZE || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -n requires a chunk size in bytes [1-%d] or 0 for off\n", BUFFER_SIZE);
return 'n';
}
break;
// Set the interval between each time a chunk is sent
case 'i':
ptr = NULL;
if ((interval = strtoul(optarg, &ptr, 0)) > 0xffff || ptr == NULL || *ptr != '\0') {
fprintf(stderr, "Option -i requires an interval in milliseconds [1-65535] or 0 for off\n");
return 'i';
}
break;
}
}
// Check if all mandatory options were set
if (optind < argc && remote_port == 0) {
fprintf(stderr, "Option -p is required for client\n");
return 'p';
} else if (optind == argc && local_port == 0) {
fprintf(stderr, "Option -q is required for server\n");
return 'q';
}
// Handle interrupt signal
signal(SIGINT, (void (*)(int)) &terminate);
// Create a barrier
Barrier barrier(num_conns + 1);
vector<shared_ptr<Stream> > conns;
// Start connections
fprintf(stderr, "Starting %u connections...\n", num_conns);
for (unsigned i = 0; i < num_conns; ++i) {
if (optind < argc) {
Client* client = new Client(barrier, argv[optind], remote_port);
if (local_port > 0) {
client->bind(local_port + i);
}
client->start();
conns.push_back(shared_ptr<Stream>( static_cast<Stream*>(client) ));
} else {
Server* server = new Server(barrier, local_port + i);
server->start();
conns.push_back(shared_ptr<Stream>( static_cast<Stream*>(server) ));
}
}
// Synchronize with connections
barrier.wait();
// TODO: Count number of established connections
// Run until completion
while (run);
return 0;
}
<|endoftext|> |
<commit_before>#include <time.h>
#include "../include/PSATsolver.hpp"
#include "../include/TestGenerator.hpp"
using namespace std;
using namespace arma;
void test(int N, int k, int n, double step, int begin, int end, string prefix);
int main(int argc, char** argv)
{
bool v;
if(argc < 20)
v = true;
else
v = false;
if (argc < 2)
{
std::cout << "I need a input file " << "\n";
return -1;
}
if((string) argv[1] == "--maketest")
{
TestGenerator t(atoi(argv[2]));
t.createAll(atoi(argv[3]),
atoi(argv[4]),
atoi(argv[5]),
atof(argv[6]),
atoi(argv[7]),
atoi(argv[8]),
argv[9]);
return 1;
}
if((string) argv[1] == "--test")
{
test(atoi(argv[2]),
atoi(argv[3]),
atoi(argv[4]),
atof(argv[5]),
atoi(argv[6]),
atoi(argv[7]),
argv[8]);
return 1;
}
int** matrix;
int**& M = matrix;
vector<double> pi;
double time;
PSATsolver::solve(M, pi, &time, argv[1], true);
return 1;
}
void test(int N, int k, int n, double step,
int begin, int end, string prefix)
{
int** matrix;
int**& M = matrix;
vector<double> pi;
ofstream outtime;
ofstream outsat;
outtime.open("./data/time.txt");
outsat.open("./data/sat.txt");
for(double i = begin; i <= end; i+=step)
{
double y = 0;
double sat = 0;
for(int j = 0; j < N; j++)
{
double time = 0;
int m = round(n*i);
string file = prefix;
file += "_K" + to_string(k)
+ "_N" + to_string(n)
+ "_M" + to_string(m)
+ "_" + to_string(j)
+ ".pcnf";
cout << file << ": ";
PSATsolver::solve(M, pi, &time,
(char*) file.c_str(), false);
if (pi[0] == 1)
{
sat += 1.0/N;
cout << "sat, time: ";
}
else cout << "unsat, time: ";
cout << time << "\n";
y += time/N;
}
outtime << i << " " << y << "\n";
outsat << i << " " << sat << "\n";
cout <<"media tempo: "<< y << "\n";
cout <<"media sat: " << sat << "\n";
}
outtime.close();
outsat.close();
}
<commit_msg>A more stable version<commit_after>#include <time.h>
#include "../include/PSATsolver.hpp"
#include "../include/TestGenerator.hpp"
using namespace std;
using namespace arma;
void test(int N, int k, int n, double step, int begin, int end, string prefix);
int main(int argc, char** argv)
{
bool v;
if(argc < 20)
v = true;
else
v = false;
if (argc < 2)
{
std::cout << "I need a input file " << "\n";
return -1;
}
if((string) argv[1] == "--maketest")
{
TestGenerator t(atoi(argv[2]));
t.createAll(atoi(argv[3]),
atoi(argv[4]),
atoi(argv[5]),
atof(argv[6]),
atoi(argv[7]),
atoi(argv[8]),
argv[9]);
return 1;
}
if((string) argv[1] == "--test")
{
test(atoi(argv[2]),
atoi(argv[3]),
atoi(argv[4]),
atof(argv[5]),
atoi(argv[6]),
atoi(argv[7]),
argv[8]);
return 1;
}
int** matrix;
int**& M = matrix;
vector<double> pi;
double time;
PSATsolver::solve(M, pi, &time, argv[1], true);
return 1;
}
void test(int N, int k, int n, double step,
int begin, int end, string prefix)
{
int** matrix;
int**& M = matrix;
vector<double> pi;
ofstream outtime;
ofstream outsat;
for(double i = begin; i <= end; i+=step)
{
outtime.open("./data/time" + to_string((int) (i*10)) + ".txt");
outsat.open("./data/sat" + to_string((int) (i*10)) + ".txt");
double y = 0;
double sat = 0;
for(int j = 0; j < N; j++)
{
double time = 0;
int m = round(n*i);
string file = prefix;
file += "_K" + to_string(k)
+ "_N" + to_string(n)
+ "_M" + to_string(m)
+ "_" + to_string(j)
+ ".pcnf";
cout << file << ": ";
PSATsolver::solve(M, pi, &time,
(char*) file.c_str(), false);
if (pi[0] == 1)
{
sat += 1.0/N;
cout << "sat, time: ";
}
else cout << "unsat, time: ";
cout << time << "\n";
y += time/N;
}
outtime << i << " " << y << "\n";
outsat << i << " " << sat << "\n";
cout <<
cout <<"media tempo: "<< y << "\n";
cout <<"media sat: " << sat << "\n";
outtime.close();
outsat.close();
}
}
<|endoftext|> |
<commit_before>/*
* Copyright (C) 2004-2014 ZNC, see the NOTICE file for details.
*
* 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.
*/
#include <znc/znc.h>
#include <signal.h>
using std::cout;
using std::endl;
using std::set;
#ifdef HAVE_GETOPT_LONG
#include <getopt.h>
#else
#define no_argument 0
#define required_argument 1
#define optional_argument 2
struct option {
const char *a;
int opt;
int *flag;
int val;
};
static inline int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *, int *)
{
return getopt(argc, argv, optstring);
}
#endif
static const struct option g_LongOpts[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ "debug", no_argument, 0, 'D' },
{ "foreground", no_argument, 0, 'f' },
{ "no-color", no_argument, 0, 'n' },
{ "allow-root", no_argument, 0, 'r' },
{ "makeconf", no_argument, 0, 'c' },
{ "makepass", no_argument, 0, 's' },
{ "makepem", no_argument, 0, 'p' },
{ "datadir", required_argument, 0, 'd' },
{ 0, 0, 0, 0 }
};
static void GenerateHelp(const char *appname) {
CUtils::PrintMessage("USAGE: " + CString(appname) + " [options]");
CUtils::PrintMessage("Options are:");
CUtils::PrintMessage("\t-h, --help List available command line options (this page)");
CUtils::PrintMessage("\t-v, --version Output version information and exit");
CUtils::PrintMessage("\t-f, --foreground Don't fork into the background");
CUtils::PrintMessage("\t-D, --debug Output debugging information (Implies -f)");
CUtils::PrintMessage("\t-n, --no-color Don't use escape sequences in the output");
CUtils::PrintMessage("\t-r, --allow-root Don't complain if ZNC is run as root");
CUtils::PrintMessage("\t-c, --makeconf Interactively create a new config");
CUtils::PrintMessage("\t-s, --makepass Generates a password for use in config");
#ifdef HAVE_LIBSSL
CUtils::PrintMessage("\t-p, --makepem Generates a pemfile for use with SSL");
#endif /* HAVE_LIBSSL */
CUtils::PrintMessage("\t-d, --datadir Set a different ZNC repository (default is ~/.znc)");
}
static void die(int sig) {
signal(SIGPIPE, SIG_DFL);
CUtils::PrintMessage("Exiting on SIG [" + CString(sig) + "]");
CZNC::DestroyInstance();
exit(sig);
}
static void signalHandler(int sig) {
switch (sig) {
case SIGHUP:
CUtils::PrintMessage("Caught SIGHUP");
CZNC::Get().SetConfigState(CZNC::ECONFIG_NEED_REHASH);
break;
case SIGUSR1:
CUtils::PrintMessage("Caught SIGUSR1");
CZNC::Get().SetConfigState(CZNC::ECONFIG_NEED_WRITE);
break;
default:
CUtils::PrintMessage("WTF? Signal handler called for a signal it doesn't know?");
}
}
static bool isRoot() {
// User root? If one of these were root, we could switch the others to root, too
return (geteuid() == 0 || getuid() == 0);
}
static void seedPRNG() {
struct timeval tv;
unsigned int seed;
// Try to find a seed which can't be as easily guessed as only time()
if (gettimeofday(&tv, NULL) == 0) {
seed = (unsigned int)tv.tv_sec;
// This is in [0:1e6], which means that roughly 20 bits are
// actually used, let's try to shuffle the high bits.
seed ^= uint32_t((tv.tv_usec << 10) | tv.tv_usec);
} else
seed = (unsigned int)time(NULL);
seed ^= rand();
seed ^= getpid();
srand(seed);
}
int main(int argc, char** argv) {
CString sConfig;
CString sDataDir = "";
seedPRNG();
CDebug::SetStdoutIsTTY(isatty(1));
int iArg, iOptIndex = -1;
bool bMakeConf = false;
bool bMakePass = false;
bool bAllowRoot = false;
bool bForeground = false;
#ifdef ALWAYS_RUN_IN_FOREGROUND
bForeground = true;
#endif
#ifdef HAVE_LIBSSL
bool bMakePem = false;
#endif
while ((iArg = getopt_long(argc, argv, "hvnrcspd:Df", g_LongOpts, &iOptIndex)) != -1) {
switch (iArg) {
case 'h':
GenerateHelp(argv[0]);
return 0;
case 'v':
cout << CZNC::GetTag() << endl;
cout << CZNC::GetCompileOptionsString() << endl;
return 0;
case 'n':
CDebug::SetStdoutIsTTY(false);
break;
case 'r':
bAllowRoot = true;
break;
case 'c':
bMakeConf = true;
break;
case 's':
bMakePass = true;
break;
case 'p':
#ifdef HAVE_LIBSSL
bMakePem = true;
break;
#else
CUtils::PrintError("ZNC is compiled without SSL support.");
return 1;
#endif /* HAVE_LIBSSL */
case 'd':
sDataDir = CString(optarg);
break;
case 'f':
bForeground = true;
break;
case 'D':
bForeground = true;
CDebug::SetDebug(true);
break;
case '?':
default:
GenerateHelp(argv[0]);
return 1;
}
}
if (optind < argc) {
CUtils::PrintError("Specifying a config file as an argument isn't supported anymore.");
CUtils::PrintError("Use --datadir instead.");
return 1;
}
CZNC::CreateInstance();
CZNC* pZNC = &CZNC::Get();
pZNC->InitDirs(((argc) ? argv[0] : ""), sDataDir);
#ifdef HAVE_LIBSSL
if (bMakePem) {
pZNC->WritePemFile();
CZNC::DestroyInstance();
return 0;
}
#endif /* HAVE_LIBSSL */
if (bMakePass) {
CString sSalt;
CUtils::PrintMessage("Type your new password.");
CString sHash = CUtils::GetSaltedHashPass(sSalt);
CUtils::PrintMessage("Kill ZNC process, if it's running.");
CUtils::PrintMessage("Then replace password in the <User> section of your config with this:");
// Not PrintMessage(), to remove [**] from the beginning, to ease copypasting
std::cout << "<Pass password>" << std::endl;
std::cout << "\tMethod = " << CUtils::sDefaultHash << std::endl;
std::cout << "\tHash = " << sHash << std::endl;
std::cout << "\tSalt = " << sSalt << std::endl;
std::cout << "</Pass>" << std::endl;
CUtils::PrintMessage("After that start ZNC again, and you should be able to login with the new password.");
CZNC::DestroyInstance();
return 0;
}
{
set<CModInfo> ssGlobalMods;
set<CModInfo> ssUserMods;
set<CModInfo> ssNetworkMods;
CUtils::PrintAction("Checking for list of available modules");
pZNC->GetModules().GetAvailableMods(ssGlobalMods, CModInfo::GlobalModule);
pZNC->GetModules().GetAvailableMods(ssUserMods, CModInfo::UserModule);
pZNC->GetModules().GetAvailableMods(ssNetworkMods, CModInfo::NetworkModule);
if (ssGlobalMods.empty() && ssUserMods.empty() && ssNetworkMods.empty()) {
CUtils::PrintStatus(false, "");
CUtils::PrintError("No modules found. Perhaps you didn't install ZNC properly?");
CUtils::PrintError("Read http://wiki.znc.in/Installation for instructions.");
if (!CUtils::GetBoolInput("Do you really want to run ZNC without any modules?", false)) {
CZNC::DestroyInstance();
return 1;
}
}
CUtils::PrintStatus(true, "");
}
if (isRoot()) {
CUtils::PrintError("You are running ZNC as root! Don't do that! There are not many valid");
CUtils::PrintError("reasons for this and it can, in theory, cause great damage!");
if (!bAllowRoot) {
CZNC::DestroyInstance();
return 1;
}
CUtils::PrintError("You have been warned.");
CUtils::PrintError("Hit CTRL+C now if you don't want to run ZNC as root.");
CUtils::PrintError("ZNC will start in 30 seconds.");
sleep(30);
}
if (bMakeConf) {
if (!pZNC->WriteNewConfig(sConfig)) {
CZNC::DestroyInstance();
return 0;
}
/* Fall through to normal bootup */
}
CString sConfigError;
if (!pZNC->ParseConfig(sConfig, sConfigError)) {
CUtils::PrintError("Unrecoverable config error.");
CZNC::DestroyInstance();
return 1;
}
if (!pZNC->OnBoot()) {
CUtils::PrintError("Exiting due to module boot errors.");
CZNC::DestroyInstance();
return 1;
}
if (bForeground) {
int iPid = getpid();
CUtils::PrintMessage("Staying open for debugging [pid: " + CString(iPid) + "]");
pZNC->WritePidFile(iPid);
CUtils::PrintMessage(CZNC::GetTag());
} else {
CUtils::PrintAction("Forking into the background");
int iPid = fork();
if (iPid == -1) {
CUtils::PrintStatus(false, strerror(errno));
CZNC::DestroyInstance();
return 1;
}
if (iPid > 0) {
// We are the parent. We are done and will go to bed.
CUtils::PrintStatus(true, "[pid: " + CString(iPid) + "]");
pZNC->WritePidFile(iPid);
CUtils::PrintMessage(CZNC::GetTag());
/* Don't destroy pZNC here or it will delete the pid file. */
return 0;
}
/* fcntl() locks don't necessarily propagate to forked()
* children. Reacquire the lock here. Use the blocking
* call to avoid race condition with parent exiting.
*/
if (!pZNC->WaitForChildLock()) {
CUtils::PrintError("Child was unable to obtain lock on config file.");
CZNC::DestroyInstance();
return 1;
}
// Redirect std in/out/err to /dev/null
close(0); open("/dev/null", O_RDONLY);
close(1); open("/dev/null", O_WRONLY);
close(2); open("/dev/null", O_WRONLY);
CDebug::SetStdoutIsTTY(false);
// We are the child. There is no way we can be a process group
// leader, thus setsid() must succeed.
setsid();
// Now we are in our own process group and session (no
// controlling terminal). We are independent!
}
struct sigaction sa;
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, (struct sigaction*) NULL);
sa.sa_handler = signalHandler;
sigaction(SIGHUP, &sa, (struct sigaction*) NULL);
sigaction(SIGUSR1, &sa, (struct sigaction*) NULL);
// Once this signal is caught, the signal handler is reset
// to SIG_DFL. This avoids endless loop with signals.
sa.sa_flags = SA_RESETHAND;
sa.sa_handler = die;
sigaction(SIGINT, &sa, (struct sigaction*) NULL);
sigaction(SIGQUIT, &sa, (struct sigaction*) NULL);
sigaction(SIGTERM, &sa, (struct sigaction*) NULL);
int iRet = 0;
try {
pZNC->Loop();
} catch (const CException& e) {
switch (e.GetType()) {
case CException::EX_Shutdown:
iRet = 0;
break;
case CException::EX_Restart: {
// strdup() because GCC is stupid
char *args[] = {
strdup(argv[0]),
strdup("--datadir"),
strdup(pZNC->GetZNCPath().c_str()),
NULL,
NULL,
NULL,
NULL
};
int pos = 3;
if (CDebug::Debug())
args[pos++] = strdup("--debug");
else if (bForeground)
args[pos++] = strdup("--foreground");
if (!CDebug::StdoutIsTTY())
args[pos++] = strdup("--no-color");
if (bAllowRoot)
args[pos++] = strdup("--allow-root");
// The above code adds 3 entries to args tops
// which means the array should be big enough
CZNC::DestroyInstance();
execvp(args[0], args);
CUtils::PrintError("Unable to restart ZNC [" + CString(strerror(errno)) + "]");
} /* Fall through */
default:
iRet = 1;
}
}
CZNC::DestroyInstance();
return iRet;
}
<commit_msg>Initialize OpenSSL locking functions<commit_after>/*
* Copyright (C) 2004-2014 ZNC, see the NOTICE file for details.
*
* 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.
*/
#include <znc/znc.h>
#include <signal.h>
#if defined(HAVE_LIBSSL) && defined(HAVE_PTHREAD)
#include <znc/Threads.h>
#include <openssl/crypto.h>
#include <memory>
static std::vector<std::unique_ptr<CMutex> > lock_cs;
static void locking_callback(int mode, int type, const char *file, int line) {
if(mode & CRYPTO_LOCK) {
lock_cs[type]->lock();
} else {
lock_cs[type]->unlock();
}
}
static unsigned long thread_id_callback() {
return (unsigned long)pthread_self();
}
static CRYPTO_dynlock_value *dyn_create_callback(const char *file, int line) {
return (CRYPTO_dynlock_value*)new CMutex;
}
static void dyn_lock_callback(int mode, CRYPTO_dynlock_value *dlock, const char *file, int line) {
CMutex *mtx = (CMutex*)dlock;
if(mode & CRYPTO_LOCK) {
mtx->lock();
} else {
mtx->unlock();
}
}
static void dyn_destroy_callback(CRYPTO_dynlock_value *dlock, const char *file, int line) {
CMutex *mtx = (CMutex*)dlock;
delete mtx;
}
static void thread_setup() {
lock_cs.resize(CRYPTO_num_locks());
for(std::unique_ptr<CMutex> &mtx: lock_cs)
mtx = std::unique_ptr<CMutex>(new CMutex());
CRYPTO_set_id_callback(&thread_id_callback);
CRYPTO_set_locking_callback(&locking_callback);
CRYPTO_set_dynlock_create_callback(&dyn_create_callback);
CRYPTO_set_dynlock_lock_callback(&dyn_lock_callback);
CRYPTO_set_dynlock_destroy_callback(&dyn_destroy_callback);
}
#else
#define thread_setup()
#endif
using std::cout;
using std::endl;
using std::set;
#ifdef HAVE_GETOPT_LONG
#include <getopt.h>
#else
#define no_argument 0
#define required_argument 1
#define optional_argument 2
struct option {
const char *a;
int opt;
int *flag;
int val;
};
static inline int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *, int *)
{
return getopt(argc, argv, optstring);
}
#endif
static const struct option g_LongOpts[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ "debug", no_argument, 0, 'D' },
{ "foreground", no_argument, 0, 'f' },
{ "no-color", no_argument, 0, 'n' },
{ "allow-root", no_argument, 0, 'r' },
{ "makeconf", no_argument, 0, 'c' },
{ "makepass", no_argument, 0, 's' },
{ "makepem", no_argument, 0, 'p' },
{ "datadir", required_argument, 0, 'd' },
{ 0, 0, 0, 0 }
};
static void GenerateHelp(const char *appname) {
CUtils::PrintMessage("USAGE: " + CString(appname) + " [options]");
CUtils::PrintMessage("Options are:");
CUtils::PrintMessage("\t-h, --help List available command line options (this page)");
CUtils::PrintMessage("\t-v, --version Output version information and exit");
CUtils::PrintMessage("\t-f, --foreground Don't fork into the background");
CUtils::PrintMessage("\t-D, --debug Output debugging information (Implies -f)");
CUtils::PrintMessage("\t-n, --no-color Don't use escape sequences in the output");
CUtils::PrintMessage("\t-r, --allow-root Don't complain if ZNC is run as root");
CUtils::PrintMessage("\t-c, --makeconf Interactively create a new config");
CUtils::PrintMessage("\t-s, --makepass Generates a password for use in config");
#ifdef HAVE_LIBSSL
CUtils::PrintMessage("\t-p, --makepem Generates a pemfile for use with SSL");
#endif /* HAVE_LIBSSL */
CUtils::PrintMessage("\t-d, --datadir Set a different ZNC repository (default is ~/.znc)");
}
static void die(int sig) {
signal(SIGPIPE, SIG_DFL);
CUtils::PrintMessage("Exiting on SIG [" + CString(sig) + "]");
CZNC::DestroyInstance();
exit(sig);
}
static void signalHandler(int sig) {
switch (sig) {
case SIGHUP:
CUtils::PrintMessage("Caught SIGHUP");
CZNC::Get().SetConfigState(CZNC::ECONFIG_NEED_REHASH);
break;
case SIGUSR1:
CUtils::PrintMessage("Caught SIGUSR1");
CZNC::Get().SetConfigState(CZNC::ECONFIG_NEED_WRITE);
break;
default:
CUtils::PrintMessage("WTF? Signal handler called for a signal it doesn't know?");
}
}
static bool isRoot() {
// User root? If one of these were root, we could switch the others to root, too
return (geteuid() == 0 || getuid() == 0);
}
static void seedPRNG() {
struct timeval tv;
unsigned int seed;
// Try to find a seed which can't be as easily guessed as only time()
if (gettimeofday(&tv, NULL) == 0) {
seed = (unsigned int)tv.tv_sec;
// This is in [0:1e6], which means that roughly 20 bits are
// actually used, let's try to shuffle the high bits.
seed ^= uint32_t((tv.tv_usec << 10) | tv.tv_usec);
} else
seed = (unsigned int)time(NULL);
seed ^= rand();
seed ^= getpid();
srand(seed);
}
int main(int argc, char** argv) {
CString sConfig;
CString sDataDir = "";
thread_setup();
seedPRNG();
CDebug::SetStdoutIsTTY(isatty(1));
int iArg, iOptIndex = -1;
bool bMakeConf = false;
bool bMakePass = false;
bool bAllowRoot = false;
bool bForeground = false;
#ifdef ALWAYS_RUN_IN_FOREGROUND
bForeground = true;
#endif
#ifdef HAVE_LIBSSL
bool bMakePem = false;
#endif
while ((iArg = getopt_long(argc, argv, "hvnrcspd:Df", g_LongOpts, &iOptIndex)) != -1) {
switch (iArg) {
case 'h':
GenerateHelp(argv[0]);
return 0;
case 'v':
cout << CZNC::GetTag() << endl;
cout << CZNC::GetCompileOptionsString() << endl;
return 0;
case 'n':
CDebug::SetStdoutIsTTY(false);
break;
case 'r':
bAllowRoot = true;
break;
case 'c':
bMakeConf = true;
break;
case 's':
bMakePass = true;
break;
case 'p':
#ifdef HAVE_LIBSSL
bMakePem = true;
break;
#else
CUtils::PrintError("ZNC is compiled without SSL support.");
return 1;
#endif /* HAVE_LIBSSL */
case 'd':
sDataDir = CString(optarg);
break;
case 'f':
bForeground = true;
break;
case 'D':
bForeground = true;
CDebug::SetDebug(true);
break;
case '?':
default:
GenerateHelp(argv[0]);
return 1;
}
}
if (optind < argc) {
CUtils::PrintError("Specifying a config file as an argument isn't supported anymore.");
CUtils::PrintError("Use --datadir instead.");
return 1;
}
CZNC::CreateInstance();
CZNC* pZNC = &CZNC::Get();
pZNC->InitDirs(((argc) ? argv[0] : ""), sDataDir);
#ifdef HAVE_LIBSSL
if (bMakePem) {
pZNC->WritePemFile();
CZNC::DestroyInstance();
return 0;
}
#endif /* HAVE_LIBSSL */
if (bMakePass) {
CString sSalt;
CUtils::PrintMessage("Type your new password.");
CString sHash = CUtils::GetSaltedHashPass(sSalt);
CUtils::PrintMessage("Kill ZNC process, if it's running.");
CUtils::PrintMessage("Then replace password in the <User> section of your config with this:");
// Not PrintMessage(), to remove [**] from the beginning, to ease copypasting
std::cout << "<Pass password>" << std::endl;
std::cout << "\tMethod = " << CUtils::sDefaultHash << std::endl;
std::cout << "\tHash = " << sHash << std::endl;
std::cout << "\tSalt = " << sSalt << std::endl;
std::cout << "</Pass>" << std::endl;
CUtils::PrintMessage("After that start ZNC again, and you should be able to login with the new password.");
CZNC::DestroyInstance();
return 0;
}
{
set<CModInfo> ssGlobalMods;
set<CModInfo> ssUserMods;
set<CModInfo> ssNetworkMods;
CUtils::PrintAction("Checking for list of available modules");
pZNC->GetModules().GetAvailableMods(ssGlobalMods, CModInfo::GlobalModule);
pZNC->GetModules().GetAvailableMods(ssUserMods, CModInfo::UserModule);
pZNC->GetModules().GetAvailableMods(ssNetworkMods, CModInfo::NetworkModule);
if (ssGlobalMods.empty() && ssUserMods.empty() && ssNetworkMods.empty()) {
CUtils::PrintStatus(false, "");
CUtils::PrintError("No modules found. Perhaps you didn't install ZNC properly?");
CUtils::PrintError("Read http://wiki.znc.in/Installation for instructions.");
if (!CUtils::GetBoolInput("Do you really want to run ZNC without any modules?", false)) {
CZNC::DestroyInstance();
return 1;
}
}
CUtils::PrintStatus(true, "");
}
if (isRoot()) {
CUtils::PrintError("You are running ZNC as root! Don't do that! There are not many valid");
CUtils::PrintError("reasons for this and it can, in theory, cause great damage!");
if (!bAllowRoot) {
CZNC::DestroyInstance();
return 1;
}
CUtils::PrintError("You have been warned.");
CUtils::PrintError("Hit CTRL+C now if you don't want to run ZNC as root.");
CUtils::PrintError("ZNC will start in 30 seconds.");
sleep(30);
}
if (bMakeConf) {
if (!pZNC->WriteNewConfig(sConfig)) {
CZNC::DestroyInstance();
return 0;
}
/* Fall through to normal bootup */
}
CString sConfigError;
if (!pZNC->ParseConfig(sConfig, sConfigError)) {
CUtils::PrintError("Unrecoverable config error.");
CZNC::DestroyInstance();
return 1;
}
if (!pZNC->OnBoot()) {
CUtils::PrintError("Exiting due to module boot errors.");
CZNC::DestroyInstance();
return 1;
}
if (bForeground) {
int iPid = getpid();
CUtils::PrintMessage("Staying open for debugging [pid: " + CString(iPid) + "]");
pZNC->WritePidFile(iPid);
CUtils::PrintMessage(CZNC::GetTag());
} else {
CUtils::PrintAction("Forking into the background");
int iPid = fork();
if (iPid == -1) {
CUtils::PrintStatus(false, strerror(errno));
CZNC::DestroyInstance();
return 1;
}
if (iPid > 0) {
// We are the parent. We are done and will go to bed.
CUtils::PrintStatus(true, "[pid: " + CString(iPid) + "]");
pZNC->WritePidFile(iPid);
CUtils::PrintMessage(CZNC::GetTag());
/* Don't destroy pZNC here or it will delete the pid file. */
return 0;
}
/* fcntl() locks don't necessarily propagate to forked()
* children. Reacquire the lock here. Use the blocking
* call to avoid race condition with parent exiting.
*/
if (!pZNC->WaitForChildLock()) {
CUtils::PrintError("Child was unable to obtain lock on config file.");
CZNC::DestroyInstance();
return 1;
}
// Redirect std in/out/err to /dev/null
close(0); open("/dev/null", O_RDONLY);
close(1); open("/dev/null", O_WRONLY);
close(2); open("/dev/null", O_WRONLY);
CDebug::SetStdoutIsTTY(false);
// We are the child. There is no way we can be a process group
// leader, thus setsid() must succeed.
setsid();
// Now we are in our own process group and session (no
// controlling terminal). We are independent!
}
struct sigaction sa;
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, (struct sigaction*) NULL);
sa.sa_handler = signalHandler;
sigaction(SIGHUP, &sa, (struct sigaction*) NULL);
sigaction(SIGUSR1, &sa, (struct sigaction*) NULL);
// Once this signal is caught, the signal handler is reset
// to SIG_DFL. This avoids endless loop with signals.
sa.sa_flags = SA_RESETHAND;
sa.sa_handler = die;
sigaction(SIGINT, &sa, (struct sigaction*) NULL);
sigaction(SIGQUIT, &sa, (struct sigaction*) NULL);
sigaction(SIGTERM, &sa, (struct sigaction*) NULL);
int iRet = 0;
try {
pZNC->Loop();
} catch (const CException& e) {
switch (e.GetType()) {
case CException::EX_Shutdown:
iRet = 0;
break;
case CException::EX_Restart: {
// strdup() because GCC is stupid
char *args[] = {
strdup(argv[0]),
strdup("--datadir"),
strdup(pZNC->GetZNCPath().c_str()),
NULL,
NULL,
NULL,
NULL
};
int pos = 3;
if (CDebug::Debug())
args[pos++] = strdup("--debug");
else if (bForeground)
args[pos++] = strdup("--foreground");
if (!CDebug::StdoutIsTTY())
args[pos++] = strdup("--no-color");
if (bAllowRoot)
args[pos++] = strdup("--allow-root");
// The above code adds 3 entries to args tops
// which means the array should be big enough
CZNC::DestroyInstance();
execvp(args[0], args);
CUtils::PrintError("Unable to restart ZNC [" + CString(strerror(errno)) + "]");
} /* Fall through */
default:
iRet = 1;
}
}
CZNC::DestroyInstance();
return iRet;
}
<|endoftext|> |
<commit_before>#ifndef units_hh_INCLUDED
#define units_hh_INCLUDED
#include "hash.hh"
#include <type_traits>
namespace Kakoune
{
template<typename RealType, typename ValueType = int>
class StronglyTypedNumber
{
public:
[[gnu::always_inline]]
explicit constexpr StronglyTypedNumber(ValueType value)
: m_value(value)
{
static_assert(std::is_base_of<StronglyTypedNumber, RealType>::value,
"RealType is not derived from StronglyTypedNumber");
}
[[gnu::always_inline]]
constexpr RealType operator+(RealType other) const
{ return RealType(m_value + other.m_value); }
[[gnu::always_inline]]
constexpr RealType operator-(RealType other) const
{ return RealType(m_value - other.m_value); }
[[gnu::always_inline]]
constexpr RealType operator*(RealType other) const
{ return RealType(m_value * other.m_value); }
[[gnu::always_inline]]
constexpr RealType operator/(RealType other) const
{ return RealType(m_value / other.m_value); }
[[gnu::always_inline]]
RealType& operator+=(RealType other)
{ m_value += other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator-=(RealType other)
{ m_value -= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator*=(RealType other)
{ m_value *= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator/=(RealType other)
{ m_value /= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator++()
{ ++m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator--()
{ --m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType operator++(int)
{ RealType backup(static_cast<RealType&>(*this)); ++m_value; return backup; }
[[gnu::always_inline]]
RealType operator--(int)
{ RealType backup(static_cast<RealType&>(*this)); --m_value; return backup; }
[[gnu::always_inline]]
constexpr RealType operator-() const { return RealType(-m_value); }
[[gnu::always_inline]]
constexpr RealType operator%(RealType other) const
{ return RealType(m_value % other.m_value); }
[[gnu::always_inline]]
RealType& operator%=(RealType other)
{ m_value %= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
constexpr bool operator==(RealType other) const
{ return m_value == other.m_value; }
[[gnu::always_inline]]
constexpr bool operator!=(RealType other) const
{ return m_value != other.m_value; }
[[gnu::always_inline]]
constexpr bool operator<(RealType other) const
{ return m_value < other.m_value; }
[[gnu::always_inline]]
constexpr bool operator<=(RealType other) const
{ return m_value <= other.m_value; }
[[gnu::always_inline]]
constexpr bool operator>(RealType other) const
{ return m_value > other.m_value; }
[[gnu::always_inline]]
constexpr bool operator>=(RealType other) const
{ return m_value >= other.m_value; }
[[gnu::always_inline]]
constexpr bool operator!() const
{ return !m_value; }
[[gnu::always_inline]]
explicit constexpr operator ValueType() const { return m_value; }
[[gnu::always_inline]]
explicit constexpr operator bool() const { return m_value; }
friend size_t hash_value(RealType val) { return hash_value(val.m_value); }
private:
ValueType m_value;
};
struct LineCount : public StronglyTypedNumber<LineCount, int>
{
[[gnu::always_inline]]
constexpr LineCount(int value = 0) : StronglyTypedNumber<LineCount>(value) {}
};
[[gnu::always_inline]]
inline constexpr LineCount operator"" _line(unsigned long long int value)
{
return LineCount(value);
}
struct ByteCount : public StronglyTypedNumber<ByteCount, int>
{
[[gnu::always_inline]]
constexpr ByteCount(int value = 0) : StronglyTypedNumber<ByteCount>(value) {}
};
[[gnu::always_inline]]
inline constexpr ByteCount operator"" _byte(unsigned long long int value)
{
return ByteCount(value);
}
struct CharCount : public StronglyTypedNumber<CharCount, int>
{
[[gnu::always_inline]]
constexpr CharCount(int value = 0) : StronglyTypedNumber<CharCount>(value) {}
};
[[gnu::always_inline]]
inline constexpr CharCount operator"" _char(unsigned long long int value)
{
return CharCount(value);
}
}
#endif // units_hh_INCLUDED
<commit_msg>Add a 'abs' friend function to StronglyTypedNumber<commit_after>#ifndef units_hh_INCLUDED
#define units_hh_INCLUDED
#include "hash.hh"
#include <type_traits>
namespace Kakoune
{
template<typename RealType, typename ValueType = int>
class StronglyTypedNumber
{
public:
[[gnu::always_inline]]
explicit constexpr StronglyTypedNumber(ValueType value)
: m_value(value)
{
static_assert(std::is_base_of<StronglyTypedNumber, RealType>::value,
"RealType is not derived from StronglyTypedNumber");
}
[[gnu::always_inline]]
constexpr RealType operator+(RealType other) const
{ return RealType(m_value + other.m_value); }
[[gnu::always_inline]]
constexpr RealType operator-(RealType other) const
{ return RealType(m_value - other.m_value); }
[[gnu::always_inline]]
constexpr RealType operator*(RealType other) const
{ return RealType(m_value * other.m_value); }
[[gnu::always_inline]]
constexpr RealType operator/(RealType other) const
{ return RealType(m_value / other.m_value); }
[[gnu::always_inline]]
RealType& operator+=(RealType other)
{ m_value += other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator-=(RealType other)
{ m_value -= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator*=(RealType other)
{ m_value *= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator/=(RealType other)
{ m_value /= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator++()
{ ++m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType& operator--()
{ --m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
RealType operator++(int)
{ RealType backup(static_cast<RealType&>(*this)); ++m_value; return backup; }
[[gnu::always_inline]]
RealType operator--(int)
{ RealType backup(static_cast<RealType&>(*this)); --m_value; return backup; }
[[gnu::always_inline]]
constexpr RealType operator-() const { return RealType(-m_value); }
[[gnu::always_inline]]
constexpr RealType operator%(RealType other) const
{ return RealType(m_value % other.m_value); }
[[gnu::always_inline]]
RealType& operator%=(RealType other)
{ m_value %= other.m_value; return static_cast<RealType&>(*this); }
[[gnu::always_inline]]
constexpr bool operator==(RealType other) const
{ return m_value == other.m_value; }
[[gnu::always_inline]]
constexpr bool operator!=(RealType other) const
{ return m_value != other.m_value; }
[[gnu::always_inline]]
constexpr bool operator<(RealType other) const
{ return m_value < other.m_value; }
[[gnu::always_inline]]
constexpr bool operator<=(RealType other) const
{ return m_value <= other.m_value; }
[[gnu::always_inline]]
constexpr bool operator>(RealType other) const
{ return m_value > other.m_value; }
[[gnu::always_inline]]
constexpr bool operator>=(RealType other) const
{ return m_value >= other.m_value; }
[[gnu::always_inline]]
constexpr bool operator!() const
{ return !m_value; }
[[gnu::always_inline]]
explicit constexpr operator ValueType() const { return m_value; }
[[gnu::always_inline]]
explicit constexpr operator bool() const { return m_value; }
friend size_t hash_value(RealType val) { return hash_value(val.m_value); }
friend size_t abs(RealType val) { return abs(val.m_value); }
private:
ValueType m_value;
};
struct LineCount : public StronglyTypedNumber<LineCount, int>
{
[[gnu::always_inline]]
constexpr LineCount(int value = 0) : StronglyTypedNumber<LineCount>(value) {}
};
[[gnu::always_inline]]
inline constexpr LineCount operator"" _line(unsigned long long int value)
{
return LineCount(value);
}
struct ByteCount : public StronglyTypedNumber<ByteCount, int>
{
[[gnu::always_inline]]
constexpr ByteCount(int value = 0) : StronglyTypedNumber<ByteCount>(value) {}
};
[[gnu::always_inline]]
inline constexpr ByteCount operator"" _byte(unsigned long long int value)
{
return ByteCount(value);
}
struct CharCount : public StronglyTypedNumber<CharCount, int>
{
[[gnu::always_inline]]
constexpr CharCount(int value = 0) : StronglyTypedNumber<CharCount>(value) {}
};
[[gnu::always_inline]]
inline constexpr CharCount operator"" _char(unsigned long long int value)
{
return CharCount(value);
}
}
#endif // units_hh_INCLUDED
<|endoftext|> |
<commit_before>/*
Copyright (c) 2013, Project OSRM, Dennis Luxen, others
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Library/OSRM.h"
#include "Server/ServerFactory.h"
#include "Util/GitDescription.h"
#include "Util/InputFileUtil.h"
#include "Util/ProgramOptions.h"
#include "Util/SimpleLogger.h"
#include "Util/UUID.h"
#ifdef __linux__
#include <sys/mman.h>
#endif
#include <signal.h>
#include <boost/bind.hpp>
// #include <boost/date_time.hpp>
#include <boost/thread.hpp>
#include <iostream>
#ifdef _WIN32
boost::function0<void> console_ctrl_function;
BOOL WINAPI console_ctrl_handler(DWORD ctrl_type)
{
switch (ctrl_type)
{
case CTRL_C_EVENT:
case CTRL_BREAK_EVENT:
case CTRL_CLOSE_EVENT:
case CTRL_SHUTDOWN_EVENT:
console_ctrl_function();
return TRUE;
default:
return FALSE;
}
}
#endif
int main (int argc, const char * argv[])
{
try
{
LogPolicy::GetInstance().Unmute();
bool use_shared_memory = false, trial = false;
std::string ip_address;
int ip_port, requested_thread_num;
ServerPaths server_paths;
const unsigned init_result = GenerateServerProgramOptions(argc, argv, server_paths, ip_address, ip_port, requested_thread_num, use_shared_memory, trial);
if (init_result == INIT_OK_DO_NOT_START_ENGINE)
{
return 0;
}
if (init_result == INIT_FAILED)
{
return 1;
}
#ifdef __linux__
const int lock_flags = MCL_CURRENT | MCL_FUTURE;
if (-1 == mlockall(lock_flags))
{
SimpleLogger().Write(logWARNING) << "Process " << argv[0] << " could not be locked to RAM";
}
#endif
SimpleLogger().Write() <<
"starting up engines, " << g_GIT_DESCRIPTION << ", " <<
"compiled at " << __DATE__ << ", " __TIME__;
if(use_shared_memory)
{
SimpleLogger().Write(logDEBUG) << "Loading from shared memory";
}
else
{
SimpleLogger().Write() << "HSGR file:\t" << server_paths["hsgrdata"];
SimpleLogger().Write(logDEBUG) << "Nodes file:\t" << server_paths["nodesdata"];
SimpleLogger().Write(logDEBUG) << "Edges file:\t" << server_paths["edgesdata"];
SimpleLogger().Write(logDEBUG) << "Geometry file:\t" << server_paths["geometries"];
SimpleLogger().Write(logDEBUG) << "RAM file:\t" << server_paths["ramindex"];
SimpleLogger().Write(logDEBUG) << "Index file:\t" << server_paths["fileindex"];
SimpleLogger().Write(logDEBUG) << "Names file:\t" << server_paths["namesdata"];
SimpleLogger().Write(logDEBUG) << "Timestamp file:\t" << server_paths["timestamp"];
SimpleLogger().Write(logDEBUG) << "Threads:\t" << requested_thread_num;
SimpleLogger().Write(logDEBUG) << "IP address:\t" << ip_address;
SimpleLogger().Write(logDEBUG) << "IP port:\t" << ip_port;
}
#ifndef _WIN32
int sig = 0;
sigset_t new_mask;
sigset_t old_mask;
sigfillset(&new_mask);
pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask);
#endif
OSRM osrm_lib(server_paths, use_shared_memory);
Server * routing_server = ServerFactory::CreateServer(
ip_address,
ip_port,
requested_thread_num
);
routing_server->GetRequestHandlerPtr().RegisterRoutingMachine(&osrm_lib);
if( trial )
{
SimpleLogger().Write() << "trial run, quitting after successful initialization";
}
else
{
boost::thread server_thread(boost::bind(&Server::Run, routing_server));
#ifndef _WIN32
sigset_t wait_mask;
pthread_sigmask(SIG_SETMASK, &old_mask, 0);
sigemptyset(&wait_mask);
sigaddset(&wait_mask, SIGINT);
sigaddset(&wait_mask, SIGQUIT);
sigaddset(&wait_mask, SIGTERM);
pthread_sigmask(SIG_BLOCK, &wait_mask, 0);
SimpleLogger().Write() << "running and waiting for requests";
sigwait(&wait_mask, &sig);
#else
// Set console control handler to allow server to be stopped.
console_ctrl_function = boost::bind(&Server::Stop, routing_server);
SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
SimpleLogger().Write() << "running and waiting for requests";
routing_server->Run();
#endif
SimpleLogger().Write() << "initiating shutdown";
routing_server->Stop();
SimpleLogger().Write() << "stopping threads";
if (!server_thread.timed_join(boost::posix_time::seconds(2)))
{
SimpleLogger().Write(logDEBUG) << "Threads did not finish within 2 seconds. Hard abort!";
}
}
SimpleLogger().Write() << "freeing objects";
delete routing_server;
SimpleLogger().Write() << "shutdown completed";
}
catch (const std::exception& e)
{
SimpleLogger().Write(logWARNING) << "exception: " << e.what();
return 1;
}
#ifdef __linux__
munlockall();
#endif
return 0;
}
<commit_msg>make function call more legible<commit_after>/*
Copyright (c) 2013, Project OSRM, Dennis Luxen, others
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Library/OSRM.h"
#include "Server/ServerFactory.h"
#include "Util/GitDescription.h"
#include "Util/InputFileUtil.h"
#include "Util/ProgramOptions.h"
#include "Util/SimpleLogger.h"
#include "Util/UUID.h"
#ifdef __linux__
#include <sys/mman.h>
#endif
#include <signal.h>
#include <boost/bind.hpp>
// #include <boost/date_time.hpp>
#include <boost/thread.hpp>
#include <iostream>
#ifdef _WIN32
boost::function0<void> console_ctrl_function;
BOOL WINAPI console_ctrl_handler(DWORD ctrl_type)
{
switch (ctrl_type)
{
case CTRL_C_EVENT:
case CTRL_BREAK_EVENT:
case CTRL_CLOSE_EVENT:
case CTRL_SHUTDOWN_EVENT:
console_ctrl_function();
return TRUE;
default:
return FALSE;
}
}
#endif
int main (int argc, const char * argv[])
{
try
{
LogPolicy::GetInstance().Unmute();
bool use_shared_memory = false, trial = false;
std::string ip_address;
int ip_port, requested_thread_num;
ServerPaths server_paths;
const unsigned init_result = GenerateServerProgramOptions(argc,
argv,
server_paths,
ip_address,
ip_port,
requested_thread_num,
use_shared_memory,
trial);
if (init_result == INIT_OK_DO_NOT_START_ENGINE)
{
return 0;
}
if (init_result == INIT_FAILED)
{
return 1;
}
#ifdef __linux__
const int lock_flags = MCL_CURRENT | MCL_FUTURE;
if (-1 == mlockall(lock_flags))
{
SimpleLogger().Write(logWARNING) << "Process " << argv[0] << " could not be locked to RAM";
}
#endif
SimpleLogger().Write() <<
"starting up engines, " << g_GIT_DESCRIPTION << ", " <<
"compiled at " << __DATE__ << ", " __TIME__;
if(use_shared_memory)
{
SimpleLogger().Write(logDEBUG) << "Loading from shared memory";
}
else
{
SimpleLogger().Write() << "HSGR file:\t" << server_paths["hsgrdata"];
SimpleLogger().Write(logDEBUG) << "Nodes file:\t" << server_paths["nodesdata"];
SimpleLogger().Write(logDEBUG) << "Edges file:\t" << server_paths["edgesdata"];
SimpleLogger().Write(logDEBUG) << "Geometry file:\t" << server_paths["geometries"];
SimpleLogger().Write(logDEBUG) << "RAM file:\t" << server_paths["ramindex"];
SimpleLogger().Write(logDEBUG) << "Index file:\t" << server_paths["fileindex"];
SimpleLogger().Write(logDEBUG) << "Names file:\t" << server_paths["namesdata"];
SimpleLogger().Write(logDEBUG) << "Timestamp file:\t" << server_paths["timestamp"];
SimpleLogger().Write(logDEBUG) << "Threads:\t" << requested_thread_num;
SimpleLogger().Write(logDEBUG) << "IP address:\t" << ip_address;
SimpleLogger().Write(logDEBUG) << "IP port:\t" << ip_port;
}
#ifndef _WIN32
int sig = 0;
sigset_t new_mask;
sigset_t old_mask;
sigfillset(&new_mask);
pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask);
#endif
OSRM osrm_lib(server_paths, use_shared_memory);
Server * routing_server = ServerFactory::CreateServer(
ip_address,
ip_port,
requested_thread_num
);
routing_server->GetRequestHandlerPtr().RegisterRoutingMachine(&osrm_lib);
if( trial )
{
SimpleLogger().Write() << "trial run, quitting after successful initialization";
}
else
{
boost::thread server_thread(boost::bind(&Server::Run, routing_server));
#ifndef _WIN32
sigset_t wait_mask;
pthread_sigmask(SIG_SETMASK, &old_mask, 0);
sigemptyset(&wait_mask);
sigaddset(&wait_mask, SIGINT);
sigaddset(&wait_mask, SIGQUIT);
sigaddset(&wait_mask, SIGTERM);
pthread_sigmask(SIG_BLOCK, &wait_mask, 0);
SimpleLogger().Write() << "running and waiting for requests";
sigwait(&wait_mask, &sig);
#else
// Set console control handler to allow server to be stopped.
console_ctrl_function = boost::bind(&Server::Stop, routing_server);
SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
SimpleLogger().Write() << "running and waiting for requests";
routing_server->Run();
#endif
SimpleLogger().Write() << "initiating shutdown";
routing_server->Stop();
SimpleLogger().Write() << "stopping threads";
if (!server_thread.timed_join(boost::posix_time::seconds(2)))
{
SimpleLogger().Write(logDEBUG) << "Threads did not finish within 2 seconds. Hard abort!";
}
}
SimpleLogger().Write() << "freeing objects";
delete routing_server;
SimpleLogger().Write() << "shutdown completed";
}
catch (const std::exception& e)
{
SimpleLogger().Write(logWARNING) << "exception: " << e.what();
return 1;
}
#ifdef __linux__
munlockall();
#endif
return 0;
}
<|endoftext|> |
<commit_before>/* Copyright 2021 Google LLC
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.
*/
#include "Poco/JSON/JSON.h"
#include "Poco/JSON/ParserImpl.h"
#include "Poco/JSON/Parser.h"
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
std::string json(reinterpret_cast<const char*>(data), size);
Poco::JSON::Parser parser;
Poco::Dynamic::Var result;
try
{
result = parser.parse(json);
}
catch(const std::exception& e)
{
return 0;
}
return 0;
}
<commit_msg>[poco] Add exception to fuzzer (#5835)<commit_after>/* Copyright 2021 Google LLC
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.
*/
#include "Poco/JSON/JSON.h"
#include "Poco/JSON/Parser.h"
#include "Poco/JSON/ParserImpl.h"
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
std::string json(reinterpret_cast<const char *>(data), size);
Poco::JSON::Parser parser;
Poco::Dynamic::Var result;
try {
result = parser.parse(json);
} catch (Poco::Exception &e) {
return 0;
} catch (const std::exception &e) {
return 0;
}
return 0;
}
<|endoftext|> |
<commit_before>#define VERSION "0.3"
#define MAX_COUNT 255
#define TAG_DENSITY 90
#define CONNECTED_THRESHOLD 0
namespace khmer {
// largest number we can count up to, exactly. (8 bytes)
typedef unsigned long long int ExactCounterType;
// largest number we're going to hash into. (8 bytes/64 bits/32 nt)
typedef unsigned long long int HashIntoType;
// largest size 'k' value for k-mer calculations. (1 byte/255)
typedef unsigned char WordLength;
// largest number we can count up to, approximately. (8 bytes/127).
// see MAX_COUNT, above.
typedef unsigned char BoundedCounterType;
typedef void (*CallbackFn)(const char * info, void * callback_data,
unsigned int n_reads, unsigned long long other);
};
<commit_msg>set default to something sane for metagenomics<commit_after>#define VERSION "0.3"
#define MAX_COUNT 255
#define TAG_DENSITY 40
#define CONNECTED_THRESHOLD 0
namespace khmer {
// largest number we can count up to, exactly. (8 bytes)
typedef unsigned long long int ExactCounterType;
// largest number we're going to hash into. (8 bytes/64 bits/32 nt)
typedef unsigned long long int HashIntoType;
// largest size 'k' value for k-mer calculations. (1 byte/255)
typedef unsigned char WordLength;
// largest number we can count up to, approximately. (8 bytes/127).
// see MAX_COUNT, above.
typedef unsigned char BoundedCounterType;
typedef void (*CallbackFn)(const char * info, void * callback_data,
unsigned int n_reads, unsigned long long other);
};
<|endoftext|> |
<commit_before>////////////////////////////////////////////////////////////////////////////////
// task - a command line task list manager.
//
// Copyright 2006 - 2009, Paul Beckingham.
// All rights reserved.
//
// This program is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the
//
// Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor,
// Boston, MA
// 02110-1301
// USA
//
////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include "Context.h"
Context context;
int main (int argc, char** argv)
{
// Set up randomness.
#ifdef HAVE_SRANDOM
srandom (time (NULL));
#else
srand (time (NULL));
#endif
int status = 0;
try
{
context.initialize (argc, argv);
if (context.program.find ("itask") != std::string::npos)
status = context.interactive ();
else
status = context.run ();
}
catch (std::string& error)
{
std::cout << error << std::endl;
return -1;
}
catch (...)
{
std::cerr << context.stringtable.get (100, "Unknown error.") << std::endl;
return -2;
}
return status;
}
////////////////////////////////////////////////////////////////////////////////
<commit_msg>Bug Fix<commit_after>////////////////////////////////////////////////////////////////////////////////
// task - a command line task list manager.
//
// Copyright 2006 - 2009, Paul Beckingham.
// All rights reserved.
//
// This program is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the
//
// Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor,
// Boston, MA
// 02110-1301
// USA
//
////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <stdlib.h>
#include "Context.h"
Context context;
int main (int argc, char** argv)
{
// Set up randomness.
#ifdef HAVE_SRANDOM
srandom (time (NULL));
#else
srand (time (NULL));
#endif
int status = 0;
try
{
context.initialize (argc, argv);
if (context.program.find ("itask") != std::string::npos)
status = context.interactive ();
else
status = context.run ();
}
catch (std::string& error)
{
std::cout << error << std::endl;
return -1;
}
catch (...)
{
std::cerr << context.stringtable.get (100, "Unknown error.") << std::endl;
return -2;
}
return status;
}
////////////////////////////////////////////////////////////////////////////////
<|endoftext|> |
<commit_before>#include <avr/io.h>
#include <util/delay.h>
#include "Led.h"
/**
* \brief main loop
*/
int main(void) {
Led led(&PORTB, &DDRB, PINB0);
while (1) {
led.toggle();
_delay_ms(500);
}
}<commit_msg>first pwm test<commit_after>//#include <avr/io.h>
//#include <util/delay.h>
//#include "Led.h"
/**
* \brief main loop
*/
//int main(void) {
// Led led(&PORTB, &DDRB, PINB0);
//
// while (1) {
// led.toggle();
// _delay_ms(500);
// }
//}
#include <avr/io.h>
#include <util/delay.h>
int main(void)
{
DDRB |= (1 << PB0); // PWM output on PB0
TCCR0A = (1 << COM0A1) | (1 << WGM00); // phase correct PWM mode
OCR0A = 0x10; // initial PWM pulse width
TCCR0B = (1 << CS01); // clock source = CLK/8, start PWM
uint8_t brightness;
while(1)
{
// increasing brightness
for (brightness = 0; brightness < 255; ++brightness)
{
// set the brightness as duty cycle
OCR0A = brightness;
// delay so as to make the user "see" the change in brightness
_delay_ms(10);
}
// decreasing brightness
for (brightness = 255; brightness > 0; --brightness)
{
// set the brightness as duty cycle
OCR0A = brightness;
// delay so as to make the user "see" the change in brightness
_delay_ms(10);
}
}
}
<|endoftext|> |
<commit_before>// Simple binary search tree class for integers
#include "bst.h"
Bst::Bst() {
root_ = nullptr;
}
Bst::~Bst() {
// Recursively delete starting at root
DeleteRecursive(root_);
}
void Bst::Insert(int val) {
// Check if empty
if (root_ == nullptr) {
// Empty tree; insert at root
root_ = new BstNode {val, nullptr, nullptr};
return;
}
// Not empty; traverse to find insertion point
BstNode* node = root_;
while (true) {
if (val <= node->data) {
// Check if we can insert on left child
if (node->left == nullptr) {
// Insert and return
node->left = new BstNode {val, nullptr, nullptr};
return;
} else {
// Traverse down left child
node = node->left;
}
} else {
// Check if we can insert on right child
if (node->right == nullptr) {
// Insert and return
node->right = new BstNode {val, nullptr, nullptr};
return;
} else {
// Traverse down right child
node = node->right;
}
}
}
}
BstNode* Bst::Find(int val) {
BstNode* node = root_;
// Traverse down tree
while (node != nullptr) {
if (node->data == val) {
// Found the value; return the node
return node;
} else if (val <= node->data) {
// Traverse down left child
node = node->left;
} else {
// Traverse down right child
node = node->right;
}
}
return nullptr;
}
void Bst::Remove(int val) {
// TODO
}
BstNode* Bst::GetRoot() {
return root_;
}
void Bst::DeleteRecursive(BstNode* node) {
if (node == nullptr) {
// Base case; return
return;
} else {
// Recursively delete left and right children
DeleteRecursive(node->left);
DeleteRecursive(node->right);
// Delete this node
delete node;
}
}
<commit_msg>Implement BST remove method<commit_after>// Simple binary search tree class for integers
#include "bst.h"
Bst::Bst() {
root_ = nullptr;
}
Bst::~Bst() {
// Recursively delete starting at root
DeleteRecursive(root_);
}
void Bst::Insert(int val) {
// Check if empty
if (root_ == nullptr) {
// Empty tree; insert at root
root_ = new BstNode {val, nullptr, nullptr};
return;
}
// Not empty; traverse to find insertion point
BstNode* node = root_;
while (true) {
if (val <= node->data) {
// Check if we can insert on left child
if (node->left == nullptr) {
// Insert and return
node->left = new BstNode {val, nullptr, nullptr};
return;
} else {
// Traverse down left child
node = node->left;
}
} else {
// Check if we can insert on right child
if (node->right == nullptr) {
// Insert and return
node->right = new BstNode {val, nullptr, nullptr};
return;
} else {
// Traverse down right child
node = node->right;
}
}
}
}
BstNode* Bst::Find(int val) {
BstNode* node = root_;
// Traverse down tree
while (node != nullptr) {
if (node->data == val) {
// Found the value; return the node
return node;
} else if (val <= node->data) {
// Traverse down left child
node = node->left;
} else {
// Traverse down right child
node = node->right;
}
}
return nullptr;
}
void Bst::Remove(int val) {
BstNode* node;
BstNode* parent = nullptr;
// Find node
while (node != nullptr) {
if (node->data == val) {
// Found the node
return node;
} else if (val <= node->data) {
// Traverse down left child
parent = node;
node = node->left;
} else {
// Traverse down right child
parent = node;
node = node->right;
}
}
// Check if node has children
if (!node->left && !node->right) {
// No children; trivial delete
if (!parent) {
// Node was root; set root to nullptr
root_ = nullptr;
} else if (node == parent->left) {
// Node was left child; update parent->left
parent->left = nullptr;
} else {
// Node was right child; update parent->right
parent->right = nullptr;
}
delete node;
} else if (!node->left) {
// Only has left children
if (!parent) {
// Node was root; set root to left children
root_ = node->left;
} else if (node == parent->left) {
// Node was left child; update parent->left
parent->left = node->left;
} else {
// Node was right child; update parent->right
parent->right = node->left;
}
delete node;
} else if (!node->right) {
// Only has right children
if (!parent) {
// Node was root; set root to right children
root_ = node->right;
} else if (node == parent->left) {
// Node was left child; update parent->left
parent->left = node->right;
} else {
// Node was right child; update parent->right
parent->right = node->right;
}
delete node;
} else {
// Has left and right children; complex delete
// Find inorder successor to node being deleted (smallest value in right subtree)
BstNode* successor = node->right;
BstNode* parent_successor = node;
while (successor->left) {
parent_successor = successor;
successor = successor->left;
}
// Handle successor's right subtree if it exists
if (successor->right) {
parent_successor->left = successor->right;
}
// Replace node we're deleting with the successor
successor->right = node->right;
successor->left = node->left;
delete node;
}
}
BstNode* Bst::GetRoot() {
return root_;
}
void Bst::DeleteRecursive(BstNode* node) {
if (node == nullptr) {
// Base case; return
return;
} else {
// Recursively delete left and right children
DeleteRecursive(node->left);
DeleteRecursive(node->right);
// Delete this node
delete node;
}
}
<|endoftext|> |
<commit_before>#include <QApplication>
#include <QDebug>
#include <QDir>
#include <QDateTime>
#include <buildtime.h>
#include "data/models.h"
#include "data/loader.h"
#include "data/vptr.h"
#include "gui/mainwindow.h"
QTextStream *out = 0;
bool logToFile = false;
bool verbose = false;
bool makeScreenshot = false;
void logOutput( QtMsgType type, const char *msg )
{
QString filedate = QDateTime::currentDateTime().toString( "yyyy.MM.dd hh:mm:ss:zzz" );
QString debugdate = QDateTime::currentDateTime().toString( "hh:mm:ss:zzz" );
switch (type)
{
case QtDebugMsg:
debugdate += " [D]";
break;
case QtWarningMsg:
debugdate += " [W]";
break;
case QtCriticalMsg:
debugdate += " [C]";
break;
case QtFatalMsg:
debugdate += " [F]";
break;
}
if ( verbose )
{
(*out) << debugdate << " " << msg << endl;
}
if ( logToFile )
{
QFile outFile("log.txt");
outFile.open(QIODevice::WriteOnly | QIODevice::Append);
QTextStream ts(&outFile);
ts << filedate << " " << msg << endl;
}
if (QtFatalMsg == type)
{
abort();
}
}
void noOutput(QtMsgType type, const char *msg) {}
int main( int argc, char *argv[] )
{
QString hg = HGTIP;
hg.remove( ";" );
hg.remove( "changeset:" );
hg.replace( " ","" );
qDebug() << "brainGL development version" << hg << BUILDDATE << BUILDTIME;
qDebug() << "(c) 2012, 2013 Ralph Schurade, Joachim Boettger";
qDebug() << "Submit suggestions, feature requests, bug reports to https://code.google.com/p/braingl/";
QApplication app( argc, argv );
QCoreApplication::setOrganizationDomain( "braingl.de" );
QCoreApplication::setOrganizationName( "MPI_CBS" );
QCoreApplication::setApplicationName( "braingl" );
QCoreApplication::setApplicationVersion( "0.8.1" );
Q_INIT_RESOURCE( resources );
QStringList args = app.arguments();
bool debug = false;
bool resetSettings = false;
bool runScript = false;
for ( int i = 1; i < args.size(); ++i )
{
if ( args.at( i ) == "-v" )
{
verbose = true;
}
if ( args.at( i ) == "-d" )
{
debug = true;
}
if ( args.at( i ) == "-l" )
{
logToFile = true;
}
if ( args.at( i ) == "-r" )
{
// reset saved settings
resetSettings = true;
}
if ( args.at( i ) == "-s" )
{
makeScreenshot = true;
}
if ( args.at( i ) == "-rs" )
{
runScript = true;
}
if ( args.at( i ) == "-h" || args.at( i ) == "?" )
{
qDebug() << "Command line options:";
qDebug() << "-h : displays this message";
qDebug() << "-v : toggles verbose mode, warning: this will spam your console with messages";
qDebug() << "-l : logs debug messages to text file";
qDebug() << "-r : resets saved settings";
qDebug() << "-s : makes a screenshot and quits";
qDebug() << "-rs : runs the loaded script";
qDebug() << "---";
}
}
qInstallMsgHandler( noOutput );
out = new QTextStream( stdout );
qInstallMsgHandler( logOutput );
#ifdef __DEBUG__
debug = true;
#endif
Models::init();
MainWindow mainWin( debug, resetSettings );
mainWin.show();
for ( int i = 1; i < args.size(); ++i )
{
mainWin.load( args.at( i ) );
}
if ( runScript )
{
mainWin.runScript();
}
if ( makeScreenshot )
{
mainWin.screenshot();
exit( 0 );
}
return app.exec();
}
<commit_msg>command line parameters fpor initial slice positions<commit_after>#include <QApplication>
#include <QDebug>
#include <QDir>
#include <QDateTime>
#include <buildtime.h>
#include "data/models.h"
#include "data/loader.h"
#include "data/vptr.h"
#include "gui/mainwindow.h"
QTextStream *out = 0;
bool logToFile = false;
bool verbose = false;
bool makeScreenshot = false;
void logOutput( QtMsgType type, const char *msg )
{
QString filedate = QDateTime::currentDateTime().toString( "yyyy.MM.dd hh:mm:ss:zzz" );
QString debugdate = QDateTime::currentDateTime().toString( "hh:mm:ss:zzz" );
switch (type)
{
case QtDebugMsg:
debugdate += " [D]";
break;
case QtWarningMsg:
debugdate += " [W]";
break;
case QtCriticalMsg:
debugdate += " [C]";
break;
case QtFatalMsg:
debugdate += " [F]";
break;
}
if ( verbose )
{
(*out) << debugdate << " " << msg << endl;
}
if ( logToFile )
{
QFile outFile("log.txt");
outFile.open(QIODevice::WriteOnly | QIODevice::Append);
QTextStream ts(&outFile);
ts << filedate << " " << msg << endl;
}
if (QtFatalMsg == type)
{
abort();
}
}
void noOutput(QtMsgType type, const char *msg) {}
int main( int argc, char *argv[] )
{
QString hg = HGTIP;
hg.remove( ";" );
hg.remove( "changeset:" );
hg.replace( " ","" );
qDebug() << "brainGL development version" << hg << BUILDDATE << BUILDTIME;
qDebug() << "(c) 2012, 2013 Ralph Schurade, Joachim Boettger";
qDebug() << "Submit suggestions, feature requests, bug reports to https://code.google.com/p/braingl/";
QApplication app( argc, argv );
QCoreApplication::setOrganizationDomain( "braingl.de" );
QCoreApplication::setOrganizationName( "MPI_CBS" );
QCoreApplication::setApplicationName( "braingl" );
QCoreApplication::setApplicationVersion( "0.8.1" );
Q_INIT_RESOURCE( resources );
QStringList args = app.arguments();
bool debug = false;
bool resetSettings = false;
bool runScript = false;
int x = -1;
int y = -1;
int z = -1;
for ( int i = 1; i < args.size(); ++i )
{
if ( args.at( i ) == "-v" )
{
verbose = true;
}
if ( args.at( i ) == "-d" )
{
debug = true;
}
if ( args.at( i ) == "-l" )
{
logToFile = true;
}
if ( args.at( i ) == "-r" )
{
// reset saved settings
resetSettings = true;
}
if ( args.at( i ) == "-s" )
{
makeScreenshot = true;
}
if ( args.at( i ) == "-rs" )
{
runScript = true;
}
if ( args.at( i ) == "-x" )
{
bool ok = false;
if ( args.size() > i + 1 )
{
int tmp = args.at( i + 1 ).toInt( &ok );
if ( ok )
{
x = tmp;
}
}
}
if ( args.at( i ) == "-y" )
{
bool ok = false;
if ( args.size() > i + 1 )
{
int tmp = args.at( i + 1 ).toInt( &ok );
if ( ok )
{
y = tmp;
}
}
}
if ( args.at( i ) == "-z" )
{
bool ok = false;
if ( args.size() > i + 1 )
{
int tmp = args.at( i + 1 ).toInt( &ok );
if ( ok )
{
z = tmp;
}
}
}
if ( args.at( i ) == "-h" || args.at( i ) == "?" )
{
qDebug() << "Command line options:";
qDebug() << "-h : displays this message";
qDebug() << "-v : toggles verbose mode, warning: this will spam your console with messages";
qDebug() << "-l : logs debug messages to text file";
qDebug() << "-r : resets saved settings";
qDebug() << "-s : makes a screenshot and quits";
qDebug() << "-rs : runs the loaded script";
qDebug() << "---";
}
}
qInstallMsgHandler( noOutput );
out = new QTextStream( stdout );
qInstallMsgHandler( logOutput );
#ifdef __DEBUG__
debug = true;
#endif
Models::init();
MainWindow mainWin( debug, resetSettings );
mainWin.show();
for ( int i = 1; i < args.size(); ++i )
{
mainWin.load( args.at( i ) );
}
if ( x != - 1 )
{
Models::setGlobal( Fn::Property::G_SAGITTAL, x );
}
if ( y != - 1 )
{
Models::setGlobal( Fn::Property::G_CORONAL, y );
}
if ( z != - 1 )
{
Models::setGlobal( Fn::Property::G_AXIAL, z );
}
if ( runScript )
{
mainWin.runScript();
}
if ( makeScreenshot )
{
mainWin.screenshot();
exit( 0 );
}
return app.exec();
}
<|endoftext|> |
<commit_before>/*************************************************
* Utility Functions Source File *
* (C) 1999-2007 Jack Lloyd *
*************************************************/
#include <botan/util.h>
#include <botan/bit_ops.h>
#include <algorithm>
#include <cmath>
namespace Botan {
/*************************************************
* Round up n to multiple of align_to *
*************************************************/
u32bit round_up(u32bit n, u32bit align_to)
{
if(n % align_to || n == 0)
n += align_to - (n % align_to);
return n;
}
/*************************************************
* Round down n to multiple of align_to *
*************************************************/
u32bit round_down(u32bit n, u32bit align_to)
{
return (n - (n % align_to));
}
/*************************************************
* Return the work required for solving DL *
*************************************************/
u32bit dl_work_factor(u32bit n_bits)
{
const u32bit MIN_ESTIMATE = 64;
if(n_bits < 32)
return 0;
const double log_x = n_bits / 1.44;
const double strength =
2.76 * std::pow(log_x, 1.0/3.0) * std::pow(std::log(log_x), 2.0/3.0);
if(strength > MIN_ESTIMATE)
return static_cast<u32bit>(strength);
return MIN_ESTIMATE;
}
/*************************************************
* Estimate the entropy of the buffer *
*************************************************/
u32bit entropy_estimate(const byte buffer[], u32bit length)
{
if(length <= 4)
return 0;
u32bit estimate = 0;
byte last = 0, last_delta = 0, last_delta2 = 0;
for(u32bit j = 0; j != length; ++j)
{
byte delta = last ^ buffer[j];
last = buffer[j];
byte delta2 = delta ^ last_delta;
last_delta = delta;
byte delta3 = delta2 ^ last_delta2;
last_delta2 = delta2;
byte min_delta = delta;
if(min_delta > delta2) min_delta = delta2;
if(min_delta > delta3) min_delta = delta3;
estimate += hamming_weight(min_delta);
}
return (estimate / 2);
}
}
<commit_msg>Rewrite dl_work_factor using a lookup table with data from RFC 3526, "More Modular Exponential (MODP) Diffie-Hellman groups for Internet Key Exchange (IKE)", which removes Botan's dependency on standard math library (which can be a big deal on embedded systems, and it seemed silly to have just a single function cause us to pull in potentially all of libm)<commit_after>/*************************************************
* Utility Functions Source File *
* (C) 1999-2007 Jack Lloyd *
*************************************************/
#include <botan/util.h>
#include <botan/bit_ops.h>
#include <algorithm>
namespace Botan {
/*************************************************
* Round up n to multiple of align_to *
*************************************************/
u32bit round_up(u32bit n, u32bit align_to)
{
if(n % align_to || n == 0)
n += align_to - (n % align_to);
return n;
}
/*************************************************
* Round down n to multiple of align_to *
*************************************************/
u32bit round_down(u32bit n, u32bit align_to)
{
return (n - (n % align_to));
}
/*************************************************
* Choose the exponent size for a DL group
*************************************************/
u32bit dl_work_factor(u32bit bits)
{
/*
These values were taken from RFC 3526
*/
if(bits <= 1536)
return 90;
else if(bits <= 2048)
return 110;
else if(bits <= 3072)
return 130;
else if(bits <= 4096)
return 150;
else if(bits <= 6144)
return 170;
else if(bits <= 8192)
return 190;
return 256;
}
/*************************************************
* Estimate the entropy of the buffer *
*************************************************/
u32bit entropy_estimate(const byte buffer[], u32bit length)
{
if(length <= 4)
return 0;
u32bit estimate = 0;
byte last = 0, last_delta = 0, last_delta2 = 0;
for(u32bit j = 0; j != length; ++j)
{
byte delta = last ^ buffer[j];
last = buffer[j];
byte delta2 = delta ^ last_delta;
last_delta = delta;
byte delta3 = delta2 ^ last_delta2;
last_delta2 = delta2;
byte min_delta = delta;
if(min_delta > delta2) min_delta = delta2;
if(min_delta > delta3) min_delta = delta3;
estimate += hamming_weight(min_delta);
}
return (estimate / 2);
}
}
<|endoftext|> |
<commit_before>#include <string>
/*
public class TennisGame4 implements TennisGame {
int serverScore;
int receiverScore;
String server;
String receiver;
public TennisGame4(String player1, String player2) {
this.server = player1;
this.receiver = player2;
}
@java.lang.Override
public void wonPoint(String playerName) {
if (server.equals(playerName))
this.serverScore += 1;
else
this.receiverScore += 1;
}
@java.lang.Override
public String getScore() {
TennisResult result = new Deuce(
this, new GameServer(
this, new GameReceiver(
this, new AdvantageServer(
this, new AdvantageReceiver(
this, new DefaultResult(this)))))).getResult();
return result.format();
}
boolean receiverHasAdvantage() {
return receiverScore >= 4 && (receiverScore - serverScore) == 1;
}
boolean serverHasAdvantage() {
return serverScore >= 4 && (serverScore - receiverScore) == 1;
}
boolean receiverHasWon() {
return receiverScore >= 4 && (receiverScore - serverScore) >= 2;
}
boolean serverHasWon() {
return serverScore >= 4 && (serverScore - receiverScore) >= 2;
}
boolean isDeuce() {
return serverScore >= 3 && receiverScore >= 3 && (serverScore == receiverScore);
}
}
class TennisResult {
String serverScore;
String receiverScore;
TennisResult(String serverScore, String receiverScore) {
this.serverScore = serverScore;
this.receiverScore = receiverScore;
}
String format() {
if ("".equals(this.receiverScore))
return this.serverScore;
if (serverScore.equals(receiverScore))
return serverScore + "-All";
return this.serverScore + "-" + this.receiverScore;
}
}
interface ResultProvider {
TennisResult getResult();
}
class Deuce implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public Deuce(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.isDeuce())
return new TennisResult("Deuce", "");
return this.nextResult.getResult();
}
}
class GameServer implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public GameServer(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.serverHasWon())
return new TennisResult("Win for " + game.server, "");
return this.nextResult.getResult();
}
}
class GameReceiver implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public GameReceiver(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.receiverHasWon())
return new TennisResult("Win for " + game.receiver, "");
return this.nextResult.getResult();
}t
}
class AdvantageServer implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public AdvantageServer(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.serverHasAdvantage())
return new TennisResult("Advantage " + game.server, "");
return this.nextResult.getResult();
}
}
class AdvantageReceiver implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public AdvantageReceiver(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.receiverHasAdvantage())
return new TennisResult("Advantage " + game.receiver, "");
return this.nextResult.getResult();
}
}
class DefaultResult implements ResultProvider {
private static final String[] scores = {"Love", "Fifteen", "Thirty", "Forty"};
private final TennisGame4 game;
public DefaultResult(TennisGame4 game) {
this.game = game;
}
@Override
public TennisResult getResult() {
return new TennisResult(scores[game.serverScore], scores[game.receiverScore]);
}
}
*/
class TennisGame4 {
public:
int serverScore, receiverScore;
};
class TennisResult {
public:
TennisResult(std::string serverScore, std::string receiverScore) {
this->serverScore = serverScore;
this->receiverScore = receiverScore;
}
std::string format() {
if ("" == this->receiverScore)
return this->serverScore;
if (serverScore == this->receiverScore)
return serverScore + "-All";
return this->serverScore + "-" + this->receiverScore;
}
private:
std::string serverScore;
std::string receiverScore;
};
class ResultProvider {
public:
virtual TennisResult getResult() = 0;
virtual ~ResultProvider() {}
};
//class Deuce implements ResultProvider {
//class GameServer implements ResultProvider {
//class GameReceiver implements ResultProvider {
//class AdvantageServer implements ResultProvider {
//class AdvantageReceiver implements ResultProvider {
class DefaultResult : ResultProvider {
public:
DefaultResult(TennisGame4& game) : game(game) { }
TennisResult getResult() override {
return TennisResult(scores[game.serverScore], scores[game.receiverScore]);
}
private:
static const std::string scores[];
const TennisGame4& game;
};
const std::string DefaultResult::scores[] = {"Love", "Fifteen", "Thirty", "Forty"};
// tennis3 function below (TODO: re-implement using class mess above!)
/* relevant inspiration from Java Unit Test
public void checkAllScores(TennisGame game) {
int highestScore = Math.max(this.player1Score, this.player2Score);
for (int i = 0; i < highestScore; i++) {
if (i < this.player1Score)
game.wonPoint("player1");
if (i < this.player2Score)
game.wonPoint("player2");
}
assertEquals(this.expectedScore, game.getScore());
}
*/
const std::string tennis_score(int p1, int p2) {
std::string s;
std::string p1N = "player1";
std::string p2N = "player2";
if ((p1 < 4 && p2 < 4) && (p1 + p2 < 6)) {
std::string p[4] = {"Love", "Fifteen", "Thirty", "Forty"};
s = p[p1];
return (p1 == p2) ? s + "-All" : s + "-" + p[p2];
} else {
if (p1 == p2)
return "Deuce";
s = p1 > p2 ? p1N : p2N;
return ((p1-p2)*(p1-p2) == 1) ? "Advantage " + s : "Win for " + s;
}
}<commit_msg>Apply some clang suggestions<commit_after>#include <string>
/*
public class TennisGame4 implements TennisGame {
int serverScore;
int receiverScore;
String server;
String receiver;
public TennisGame4(String player1, String player2) {
this.server = player1;
this.receiver = player2;
}
@java.lang.Override
public void wonPoint(String playerName) {
if (server.equals(playerName))
this.serverScore += 1;
else
this.receiverScore += 1;
}
@java.lang.Override
public String getScore() {
TennisResult result = new Deuce(
this, new GameServer(
this, new GameReceiver(
this, new AdvantageServer(
this, new AdvantageReceiver(
this, new DefaultResult(this)))))).getResult();
return result.format();
}
boolean receiverHasAdvantage() {
return receiverScore >= 4 && (receiverScore - serverScore) == 1;
}
boolean serverHasAdvantage() {
return serverScore >= 4 && (serverScore - receiverScore) == 1;
}
boolean receiverHasWon() {
return receiverScore >= 4 && (receiverScore - serverScore) >= 2;
}
boolean serverHasWon() {
return serverScore >= 4 && (serverScore - receiverScore) >= 2;
}
boolean isDeuce() {
return serverScore >= 3 && receiverScore >= 3 && (serverScore == receiverScore);
}
}
class TennisResult {
String serverScore;
String receiverScore;
TennisResult(String serverScore, String receiverScore) {
this.serverScore = serverScore;
this.receiverScore = receiverScore;
}
String format() {
if ("".equals(this.receiverScore))
return this.serverScore;
if (serverScore.equals(receiverScore))
return serverScore + "-All";
return this.serverScore + "-" + this.receiverScore;
}
}
interface ResultProvider {
TennisResult getResult();
}
class Deuce implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public Deuce(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.isDeuce())
return new TennisResult("Deuce", "");
return this.nextResult.getResult();
}
}
class GameServer implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public GameServer(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.serverHasWon())
return new TennisResult("Win for " + game.server, "");
return this.nextResult.getResult();
}
}
class GameReceiver implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public GameReceiver(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.receiverHasWon())
return new TennisResult("Win for " + game.receiver, "");
return this.nextResult.getResult();
}t
}
class AdvantageServer implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public AdvantageServer(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.serverHasAdvantage())
return new TennisResult("Advantage " + game.server, "");
return this.nextResult.getResult();
}
}
class AdvantageReceiver implements ResultProvider {
private final TennisGame4 game;
private final ResultProvider nextResult;
public AdvantageReceiver(TennisGame4 game, ResultProvider nextResult) {
this.game = game;
this.nextResult = nextResult;
}
@Override
public TennisResult getResult() {
if (game.receiverHasAdvantage())
return new TennisResult("Advantage " + game.receiver, "");
return this.nextResult.getResult();
}
}
class DefaultResult implements ResultProvider {
private static final String[] scores = {"Love", "Fifteen", "Thirty", "Forty"};
private final TennisGame4 game;
public DefaultResult(TennisGame4 game) {
this.game = game;
}
@Override
public TennisResult getResult() {
return new TennisResult(scores[game.serverScore], scores[game.receiverScore]);
}
}
*/
class TennisGame4 {
public:
int serverScore, receiverScore;
};
class TennisResult {
public:
TennisResult(std::string serverScore, std::string receiverScore) {
this->serverScore = serverScore;
this->receiverScore = receiverScore;
}
std::string format() {
if ("" == this->receiverScore)
return this->serverScore;
if (serverScore == this->receiverScore)
return serverScore + "-All";
return this->serverScore + "-" + this->receiverScore;
}
private:
std::string serverScore;
std::string receiverScore;
};
class ResultProvider {
public:
virtual TennisResult getResult() = 0;
virtual ~ResultProvider() = default;
};
//class Deuce implements ResultProvider {
//class GameServer implements ResultProvider {
//class GameReceiver implements ResultProvider {
//class AdvantageServer implements ResultProvider {
//class AdvantageReceiver implements ResultProvider {
class DefaultResult : ResultProvider {
public:
explicit DefaultResult(TennisGame4& game) : game(game) { }
TennisResult getResult() override {
return TennisResult(scores[game.serverScore], scores[game.receiverScore]);
}
private:
static const std::string scores[];
const TennisGame4& game;
};
const std::string DefaultResult::scores[] = {"Love", "Fifteen", "Thirty", "Forty"};
// tennis3 function below (TODO: re-implement using class mess above!)
/* relevant inspiration from Java Unit Test
public void checkAllScores(TennisGame game) {
int highestScore = Math.max(this.player1Score, this.player2Score);
for (int i = 0; i < highestScore; i++) {
if (i < this.player1Score)
game.wonPoint("player1");
if (i < this.player2Score)
game.wonPoint("player2");
}
assertEquals(this.expectedScore, game.getScore());
}
*/
const std::string tennis_score(int p1, int p2) {
std::string s;
std::string p1N = "player1";
std::string p2N = "player2";
if ((p1 < 4 && p2 < 4) && (p1 + p2 < 6)) {
std::string p[4] = {"Love", "Fifteen", "Thirty", "Forty"};
s = p[p1];
return (p1 == p2) ? s + "-All" : s + "-" + p[p2];
} else {
if (p1 == p2)
return "Deuce";
s = p1 > p2 ? p1N : p2N;
return ((p1-p2)*(p1-p2) == 1) ? "Advantage " + s : "Win for " + s;
}
}<|endoftext|> |
<commit_before>/**
* @copyright Copyright 2016 The J-PET Framework Authors. All rights reserved.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may find a copy of the License in the LICENCE file.
*
* 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.
*
* @file TimeCalibLoader.cpp
*/
#include "TimeCalibLoader.h"
#include "TimeCalibTools.h"
#include "JPetGeomMapping/JPetGeomMapping.h"
#include <JPetParamManager/JPetParamManager.h>
TimeCalibLoader::TimeCalibLoader(const char* name):
JPetUserTask(name) {}
TimeCalibLoader::~TimeCalibLoader() {}
bool TimeCalibLoader::init()
{
fOutputEvents = new JPetTimeWindow("JPetSigCh");
auto calibFile = std::string("timeCalib.txt");
if (fParams.getOptions().count(fConfigFileParamKey)) {
calibFile = boost::any_cast<std::string>(fParams.getOptions().at(fConfigFileParamKey));
}
assert(fParamManager);
JPetGeomMapping mapper(fParamManager->getParamBank());
auto tombMap = mapper.getTOMBMapping();
fTimeCalibration = TimeCalibTools::loadTimeCalibration(calibFile, tombMap);
if (fTimeCalibration.empty()) {
ERROR("Time calibration seems to be empty");
}
return true;
}
bool TimeCalibLoader::exec()
{
if (auto oldTimeWindow = dynamic_cast<const JPetTimeWindow* const>(fEvent)) {
auto n = oldTimeWindow->getNumberOfEvents();
for(uint i=0;i<n;++i){
JPetSigCh sigCh = dynamic_cast<const JPetSigCh&>(oldTimeWindow->operator[](i));
/// Calibration time is ns so we should change it to ps, cause all the time is in ps.
sigCh.setValue(sigCh.getValue() + 1000. * TimeCalibTools::getTimeCalibCorrection(fTimeCalibration, sigCh.getTOMBChannel().getChannel()));
fOutputEvents->add<JPetSigCh>(sigCh);
}
}else{
return false;
}
return true;
}
bool TimeCalibLoader::terminate()
{
return true;
}
<commit_msg>Remove use of obsolete variables<commit_after>/**
* @copyright Copyright 2016 The J-PET Framework Authors. All rights reserved.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may find a copy of the License in the LICENCE file.
*
* 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.
*
* @file TimeCalibLoader.cpp
*/
#include "TimeCalibLoader.h"
#include "TimeCalibTools.h"
#include "JPetGeomMapping/JPetGeomMapping.h"
#include <JPetParamManager/JPetParamManager.h>
TimeCalibLoader::TimeCalibLoader(const char* name):
JPetUserTask(name) {}
TimeCalibLoader::~TimeCalibLoader() {}
bool TimeCalibLoader::init()
{
fOutputEvents = new JPetTimeWindow("JPetSigCh");
auto calibFile = std::string("timeCalib.txt");
if (fParams.getOptions().count(fConfigFileParamKey)) {
calibFile = boost::any_cast<std::string>(fParams.getOptions().at(fConfigFileParamKey));
}
JPetGeomMapping mapper(getParamBank());
auto tombMap = mapper.getTOMBMapping();
fTimeCalibration = TimeCalibTools::loadTimeCalibration(calibFile, tombMap);
if (fTimeCalibration.empty()) {
ERROR("Time calibration seems to be empty");
}
return true;
}
bool TimeCalibLoader::exec()
{
if (auto oldTimeWindow = dynamic_cast<const JPetTimeWindow* const>(fEvent)) {
auto n = oldTimeWindow->getNumberOfEvents();
for(uint i=0;i<n;++i){
JPetSigCh sigCh = dynamic_cast<const JPetSigCh&>(oldTimeWindow->operator[](i));
/// Calibration time is ns so we should change it to ps, cause all the time is in ps.
sigCh.setValue(sigCh.getValue() + 1000. * TimeCalibTools::getTimeCalibCorrection(fTimeCalibration, sigCh.getTOMBChannel().getChannel()));
fOutputEvents->add<JPetSigCh>(sigCh);
}
}else{
return false;
}
return true;
}
bool TimeCalibLoader::terminate()
{
return true;
}
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: gsub.cxx,v $
*
* $Revision: 1.10 $
*
* last change: $Author: hr $ $Date: 2006-06-19 10:24:27 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#include "sft.h"
#undef true
#undef false
#include "gsub.h"
#include <vector>
#include <map>
#include <algorithm>
typedef sal_uInt32 ULONG;
typedef sal_uInt16 USHORT;
typedef sal_uInt8 FT_Byte;
typedef std::map<USHORT,USHORT> GlyphSubstitution;
inline long NEXT_Long( const unsigned char* &p )
{
long nVal = (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3];
p += 4;
return nVal;
}
inline USHORT NEXT_UShort( const unsigned char* &p )
{
USHORT nVal = (p[0]<<8) + p[1];
p += 2;
return nVal;
}
#define MKTAG(s) ((((((s[0]<<8)+s[1])<<8)+s[2])<<8)+s[3])
int ReadGSUB( struct _TrueTypeFont* pTTFile,
int nRequestedScript, int nRequestedLangsys )
{
const FT_Byte* pGsubBase = (FT_Byte*)pTTFile->tables[ O_gsub ];
if( !pGsubBase )
return -1;
// #129682# check offsets inside GSUB table
const FT_Byte* pGsubLimit = pGsubBase + pTTFile->tlens[ O_gsub ];
// parse GSUB header
const FT_Byte* pGsubHeader = pGsubBase;
const ULONG nVersion = NEXT_Long( pGsubHeader );
const USHORT nOfsScriptList = NEXT_UShort( pGsubHeader );
const USHORT nOfsFeatureTable = NEXT_UShort( pGsubHeader );
const USHORT nOfsLookupList = NEXT_UShort( pGsubHeader );
// sanity check the GSUB header
if( nVersion != 0x00010000 )
if( nVersion != 0x00001000 ) // workaround for SunBatang etc.
return -1; // unknown format or broken
typedef std::vector<ULONG> ReqFeatureTagList;
ReqFeatureTagList aReqFeatureTagList;
aReqFeatureTagList.push_back( MKTAG("vert") );
typedef std::vector<USHORT> UshortList;
UshortList aFeatureIndexList;
UshortList aFeatureOffsetList;
// parse Script Table
const FT_Byte* pScriptHeader = pGsubBase + nOfsScriptList;
const USHORT nCntScript = NEXT_UShort( pScriptHeader );
if( pGsubLimit < pScriptHeader + 6 * nCntScript )
return false;
for( USHORT nScriptIndex = 0; nScriptIndex < nCntScript; ++nScriptIndex )
{
const ULONG nTag = NEXT_Long( pScriptHeader ); // e.g. hani/arab/kana/hang
const USHORT nOfsScriptTable= NEXT_UShort( pScriptHeader );
if( (nTag != (USHORT)nRequestedScript) && (nRequestedScript != 0) )
continue;
const FT_Byte* pScriptTable = pGsubBase + nOfsScriptList + nOfsScriptTable;
if( pGsubLimit < pScriptTable + 4 )
return false;
const USHORT nDefaultLangsysOfs = NEXT_UShort( pScriptTable );
const USHORT nCntLangSystem = NEXT_UShort( pScriptTable );
USHORT nLangsysOffset = 0;
if( pGsubLimit < pScriptTable + 6 * nCntLangSystem )
return false;
for( USHORT nLangsysIndex = 0; nLangsysIndex < nCntLangSystem; ++nLangsysIndex )
{
const ULONG nInnerTag = NEXT_Long( pScriptTable ); // e.g. KOR/ZHS/ZHT/JAN
const USHORT nOffset= NEXT_UShort( pScriptTable );
if( (nInnerTag != (USHORT)nRequestedLangsys) && (nRequestedLangsys != 0) )
continue;
nLangsysOffset = nOffset;
break;
}
if( (nDefaultLangsysOfs != 0) && (nDefaultLangsysOfs != nLangsysOffset) )
{
const FT_Byte* pLangSys = pGsubBase + nOfsScriptList + nOfsScriptTable + nDefaultLangsysOfs;
if( pGsubLimit < pLangSys + 6 )
return false;
/*const USHORT nLookupOrder =*/ NEXT_UShort( pLangSys );
const USHORT nReqFeatureIdx = NEXT_UShort( pLangSys );
const USHORT nCntFeature = NEXT_UShort( pLangSys );
if( pGsubLimit < pLangSys + 2 * nCntFeature )
return false;
aFeatureIndexList.push_back( nReqFeatureIdx );
for( USHORT i = 0; i < nCntFeature; ++i )
{
const USHORT nFeatureIndex = NEXT_UShort( pLangSys );
aFeatureIndexList.push_back( nFeatureIndex );
}
}
if( nLangsysOffset != 0 )
{
const FT_Byte* pLangSys = pGsubBase + nOfsScriptList + nOfsScriptTable + nLangsysOffset;
if( pGsubLimit < pLangSys + 6 )
return false;
/*const USHORT nLookupOrder =*/ NEXT_UShort( pLangSys );
const USHORT nReqFeatureIdx = NEXT_UShort( pLangSys );
const USHORT nCntFeature = NEXT_UShort( pLangSys );
if( pGsubLimit < pLangSys + 2 * nCntFeature )
return false;
aFeatureIndexList.push_back( nReqFeatureIdx );
for( USHORT i = 0; i < nCntFeature; ++i )
{
const USHORT nFeatureIndex = NEXT_UShort( pLangSys );
aFeatureIndexList.push_back( nFeatureIndex );
}
}
}
if( !aFeatureIndexList.size() )
return true;
UshortList aLookupIndexList;
UshortList aLookupOffsetList;
// parse Feature Table
const FT_Byte* pFeatureHeader = pGsubBase + nOfsFeatureTable;
if( pGsubLimit < pFeatureHeader + 2 )
return false;
const USHORT nCntFeature = NEXT_UShort( pFeatureHeader );
if( pGsubLimit < pFeatureHeader + 6 * nCntFeature )
return false;
for( USHORT nFeatureIndex = 0; nFeatureIndex < nCntFeature; ++nFeatureIndex )
{
const ULONG nTag = NEXT_Long( pFeatureHeader ); // e.g. locl/vert/trad/smpl/liga/fina/...
const USHORT nOffset= NEXT_UShort( pFeatureHeader );
// feature (required && (requested || available))?
if( (aFeatureIndexList[0] != nFeatureIndex)
&& (!std::count( aReqFeatureTagList.begin(), aReqFeatureTagList.end(), nTag))
|| (!std::count( aFeatureIndexList.begin(), aFeatureIndexList.end(), nFeatureIndex) ) )
continue;
const FT_Byte* pFeatureTable = pGsubBase + nOfsFeatureTable + nOffset;
if( pGsubLimit < pFeatureTable + 2 )
return false;
const USHORT nCntLookups = NEXT_UShort( pFeatureTable );
if( pGsubLimit < pFeatureTable + 2 * nCntLookups )
return false;
for( USHORT i = 0; i < nCntLookups; ++i )
{
const USHORT nLookupIndex = NEXT_UShort( pFeatureTable );
aLookupIndexList.push_back( nLookupIndex );
}
if( nCntLookups == 0 ) //### hack needed by Mincho/Gothic/Mingliu/Simsun/...
aLookupIndexList.push_back( 0 );
}
// parse Lookup List
const FT_Byte* pLookupHeader = pGsubBase + nOfsLookupList;
if( pGsubLimit < pLookupHeader + 2 )
return false;
const USHORT nCntLookupTable = NEXT_UShort( pLookupHeader );
if( pGsubLimit < pLookupHeader + 2 * nCntLookupTable )
return false;
for( USHORT nLookupIdx = 0; nLookupIdx < nCntLookupTable; ++nLookupIdx )
{
const USHORT nOffset = NEXT_UShort( pLookupHeader );
if( std::count( aLookupIndexList.begin(), aLookupIndexList.end(), nLookupIdx ) )
aLookupOffsetList.push_back( nOffset );
}
UshortList::const_iterator it = aLookupOffsetList.begin();
for(; it != aLookupOffsetList.end(); ++it )
{
const USHORT nOfsLookupTable = *it;
const FT_Byte* pLookupTable = pGsubBase + nOfsLookupList + nOfsLookupTable;
if( pGsubLimit < pLookupTable + 6 )
return false;
const USHORT eLookupType = NEXT_UShort( pLookupTable );
/*const USHORT eLookupFlag =*/ NEXT_UShort( pLookupTable );
const USHORT nCntLookupSubtable = NEXT_UShort( pLookupTable );
// TODO: switch( eLookupType )
if( eLookupType != 1 ) // TODO: once we go beyond SingleSubst
continue;
if( pGsubLimit < pLookupTable + 2 * nCntLookupSubtable )
return false;
for( USHORT nSubTableIdx = 0; nSubTableIdx < nCntLookupSubtable; ++nSubTableIdx )
{
const USHORT nOfsSubLookupTable = NEXT_UShort( pLookupTable );
const FT_Byte* pSubLookup = pGsubBase + nOfsLookupList + nOfsLookupTable + nOfsSubLookupTable;
if( pGsubLimit < pSubLookup + 6 )
return false;
const USHORT nFmtSubstitution = NEXT_UShort( pSubLookup );
const USHORT nOfsCoverage = NEXT_UShort( pSubLookup );
typedef std::pair<USHORT,USHORT> GlyphSubst;
typedef std::vector<GlyphSubst> SubstVector;
SubstVector aSubstVector;
const FT_Byte* pCoverage = pGsubBase
+ nOfsLookupList + nOfsLookupTable + nOfsSubLookupTable + nOfsCoverage;
if( pGsubLimit < pCoverage + 4 )
return false;
const USHORT nFmtCoverage = NEXT_UShort( pCoverage );
switch( nFmtCoverage )
{
case 1: // Coverage Format 1
{
const USHORT nCntGlyph = NEXT_UShort( pCoverage );
if( pGsubLimit < pCoverage + 2 * nCntGlyph )
// TODO? nCntGlyph = (pGsubLimit - pCoverage) / 2;
return false;
aSubstVector.reserve( nCntGlyph );
for( USHORT i = 0; i < nCntGlyph; ++i )
{
const USHORT nGlyphId = NEXT_UShort( pCoverage );
aSubstVector.push_back( GlyphSubst( nGlyphId, 0 ) );
}
}
break;
case 2: // Coverage Format 2
{
const USHORT nCntRange = NEXT_UShort( pCoverage );
if( pGsubLimit < pCoverage + 6 * nCntRange )
// TODO? nCntGlyph = (pGsubLimit - pCoverage) / 6;
return false;
for( int i = nCntRange; --i >= 0; )
{
const USHORT nGlyph0 = NEXT_UShort( pCoverage );
const USHORT nGlyph1 = NEXT_UShort( pCoverage );
const USHORT nCovIdx = NEXT_UShort( pCoverage );
for( USHORT j = nGlyph0; j <= nGlyph1; ++j )
aSubstVector.push_back( GlyphSubst( j + nCovIdx, 0 ) );
}
}
break;
}
SubstVector::iterator subst_it( aSubstVector.begin() );
switch( nFmtSubstitution )
{
case 1: // Single Substitution Format 1
{
const USHORT nDeltaGlyphId = NEXT_UShort( pSubLookup );
for(; subst_it != aSubstVector.end(); ++subst_it )
(*subst_it).second = (*subst_it).first + nDeltaGlyphId;
}
break;
case 2: // Single Substitution Format 2
{
const USHORT nCntGlyph = NEXT_UShort( pSubLookup );
for( int i = nCntGlyph; (subst_it != aSubstVector.end()) && (--i>=0); ++subst_it )
{
if( pGsubLimit < pSubLookup + 2 )
return false;
const USHORT nGlyphId = NEXT_UShort( pSubLookup );
(*subst_it).second = nGlyphId;
}
}
break;
}
// now apply the glyph substitutions that have been collected in this subtable
if( aSubstVector.size() > 0 )
{
GlyphSubstitution* pGSubstitution = new GlyphSubstitution;
pTTFile->pGSubstitution = (void*)pGSubstitution;
for( subst_it = aSubstVector.begin(); subst_it != aSubstVector.end(); ++subst_it )
(*pGSubstitution)[ (*subst_it).first ] = (*subst_it).second;
}
}
}
return true;
}
int UseGSUB( struct _TrueTypeFont* pTTFile, int nGlyph, int /*wmode*/ )
{
GlyphSubstitution* pGlyphSubstitution = (GlyphSubstitution*)pTTFile->pGSubstitution;
if( pGlyphSubstitution != 0 )
{
GlyphSubstitution::const_iterator it( pGlyphSubstitution->find( sal::static_int_cast<USHORT>(nGlyph) ) );
if( it != pGlyphSubstitution->end() )
nGlyph = (*it).second;
}
return nGlyph;
}
int HasVerticalGSUB( struct _TrueTypeFont* pTTFile )
{
GlyphSubstitution* pGlyphSubstitution = (GlyphSubstitution*)pTTFile->pGSubstitution;
return pGlyphSubstitution ? +1 : 0;
}
<commit_msg>INTEGRATION: CWS pchfix02 (1.10.20); FILE MERGED 2006/09/01 17:32:54 kaib 1.10.20.1: #i68856# Added header markers and pch files<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: gsub.cxx,v $
*
* $Revision: 1.11 $
*
* last change: $Author: obo $ $Date: 2006-09-16 12:34:33 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_psprint.hxx"
#include "sft.h"
#undef true
#undef false
#include "gsub.h"
#include <vector>
#include <map>
#include <algorithm>
typedef sal_uInt32 ULONG;
typedef sal_uInt16 USHORT;
typedef sal_uInt8 FT_Byte;
typedef std::map<USHORT,USHORT> GlyphSubstitution;
inline long NEXT_Long( const unsigned char* &p )
{
long nVal = (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3];
p += 4;
return nVal;
}
inline USHORT NEXT_UShort( const unsigned char* &p )
{
USHORT nVal = (p[0]<<8) + p[1];
p += 2;
return nVal;
}
#define MKTAG(s) ((((((s[0]<<8)+s[1])<<8)+s[2])<<8)+s[3])
int ReadGSUB( struct _TrueTypeFont* pTTFile,
int nRequestedScript, int nRequestedLangsys )
{
const FT_Byte* pGsubBase = (FT_Byte*)pTTFile->tables[ O_gsub ];
if( !pGsubBase )
return -1;
// #129682# check offsets inside GSUB table
const FT_Byte* pGsubLimit = pGsubBase + pTTFile->tlens[ O_gsub ];
// parse GSUB header
const FT_Byte* pGsubHeader = pGsubBase;
const ULONG nVersion = NEXT_Long( pGsubHeader );
const USHORT nOfsScriptList = NEXT_UShort( pGsubHeader );
const USHORT nOfsFeatureTable = NEXT_UShort( pGsubHeader );
const USHORT nOfsLookupList = NEXT_UShort( pGsubHeader );
// sanity check the GSUB header
if( nVersion != 0x00010000 )
if( nVersion != 0x00001000 ) // workaround for SunBatang etc.
return -1; // unknown format or broken
typedef std::vector<ULONG> ReqFeatureTagList;
ReqFeatureTagList aReqFeatureTagList;
aReqFeatureTagList.push_back( MKTAG("vert") );
typedef std::vector<USHORT> UshortList;
UshortList aFeatureIndexList;
UshortList aFeatureOffsetList;
// parse Script Table
const FT_Byte* pScriptHeader = pGsubBase + nOfsScriptList;
const USHORT nCntScript = NEXT_UShort( pScriptHeader );
if( pGsubLimit < pScriptHeader + 6 * nCntScript )
return false;
for( USHORT nScriptIndex = 0; nScriptIndex < nCntScript; ++nScriptIndex )
{
const ULONG nTag = NEXT_Long( pScriptHeader ); // e.g. hani/arab/kana/hang
const USHORT nOfsScriptTable= NEXT_UShort( pScriptHeader );
if( (nTag != (USHORT)nRequestedScript) && (nRequestedScript != 0) )
continue;
const FT_Byte* pScriptTable = pGsubBase + nOfsScriptList + nOfsScriptTable;
if( pGsubLimit < pScriptTable + 4 )
return false;
const USHORT nDefaultLangsysOfs = NEXT_UShort( pScriptTable );
const USHORT nCntLangSystem = NEXT_UShort( pScriptTable );
USHORT nLangsysOffset = 0;
if( pGsubLimit < pScriptTable + 6 * nCntLangSystem )
return false;
for( USHORT nLangsysIndex = 0; nLangsysIndex < nCntLangSystem; ++nLangsysIndex )
{
const ULONG nInnerTag = NEXT_Long( pScriptTable ); // e.g. KOR/ZHS/ZHT/JAN
const USHORT nOffset= NEXT_UShort( pScriptTable );
if( (nInnerTag != (USHORT)nRequestedLangsys) && (nRequestedLangsys != 0) )
continue;
nLangsysOffset = nOffset;
break;
}
if( (nDefaultLangsysOfs != 0) && (nDefaultLangsysOfs != nLangsysOffset) )
{
const FT_Byte* pLangSys = pGsubBase + nOfsScriptList + nOfsScriptTable + nDefaultLangsysOfs;
if( pGsubLimit < pLangSys + 6 )
return false;
/*const USHORT nLookupOrder =*/ NEXT_UShort( pLangSys );
const USHORT nReqFeatureIdx = NEXT_UShort( pLangSys );
const USHORT nCntFeature = NEXT_UShort( pLangSys );
if( pGsubLimit < pLangSys + 2 * nCntFeature )
return false;
aFeatureIndexList.push_back( nReqFeatureIdx );
for( USHORT i = 0; i < nCntFeature; ++i )
{
const USHORT nFeatureIndex = NEXT_UShort( pLangSys );
aFeatureIndexList.push_back( nFeatureIndex );
}
}
if( nLangsysOffset != 0 )
{
const FT_Byte* pLangSys = pGsubBase + nOfsScriptList + nOfsScriptTable + nLangsysOffset;
if( pGsubLimit < pLangSys + 6 )
return false;
/*const USHORT nLookupOrder =*/ NEXT_UShort( pLangSys );
const USHORT nReqFeatureIdx = NEXT_UShort( pLangSys );
const USHORT nCntFeature = NEXT_UShort( pLangSys );
if( pGsubLimit < pLangSys + 2 * nCntFeature )
return false;
aFeatureIndexList.push_back( nReqFeatureIdx );
for( USHORT i = 0; i < nCntFeature; ++i )
{
const USHORT nFeatureIndex = NEXT_UShort( pLangSys );
aFeatureIndexList.push_back( nFeatureIndex );
}
}
}
if( !aFeatureIndexList.size() )
return true;
UshortList aLookupIndexList;
UshortList aLookupOffsetList;
// parse Feature Table
const FT_Byte* pFeatureHeader = pGsubBase + nOfsFeatureTable;
if( pGsubLimit < pFeatureHeader + 2 )
return false;
const USHORT nCntFeature = NEXT_UShort( pFeatureHeader );
if( pGsubLimit < pFeatureHeader + 6 * nCntFeature )
return false;
for( USHORT nFeatureIndex = 0; nFeatureIndex < nCntFeature; ++nFeatureIndex )
{
const ULONG nTag = NEXT_Long( pFeatureHeader ); // e.g. locl/vert/trad/smpl/liga/fina/...
const USHORT nOffset= NEXT_UShort( pFeatureHeader );
// feature (required && (requested || available))?
if( (aFeatureIndexList[0] != nFeatureIndex)
&& (!std::count( aReqFeatureTagList.begin(), aReqFeatureTagList.end(), nTag))
|| (!std::count( aFeatureIndexList.begin(), aFeatureIndexList.end(), nFeatureIndex) ) )
continue;
const FT_Byte* pFeatureTable = pGsubBase + nOfsFeatureTable + nOffset;
if( pGsubLimit < pFeatureTable + 2 )
return false;
const USHORT nCntLookups = NEXT_UShort( pFeatureTable );
if( pGsubLimit < pFeatureTable + 2 * nCntLookups )
return false;
for( USHORT i = 0; i < nCntLookups; ++i )
{
const USHORT nLookupIndex = NEXT_UShort( pFeatureTable );
aLookupIndexList.push_back( nLookupIndex );
}
if( nCntLookups == 0 ) //### hack needed by Mincho/Gothic/Mingliu/Simsun/...
aLookupIndexList.push_back( 0 );
}
// parse Lookup List
const FT_Byte* pLookupHeader = pGsubBase + nOfsLookupList;
if( pGsubLimit < pLookupHeader + 2 )
return false;
const USHORT nCntLookupTable = NEXT_UShort( pLookupHeader );
if( pGsubLimit < pLookupHeader + 2 * nCntLookupTable )
return false;
for( USHORT nLookupIdx = 0; nLookupIdx < nCntLookupTable; ++nLookupIdx )
{
const USHORT nOffset = NEXT_UShort( pLookupHeader );
if( std::count( aLookupIndexList.begin(), aLookupIndexList.end(), nLookupIdx ) )
aLookupOffsetList.push_back( nOffset );
}
UshortList::const_iterator it = aLookupOffsetList.begin();
for(; it != aLookupOffsetList.end(); ++it )
{
const USHORT nOfsLookupTable = *it;
const FT_Byte* pLookupTable = pGsubBase + nOfsLookupList + nOfsLookupTable;
if( pGsubLimit < pLookupTable + 6 )
return false;
const USHORT eLookupType = NEXT_UShort( pLookupTable );
/*const USHORT eLookupFlag =*/ NEXT_UShort( pLookupTable );
const USHORT nCntLookupSubtable = NEXT_UShort( pLookupTable );
// TODO: switch( eLookupType )
if( eLookupType != 1 ) // TODO: once we go beyond SingleSubst
continue;
if( pGsubLimit < pLookupTable + 2 * nCntLookupSubtable )
return false;
for( USHORT nSubTableIdx = 0; nSubTableIdx < nCntLookupSubtable; ++nSubTableIdx )
{
const USHORT nOfsSubLookupTable = NEXT_UShort( pLookupTable );
const FT_Byte* pSubLookup = pGsubBase + nOfsLookupList + nOfsLookupTable + nOfsSubLookupTable;
if( pGsubLimit < pSubLookup + 6 )
return false;
const USHORT nFmtSubstitution = NEXT_UShort( pSubLookup );
const USHORT nOfsCoverage = NEXT_UShort( pSubLookup );
typedef std::pair<USHORT,USHORT> GlyphSubst;
typedef std::vector<GlyphSubst> SubstVector;
SubstVector aSubstVector;
const FT_Byte* pCoverage = pGsubBase
+ nOfsLookupList + nOfsLookupTable + nOfsSubLookupTable + nOfsCoverage;
if( pGsubLimit < pCoverage + 4 )
return false;
const USHORT nFmtCoverage = NEXT_UShort( pCoverage );
switch( nFmtCoverage )
{
case 1: // Coverage Format 1
{
const USHORT nCntGlyph = NEXT_UShort( pCoverage );
if( pGsubLimit < pCoverage + 2 * nCntGlyph )
// TODO? nCntGlyph = (pGsubLimit - pCoverage) / 2;
return false;
aSubstVector.reserve( nCntGlyph );
for( USHORT i = 0; i < nCntGlyph; ++i )
{
const USHORT nGlyphId = NEXT_UShort( pCoverage );
aSubstVector.push_back( GlyphSubst( nGlyphId, 0 ) );
}
}
break;
case 2: // Coverage Format 2
{
const USHORT nCntRange = NEXT_UShort( pCoverage );
if( pGsubLimit < pCoverage + 6 * nCntRange )
// TODO? nCntGlyph = (pGsubLimit - pCoverage) / 6;
return false;
for( int i = nCntRange; --i >= 0; )
{
const USHORT nGlyph0 = NEXT_UShort( pCoverage );
const USHORT nGlyph1 = NEXT_UShort( pCoverage );
const USHORT nCovIdx = NEXT_UShort( pCoverage );
for( USHORT j = nGlyph0; j <= nGlyph1; ++j )
aSubstVector.push_back( GlyphSubst( j + nCovIdx, 0 ) );
}
}
break;
}
SubstVector::iterator subst_it( aSubstVector.begin() );
switch( nFmtSubstitution )
{
case 1: // Single Substitution Format 1
{
const USHORT nDeltaGlyphId = NEXT_UShort( pSubLookup );
for(; subst_it != aSubstVector.end(); ++subst_it )
(*subst_it).second = (*subst_it).first + nDeltaGlyphId;
}
break;
case 2: // Single Substitution Format 2
{
const USHORT nCntGlyph = NEXT_UShort( pSubLookup );
for( int i = nCntGlyph; (subst_it != aSubstVector.end()) && (--i>=0); ++subst_it )
{
if( pGsubLimit < pSubLookup + 2 )
return false;
const USHORT nGlyphId = NEXT_UShort( pSubLookup );
(*subst_it).second = nGlyphId;
}
}
break;
}
// now apply the glyph substitutions that have been collected in this subtable
if( aSubstVector.size() > 0 )
{
GlyphSubstitution* pGSubstitution = new GlyphSubstitution;
pTTFile->pGSubstitution = (void*)pGSubstitution;
for( subst_it = aSubstVector.begin(); subst_it != aSubstVector.end(); ++subst_it )
(*pGSubstitution)[ (*subst_it).first ] = (*subst_it).second;
}
}
}
return true;
}
int UseGSUB( struct _TrueTypeFont* pTTFile, int nGlyph, int /*wmode*/ )
{
GlyphSubstitution* pGlyphSubstitution = (GlyphSubstitution*)pTTFile->pGSubstitution;
if( pGlyphSubstitution != 0 )
{
GlyphSubstitution::const_iterator it( pGlyphSubstitution->find( sal::static_int_cast<USHORT>(nGlyph) ) );
if( it != pGlyphSubstitution->end() )
nGlyph = (*it).second;
}
return nGlyph;
}
int HasVerticalGSUB( struct _TrueTypeFont* pTTFile )
{
GlyphSubstitution* pGlyphSubstitution = (GlyphSubstitution*)pTTFile->pGSubstitution;
return pGlyphSubstitution ? +1 : 0;
}
<|endoftext|> |
<commit_before>
#include "CatGameLib.h"
#include "ExternalLib.h"
#include "LibSound.h"
using namespace std;
using namespace CatGameLib;
int LibSound::loadCount = 0;
unsigned int LibSound::sourceIDs[LoadSoundMax] = { 0 };
unsigned int LibSound::bufferIDs[LoadSoundMax] = { 0 };
LibSound* LibSound::create( const char* fileName)
{
LibSound* sound = new (nothrow)LibSound();
if( sound == nullptr)
{
return nullptr;
}
sound -> loadFile( fileName);
return sound;
}
void LibSound::allRelease( void)
{
alSourceStopv( loadCount, sourceIDs);
alDeleteSources( loadCount, sourceIDs);
alDeleteBuffers( loadCount, bufferIDs);
loadCount = 0;
}
LibSound::LibSound() : sourceID( 0),
bufferID( 0)
{
}
LibSound::~LibSound()
{
stop();
alDeleteSources( 1, &sourceIDs[sourceID]);
alDeleteBuffers( 1, &bufferIDs[bufferID]);
}
void LibSound::setLoop( bool isLoop)
{
alSourcei( sourceIDs[sourceID], AL_LOOPING, isLoop);
}
void LibSound::setVolume( float vol)
{
alSourcef( sourceIDs[sourceID], AL_GAIN, LibBasicFunc::clamp( vol, 0.0f, 1.0f));
}
void LibSound::play( void)
{
alSourcePlay( sourceIDs[sourceID]);
}
void LibSound::pause( void)
{
alSourcePause( sourceIDs[sourceID]);
}
void LibSound::stop( void)
{
alSourceStop( sourceIDs[sourceID]);
}
void LibSound::restart( void)
{
stop();
play();
}
void LibSound::loadFile( const char* fileName)
{
string filePass = "ResourceFile/Sound/";
filePass += fileName;
// \[X쐬
alGenSources( 1, &sourceIDs[loadCount]);
// obt@쐬
bufferIDs[loadCount] = alureCreateBufferFromFile( filePass.c_str());
if( bufferIDs[loadCount] == AL_NONE)
{
std::cout << "Failed to load from file!" << std::endl;
}
// w肵ԍۑ
sourceID = loadCount;
bufferID = loadCount;
// JEgXV
loadCount++;
// obt@ɐݒ
alSourcei( sourceIDs[sourceID], AL_BUFFER, bufferIDs[bufferID]);
// ʂ
alSourcef( sourceIDs[sourceID], AL_GAIN, 0.5f);
}
<commit_msg>サウンドクラスのエラー処置の不備を修正<commit_after>
#include "CatGameLib.h"
#include "ExternalLib.h"
#include "LibSound.h"
using namespace std;
using namespace CatGameLib;
int LibSound::loadCount = 0;
unsigned int LibSound::sourceIDs[LoadSoundMax] = { 0 };
unsigned int LibSound::bufferIDs[LoadSoundMax] = { 0 };
LibSound* LibSound::create( const char* fileName)
{
LibSound* sound = new (nothrow)LibSound();
if( sound == nullptr)
{
return nullptr;
}
sound -> loadFile( fileName);
return sound;
}
void LibSound::allRelease( void)
{
alSourceStopv( loadCount, sourceIDs);
alDeleteSources( loadCount, sourceIDs);
alDeleteBuffers( loadCount, bufferIDs);
loadCount = 0;
}
LibSound::LibSound() : sourceID( 0),
bufferID( 0)
{
}
LibSound::~LibSound()
{
stop();
alDeleteSources( 1, &sourceIDs[sourceID]);
alDeleteBuffers( 1, &bufferIDs[bufferID]);
}
void LibSound::setLoop( bool isLoop)
{
alSourcei( sourceIDs[sourceID], AL_LOOPING, isLoop);
}
void LibSound::setVolume( float vol)
{
alSourcef( sourceIDs[sourceID], AL_GAIN, LibBasicFunc::clamp( vol, 0.0f, 1.0f));
}
void LibSound::play( void)
{
alSourcePlay( sourceIDs[sourceID]);
}
void LibSound::pause( void)
{
alSourcePause( sourceIDs[sourceID]);
}
void LibSound::stop( void)
{
alSourceStop( sourceIDs[sourceID]);
}
void LibSound::restart( void)
{
stop();
play();
}
void LibSound::loadFile( const char* fileName)
{
string filePass = "ResourceFile/Sound/";
filePass += fileName;
// \[X쐬
alGenSources( 1, &sourceIDs[loadCount]);
// obt@쐬
bufferIDs[loadCount] = alureCreateBufferFromFile( filePass.c_str());
if( bufferIDs[loadCount] == AL_NONE)
{
string message = "can't load from ";
message += fileName;
LibDebug::errorMessageBox( message.c_str());
}
// w肵ԍۑ
sourceID = loadCount;
bufferID = loadCount;
// JEgXV
loadCount++;
// obt@ɐݒ
alSourcei( sourceIDs[sourceID], AL_BUFFER, bufferIDs[bufferID]);
// ʂ
alSourcef( sourceIDs[sourceID], AL_GAIN, 0.5f);
}
<|endoftext|> |
<commit_before>#ifndef DUNE_DETAILED_DISCRETIZATIONS_ASSEMLBER_LOCAL_CODIM0_HH
#define DUNE_DETAILED_DISCRETIZATIONS_ASSEMLBER_LOCAL_CODIM0_HH
#include <vector>
#include <dune/common/dynmatrix.hh>
#include <dune/common/dynvector.hh>
#include <dune/stuff/common/matrix.hh>
#include <dune/stuff/la/container/interface.hh>
#include <dune/detailed/discretizations/localoperator/codim0.hh>
#include <dune/detailed/discretizations/space/interface.hh>
namespace Dune {
namespace Detailed {
namespace Discretizations {
// forward, to be used in the traits
template <class LocalOperatorImp>
class LocalAssemblerCodim0Matrix;
template <class LocalOperatorImp>
class LocalAssemblerCodim0MatrixTraits
{
public:
typedef LocalAssemblerCodim0Matrix<LocalOperatorImp> derived_type;
typedef LocalOperatorCodim0Interface<typename LocalOperatorImp::Traits> LocalOperatorType;
}; // class LocalAssemblerCodim0MatrixTraits
template <class LocalOperatorImp>
class LocalAssemblerCodim0Matrix
{
public:
typedef LocalAssemblerCodim0MatrixTraits<LocalOperatorImp> Traits;
typedef typename Traits::LocalOperatorType LocalOperatorType;
LocalAssemblerCodim0Matrix(const LocalOperatorType& op)
: localOperator_(op)
{
}
const LocalOperatorType& localOperator() const
{
return localOperator_;
}
private:
static const size_t numTmpObjectsRequired_ = 1;
public:
std::vector<size_t> numTmpObjectsRequired() const
{
return {numTmpObjectsRequired_, localOperator_.numTmpObjectsRequired()};
}
/**
* \tparam T Traits of the SpaceInterface implementation, representing the type of testSpace
* \tparam A
* \tparam EntityType
* \tparam M
* \tparam L
*/
template <class T, class A, class EntityType, class M, class R>
void assembleLocal(const SpaceInterface<T>& testSpace, const SpaceInterface<A>& ansatzSpace, const EntityType& entity,
Dune::Stuff::LA::Container::MatrixInterface<M>& systemMatrix,
std::vector<std::vector<Dune::DynamicMatrix<R>>>& tmpLocalMatricesContainer,
std::vector<Dune::DynamicVector<size_t>>& tmpIndicesContainer) const
{
// check
assert(tmpLocalMatricesContainer.size() >= 1);
assert(tmpLocalMatricesContainer[0].size() >= numTmpObjectsRequired_);
assert(tmpLocalMatricesContainer[1].size() >= localOperator_.numTmpObjectsRequired());
assert(tmpIndicesContainer.size() >= 2);
// get and clear matrix
auto& localMatrix = tmpLocalMatricesContainer[0][0];
Dune::Stuff::Common::clear(localMatrix);
auto& tmpOperatorMatrices = tmpLocalMatricesContainer[1];
// apply local operator (result is in localMatrix)
localOperator_.apply(
testSpace.baseFunctionSet(entity), ansatzSpace.baseFunctionSet(entity), localMatrix, tmpOperatorMatrices);
// write local matrix to global
auto& globalRows = tmpIndicesContainer[0];
auto& globalCols = tmpIndicesContainer[1];
const size_t rows = testSpace.mapper().numDofs(entity);
const size_t cols = ansatzSpace.mapper().numDofs(entity);
assert(globalRows.size() >= rows);
assert(globalCols.size() >= cols);
testSpace.mapper().globalIndices(entity, globalRows);
ansatzSpace.mapper().globalIndices(entity, globalCols);
for (size_t ii = 0; ii < rows; ++ii) {
const auto& localRow = localMatrix[ii];
for (size_t jj = 0; jj < cols; ++jj)
systemMatrix.set(globalRows[ii], globalCols[jj], localRow[jj]);
} // write local matrix to global
} // ... assembleLocal(...)
private:
const LocalOperatorType& localOperator_;
}; // class LocalAssemblerCodim0Matrix
} // namespace Discretizations
} // namespace Detailed
} // namespace Dune
#endif // DUNE_DETAILED_DISCRETIZATIONS_ASSEMLBER_LOCAL_CODIM0_HH
<commit_msg>[assembler.local.codim0] fixed wrong matrix filling (add instead of set)<commit_after>#ifndef DUNE_DETAILED_DISCRETIZATIONS_ASSEMLBER_LOCAL_CODIM0_HH
#define DUNE_DETAILED_DISCRETIZATIONS_ASSEMLBER_LOCAL_CODIM0_HH
#include <vector>
#include <dune/common/dynmatrix.hh>
#include <dune/common/dynvector.hh>
#include <dune/stuff/common/matrix.hh>
#include <dune/stuff/la/container/interface.hh>
#include <dune/detailed/discretizations/localoperator/codim0.hh>
#include <dune/detailed/discretizations/space/interface.hh>
namespace Dune {
namespace Detailed {
namespace Discretizations {
// forward, to be used in the traits
template <class LocalOperatorImp>
class LocalAssemblerCodim0Matrix;
template <class LocalOperatorImp>
class LocalAssemblerCodim0MatrixTraits
{
public:
typedef LocalAssemblerCodim0Matrix<LocalOperatorImp> derived_type;
typedef LocalOperatorCodim0Interface<typename LocalOperatorImp::Traits> LocalOperatorType;
}; // class LocalAssemblerCodim0MatrixTraits
template <class LocalOperatorImp>
class LocalAssemblerCodim0Matrix
{
public:
typedef LocalAssemblerCodim0MatrixTraits<LocalOperatorImp> Traits;
typedef typename Traits::LocalOperatorType LocalOperatorType;
LocalAssemblerCodim0Matrix(const LocalOperatorType& op)
: localOperator_(op)
{
}
const LocalOperatorType& localOperator() const
{
return localOperator_;
}
private:
static const size_t numTmpObjectsRequired_ = 1;
public:
std::vector<size_t> numTmpObjectsRequired() const
{
return {numTmpObjectsRequired_, localOperator_.numTmpObjectsRequired()};
}
/**
* \tparam T Traits of the SpaceInterface implementation, representing the type of testSpace
* \tparam A Traits of the SpaceInterface implementation, representing the type of ansatzSpace
* \tparam EntityType A model of Dune::Entity< 0 >
* \tparam M Traits of the Dune::Stuff::LA::Container::MatrixInterface implementation, representing the
* type of systemMatrix
* \tparam R RangeFieldType, i.e. double
*/
template <class T, class A, class EntityType, class M, class R>
void assembleLocal(const SpaceInterface<T>& testSpace, const SpaceInterface<A>& ansatzSpace, const EntityType& entity,
Dune::Stuff::LA::Container::MatrixInterface<M>& systemMatrix,
std::vector<std::vector<Dune::DynamicMatrix<R>>>& tmpLocalMatricesContainer,
std::vector<Dune::DynamicVector<size_t>>& tmpIndicesContainer) const
{
// check
assert(tmpLocalMatricesContainer.size() >= 1);
assert(tmpLocalMatricesContainer[0].size() >= numTmpObjectsRequired_);
assert(tmpLocalMatricesContainer[1].size() >= localOperator_.numTmpObjectsRequired());
assert(tmpIndicesContainer.size() >= 2);
// get and clear matrix
auto& localMatrix = tmpLocalMatricesContainer[0][0];
Dune::Stuff::Common::clear(localMatrix);
auto& tmpOperatorMatrices = tmpLocalMatricesContainer[1];
// apply local operator (result is in localMatrix)
localOperator_.apply(
testSpace.baseFunctionSet(entity), ansatzSpace.baseFunctionSet(entity), localMatrix, tmpOperatorMatrices);
// write local matrix to global
auto& globalRows = tmpIndicesContainer[0];
auto& globalCols = tmpIndicesContainer[1];
const size_t rows = testSpace.mapper().numDofs(entity);
const size_t cols = ansatzSpace.mapper().numDofs(entity);
assert(globalRows.size() >= rows);
assert(globalCols.size() >= cols);
testSpace.mapper().globalIndices(entity, globalRows);
ansatzSpace.mapper().globalIndices(entity, globalCols);
for (size_t ii = 0; ii < rows; ++ii) {
const auto& localRow = localMatrix[ii];
for (size_t jj = 0; jj < cols; ++jj)
systemMatrix.add(globalRows[ii], globalCols[jj], localRow[jj]);
} // write local matrix to global
} // ... assembleLocal(...)
private:
const LocalOperatorType& localOperator_;
}; // class LocalAssemblerCodim0Matrix
} // namespace Discretizations
} // namespace Detailed
} // namespace Dune
#endif // DUNE_DETAILED_DISCRETIZATIONS_ASSEMLBER_LOCAL_CODIM0_HH
<|endoftext|> |
<commit_before>// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "update_engine/dbus_service.h"
#include <string>
#include <base/logging.h>
#include "update_engine/marshal.glibmarshal.h"
#include "update_engine/omaha_request_params.h"
#include "update_engine/utils.h"
using std::string;
G_DEFINE_TYPE(UpdateEngineService, update_engine_service, G_TYPE_OBJECT)
static void update_engine_service_finalize(GObject* object) {
G_OBJECT_CLASS(update_engine_service_parent_class)->finalize(object);
}
static guint status_update_signal = 0;
static void update_engine_service_class_init(UpdateEngineServiceClass* klass) {
GObjectClass *object_class;
object_class = G_OBJECT_CLASS(klass);
object_class->finalize = update_engine_service_finalize;
status_update_signal = g_signal_new(
"status_update",
G_OBJECT_CLASS_TYPE(klass),
G_SIGNAL_RUN_LAST,
0, // 0 == no class method associated
NULL, // Accumulator
NULL, // Accumulator data
update_engine_VOID__INT64_DOUBLE_STRING_STRING_INT64,
G_TYPE_NONE, // Return type
5, // param count:
G_TYPE_INT64,
G_TYPE_DOUBLE,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT64);
}
static void update_engine_service_init(UpdateEngineService* object) {
}
UpdateEngineService* update_engine_service_new(void) {
return reinterpret_cast<UpdateEngineService*>(
g_object_new(UPDATE_ENGINE_TYPE_SERVICE, NULL));
}
gboolean update_engine_service_attempt_update(UpdateEngineService* self,
gchar* app_version,
gchar* omaha_url,
GError **error) {
string update_app_version;
string update_omaha_url;
// Only non-official (e.g., dev and test) builds can override the current
// version and update server URL over D-Bus.
if (!chromeos_update_engine::utils::IsOfficialBuild()) {
if (app_version) {
update_app_version = app_version;
}
if (omaha_url) {
update_omaha_url = omaha_url;
}
}
LOG(INFO) << "Attempt update: app_version=\"" << update_app_version << "\" "
<< "omaha_url=\"" << update_omaha_url << "\"";
self->update_attempter_->CheckForUpdate(update_app_version, update_omaha_url);
return TRUE;
}
gboolean update_engine_service_get_status(UpdateEngineService* self,
int64_t* last_checked_time,
double* progress,
gchar** current_operation,
gchar** new_version,
int64_t* new_size,
GError **error) {
string current_op;
string new_version_str;
CHECK(self->update_attempter_->GetStatus(last_checked_time,
progress,
¤t_op,
&new_version_str,
new_size));
*current_operation = strdup(current_op.c_str());
*new_version = strdup(new_version_str.c_str());
if (!(*current_operation && *new_version)) {
*error = NULL;
return FALSE;
}
return TRUE;
}
gboolean update_engine_service_get_track(UpdateEngineService* self,
gchar** track,
GError **error) {
string track_str =
chromeos_update_engine::OmahaRequestDeviceParams::GetDeviceTrack();
*track = strdup(track_str.c_str());
return TRUE;
}
gboolean update_engine_service_reboot_if_needed(UpdateEngineService* self,
GError **error) {
if (!self->update_attempter_->RebootIfNeeded()) {
*error = NULL;
return FALSE;
}
return TRUE;
}
gboolean update_engine_service_set_track(UpdateEngineService* self,
gchar* track,
GError **error) {
if (track) {
LOG(INFO) << "Setting track to: " << track;
if (!chromeos_update_engine::OmahaRequestDeviceParams::SetDeviceTrack(
track)) {
*error = NULL;
return FALSE;
}
}
return TRUE;
}
gboolean update_engine_service_emit_status_update(
UpdateEngineService* self,
gint64 last_checked_time,
gdouble progress,
const gchar* current_operation,
const gchar* new_version,
gint64 new_size) {
g_signal_emit(self,
status_update_signal,
0,
last_checked_time,
progress,
current_operation,
new_version,
new_size);
return TRUE;
}
<commit_msg>Use g_strdup() instead of strdup().<commit_after>// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "update_engine/dbus_service.h"
#include <string>
#include <base/logging.h>
#include "update_engine/marshal.glibmarshal.h"
#include "update_engine/omaha_request_params.h"
#include "update_engine/utils.h"
using std::string;
G_DEFINE_TYPE(UpdateEngineService, update_engine_service, G_TYPE_OBJECT)
static void update_engine_service_finalize(GObject* object) {
G_OBJECT_CLASS(update_engine_service_parent_class)->finalize(object);
}
static guint status_update_signal = 0;
static void update_engine_service_class_init(UpdateEngineServiceClass* klass) {
GObjectClass *object_class;
object_class = G_OBJECT_CLASS(klass);
object_class->finalize = update_engine_service_finalize;
status_update_signal = g_signal_new(
"status_update",
G_OBJECT_CLASS_TYPE(klass),
G_SIGNAL_RUN_LAST,
0, // 0 == no class method associated
NULL, // Accumulator
NULL, // Accumulator data
update_engine_VOID__INT64_DOUBLE_STRING_STRING_INT64,
G_TYPE_NONE, // Return type
5, // param count:
G_TYPE_INT64,
G_TYPE_DOUBLE,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT64);
}
static void update_engine_service_init(UpdateEngineService* object) {
}
UpdateEngineService* update_engine_service_new(void) {
return reinterpret_cast<UpdateEngineService*>(
g_object_new(UPDATE_ENGINE_TYPE_SERVICE, NULL));
}
gboolean update_engine_service_attempt_update(UpdateEngineService* self,
gchar* app_version,
gchar* omaha_url,
GError **error) {
string update_app_version;
string update_omaha_url;
// Only non-official (e.g., dev and test) builds can override the current
// version and update server URL over D-Bus.
if (!chromeos_update_engine::utils::IsOfficialBuild()) {
if (app_version) {
update_app_version = app_version;
}
if (omaha_url) {
update_omaha_url = omaha_url;
}
}
LOG(INFO) << "Attempt update: app_version=\"" << update_app_version << "\" "
<< "omaha_url=\"" << update_omaha_url << "\"";
self->update_attempter_->CheckForUpdate(update_app_version, update_omaha_url);
return TRUE;
}
gboolean update_engine_service_get_status(UpdateEngineService* self,
int64_t* last_checked_time,
double* progress,
gchar** current_operation,
gchar** new_version,
int64_t* new_size,
GError **error) {
string current_op;
string new_version_str;
CHECK(self->update_attempter_->GetStatus(last_checked_time,
progress,
¤t_op,
&new_version_str,
new_size));
*current_operation = g_strdup(current_op.c_str());
*new_version = g_strdup(new_version_str.c_str());
if (!(*current_operation && *new_version)) {
*error = NULL;
return FALSE;
}
return TRUE;
}
gboolean update_engine_service_get_track(UpdateEngineService* self,
gchar** track,
GError **error) {
string track_str =
chromeos_update_engine::OmahaRequestDeviceParams::GetDeviceTrack();
*track = g_strdup(track_str.c_str());
return TRUE;
}
gboolean update_engine_service_reboot_if_needed(UpdateEngineService* self,
GError **error) {
if (!self->update_attempter_->RebootIfNeeded()) {
*error = NULL;
return FALSE;
}
return TRUE;
}
gboolean update_engine_service_set_track(UpdateEngineService* self,
gchar* track,
GError **error) {
if (track) {
LOG(INFO) << "Setting track to: " << track;
if (!chromeos_update_engine::OmahaRequestDeviceParams::SetDeviceTrack(
track)) {
*error = NULL;
return FALSE;
}
}
return TRUE;
}
gboolean update_engine_service_emit_status_update(
UpdateEngineService* self,
gint64 last_checked_time,
gdouble progress,
const gchar* current_operation,
const gchar* new_version,
gint64 new_size) {
g_signal_emit(self,
status_update_signal,
0,
last_checked_time,
progress,
current_operation,
new_version,
new_size);
return TRUE;
}
<|endoftext|> |
<commit_before>#include <iostream>
#include <sstream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cassert>
#include "logger.hpp"
#include "lexer.hpp"
#include "parser.hpp"
#include "environment.hpp"
#include "direct_interpreter.hpp"
// convert double to percent string
std::string format_probability(double prob)
{
if (prob < 0.0001 && prob != 0)
{
return "< 0.01 %";
}
return std::to_string(prob * 100) + " %";
}
// value formatting functions
class formatting_visitor : public dice::value_visitor
{
public:
void visit(dice::type_int* value) override
{
std::cout << value->data() << std::endl;
}
void visit(dice::type_double* value) override
{
std::cout << value->data() << std::endl;
}
void visit(dice::type_rand_var* value) override
{
const int width_value = 10;
const int width_prob = 15;
const int width_cdf = 15;
// print table header
std::cout << std::endl
<< std::setw(width_value) << "Value"
<< std::setw(width_prob) << "PMF"
<< std::setw(width_cdf) << "CDF"
<< std::endl;
// sort PMF by value
auto probability = value->data().to_random_variable().probability();
dice::random_variable<int, double>::probability_list values{
probability.begin(),
probability.end()
};
std::sort(values.begin(), values.end(), [](auto&& a, auto&& b)
{
return a.first < b.first;
});
// print the random variable
if (values.empty())
return;
double sum = 0;
for (auto it = values.begin(); it != values.end(); ++it)
{
sum += it->second;
std::cout
<< std::setw(width_value) << it->first
<< std::setw(width_prob) << format_probability(it->second)
<< std::setw(width_cdf) << format_probability(sum)
<< std::endl;
}
}
};
struct options
{
// Command line arguments
std::vector<std::string> args;
// Input stream
std::istream* input;
// Should we print the executed script?
bool verbose;
options(int argc, char** argv) :
args(argv, argv + argc),
input(nullptr),
verbose(false)
{
parse();
}
private:
std::ifstream input_file_;
std::stringstream input_mem_;
void parse()
{
auto it = args.begin() + 1; // first arg is the file path
bool load_from_file = false;
for (; it != args.end(); ++it)
{
if (*it == "-f") // input file
{
assert(it + 1 != args.end());
++it;
input_file_.open(*it);
input = &input_file_;
load_from_file = true;
}
else if (*it == "-v")
{
verbose = true;
}
else
{
break;
}
}
// load from arguments - concatenate the rest of the args
if (!load_from_file && it != args.end())
{
std::string expr = *it++;
for (; it != args.end(); ++it)
expr += " " + *it;
input_mem_ = std::stringstream{ expr };
input = &input_mem_;
}
}
};
int main(int argc, char** argv)
{
options opt{ argc, argv };
if (opt.input != nullptr)
{
// parse and interpret the expression
dice::logger log;
dice::lexer lexer{ opt.input, &log };
dice::environment env;
dice::direct_interpreter<dice::environment> interpret{ &env };
auto parser = dice::make_parser(&lexer, &log, &interpret);
auto result = parser.parse();
formatting_visitor format;
for (auto&& value : result)
{
if (value == nullptr)
continue;
value->accept(&format);
}
if (!log.empty())
return 1;
}
else
{
std::cerr << "Dice expressions interpreter." << std::endl
<< std::endl
<< "Usage:" << std::endl
<< " ./dice_cli [options] [expression]" << std::endl
<< std::endl
<< " [options]:" << std::endl
<< " -f <file> load expression from file" << std::endl
<< " -v verbose output (show executed script)" << std::endl
<< std::endl
<< " [expression]:" << std::endl
<< " A dice expression. Can be in multiple arguments." << std::endl
<< " The program will join them wih a space." << std::endl;
return 1;
}
return 0;
}<commit_msg>Add execution time<commit_after>#include <iostream>
#include <sstream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cassert>
#include <chrono>
#include "logger.hpp"
#include "lexer.hpp"
#include "parser.hpp"
#include "environment.hpp"
#include "direct_interpreter.hpp"
// convert double to percent string
std::string format_probability(double prob)
{
if (prob < 0.0001 && prob != 0)
{
return "< 0.01 %";
}
return std::to_string(prob * 100) + " %";
}
// value formatting functions
class formatting_visitor : public dice::value_visitor
{
public:
void visit(dice::type_int* value) override
{
std::cout << value->data() << std::endl;
}
void visit(dice::type_double* value) override
{
std::cout << value->data() << std::endl;
}
void visit(dice::type_rand_var* value) override
{
const int width_value = 10;
const int width_prob = 15;
const int width_cdf = 15;
// print table header
std::cout << std::endl
<< std::setw(width_value) << "Value"
<< std::setw(width_prob) << "PMF"
<< std::setw(width_cdf) << "CDF"
<< std::endl;
// sort PMF by value
auto probability = value->data().to_random_variable().probability();
dice::random_variable<int, double>::probability_list values{
probability.begin(),
probability.end()
};
std::sort(values.begin(), values.end(), [](auto&& a, auto&& b)
{
return a.first < b.first;
});
// print the random variable
if (values.empty())
return;
double sum = 0;
for (auto it = values.begin(); it != values.end(); ++it)
{
sum += it->second;
std::cout
<< std::setw(width_value) << it->first
<< std::setw(width_prob) << format_probability(it->second)
<< std::setw(width_cdf) << format_probability(sum)
<< std::endl;
}
}
};
struct options
{
// Command line arguments
std::vector<std::string> args;
// Input stream
std::istream* input;
// Should we print the executed script?
bool verbose;
options(int argc, char** argv) :
args(argv, argv + argc),
input(nullptr),
verbose(false)
{
parse();
}
private:
std::ifstream input_file_;
std::stringstream input_mem_;
void parse()
{
auto it = args.begin() + 1; // first arg is the file path
bool load_from_file = false;
for (; it != args.end(); ++it)
{
if (*it == "-f") // input file
{
assert(it + 1 != args.end());
++it;
input_file_.open(*it);
input = &input_file_;
load_from_file = true;
}
else if (*it == "-v")
{
verbose = true;
}
else
{
break;
}
}
// load from arguments - concatenate the rest of the args
if (!load_from_file && it != args.end())
{
std::string expr = *it++;
for (; it != args.end(); ++it)
expr += " " + *it;
input_mem_ = std::stringstream{ expr };
input = &input_mem_;
}
}
};
int main(int argc, char** argv)
{
options opt{ argc, argv };
if (opt.input != nullptr)
{
// parse and interpret the expression
dice::logger log;
dice::lexer lexer{ opt.input, &log };
dice::environment env;
dice::direct_interpreter<dice::environment> interpret{ &env };
auto parser = dice::make_parser(&lexer, &log, &interpret);
auto start = std::chrono::high_resolution_clock::now();
auto result = parser.parse();
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
formatting_visitor format;
for (auto&& value : result)
{
if (value == nullptr)
continue;
value->accept(&format);
}
std::cout << "Evaluated in " << duration << " ms" << std::endl;
if (!log.empty())
return 1;
}
else
{
std::cerr << "Dice expressions interpreter." << std::endl
<< std::endl
<< "Usage:" << std::endl
<< " ./dice_cli [options] [expression]" << std::endl
<< std::endl
<< " [options]:" << std::endl
<< " -f <file> load expression from file" << std::endl
<< " -v verbose output (show executed script)" << std::endl
<< std::endl
<< " [expression]:" << std::endl
<< " A dice expression. Can be in multiple arguments." << std::endl
<< " The program will join them wih a space." << std::endl;
return 1;
}
return 0;
}<|endoftext|> |
<commit_before>#include <avr/io.h>
#include <util/delay.h>
#include "output/PWMOut.h"
PWMOut pwm0(&TCCR0A, &TCCR0B, &OCR0A, &DDRB, PB0, COM0A0, COM0A1);
PWMOut pwm1(&TCCR0A, &TCCR0B, &OCR0B, &DDRB, PB1, COM0B0, COM0B1);
int main(void) {
uint8_t x;
while (1) {
for (x = 0; x < 255; x++) {
pwm0.write(x);
pwm1.write(255 - x);
_delay_ms(4);
}
for (x = 255; x > 0; x--) {
pwm0.write(x);
pwm1.write(255 - x);
_delay_ms(4);
}
}
}
<commit_msg>first try on pin change interrupts<commit_after>#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "output/PWMOut.h"
#include "output/DOut.h"
PWMOut pwm0(&TCCR0A, &TCCR0B, &OCR0A, &DDRB, PB0, COM0A0, COM0A1);
DOut led1(&PORTB, &DDRB, PB1);
//PWMOut pwm1(&TCCR0A, &TCCR0B, &OCR0B, &DDRB, PB1, COM0B0, COM0B1);
int main(void) {
cli();
GIMSK |= (1 << PCIE); // turns on pin change interrupts
PCMSK |= (1 << PCINT3); // turn on interrupts on pins PB2,
sei();
DDRB &= ~(1 << PB3); // PB3 as input
PORTB |= (1 << PB3); // internal pullup pb3
uint8_t x;
while (1) {
for (x = 0; x < 255; x++) {
pwm0.write(x);
_delay_ms(4);
}
_delay_ms(1000);
}
}
ISR(PCINT0_vect) {
if (!(PINB & (1 << PB3))) {
led1.toggle();
}
}<|endoftext|> |
<commit_before>/*
* Copyright (c) 2004 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "base/misc.hh"
#include "dev/etherpkt.hh"
#include "sim/serialize.hh"
using namespace std;
void
PacketData::serialize(const string &base, ostream &os)
{
paramOut(os, base + ".length", length);
arrayParamOut(os, base + ".data", data, length);
}
void
PacketData::unserialize(const string &base, Checkpoint *cp,
const string §ion)
{
paramIn(cp, section, base + ".length", length);
arrayParamIn(cp, section, base + ".data", data, length);
}
<commit_msg>Improve checkpointing of ethernet packets a bit.<commit_after>/*
* Copyright (c) 2004 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <iostream>
#include "base/misc.hh"
#include "dev/etherpkt.hh"
#include "sim/serialize.hh"
using namespace std;
void
PacketData::serialize(const string &base, ostream &os)
{
paramOut(os, base + ".length", length);
arrayParamOut(os, base + ".data", data, length);
}
void
PacketData::unserialize(const string &base, Checkpoint *cp,
const string §ion)
{
paramIn(cp, section, base + ".length", length);
if (length)
arrayParamIn(cp, section, base + ".data", data, length);
}
<|endoftext|> |
<commit_before>#include <GL/glew.h> // to load OpenGL extensions at runtime
#include <GLFW/glfw3.h> // to set up the OpenGL context and manage window lifecycle and inputs
#include <stdio.h>
#include <iostream>
/// The main function
int main () {
std::cout << "Hello !" << std::endl;
return 0;
}<commit_msg>Added GLFW initialization and loop<commit_after>#include <GL/glew.h> // to load OpenGL extensions at runtime
#include <GLFW/glfw3.h> // to set up the OpenGL context and manage window lifecycle and inputs
#include <stdio.h>
#include <iostream>
#define INITIAL_SIZE_WIDTH 800
#define INITIAL_SIZE_HEIGHT 600
/// The main function
int main () {
// Initialize glfw, which will create and setup an OpenGL context.
if (!glfwInit()) {
std::cerr << "ERROR: could not start GLFW3" << std::endl;
return 1;
}
// On OS X, the correct OpenGL profile and version to use have to be explicitely defined.
#ifdef __APPLE__
glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
// Create a window with a given size. Width and height are macros as we will need them again.
GLFWwindow* window = glfwCreateWindow(INITIAL_SIZE_WIDTH, INITIAL_SIZE_HEIGHT,"GL_Template", NULL, NULL);
if (!window) {
std::cerr << "ERROR: could not open window with GLFW3" << std::endl;
glfwTerminate();
return 1;
}
// Bind the OpenGL context and the new window.
glfwMakeContextCurrent(window);
// Start the display/interaction loop.
while (!glfwWindowShouldClose(window)) {
// Update the content of the window.
// ...
// Update events (inputs,...).
glfwPollEvents();
}
// Remove the window.
glfwDestroyWindow(window);
// Close GL context and any other GLFW resources.
glfwTerminate();
return 0;
}<|endoftext|> |
<commit_before>// Convert DMD CodeView debug information to PDB files
// Copyright (c) 2009-2010 by Rainer Schuetze, All Rights Reserved
//
// License for redistribution is given by the Artistic License 2.0
// see file LICENSE for further details
#include "PEImage.h"
#include "cv2pdb.h"
#include "symutil.h"
#include <direct.h>
double
#include "../VERSION"
;
#ifdef UNICODE
#define T_toupper towupper
#define T_getdcwd _wgetdcwd
#define T_strlen wcslen
#define T_strcpy wcscpy
#define T_strcat wcscat
#define T_strstr wcsstr
#define T_strncmp wcsncmp
#define T_strtoul wcstoul
#define T_strtod wcstod
#define T_strrchr wcsrchr
#define T_unlink _wremove
#define T_main wmain
#define SARG "%S"
#define T_stat _wstat
#else
#define T_toupper toupper
#define T_getdcwd _getdcwd
#define T_strlen strlen
#define T_strcpy strcpy
#define T_strcat strcat
#define T_strstr strstr
#define T_strncmp strncmp
#define T_strtoul strtoul
#define T_strtod strtod
#define T_strrchr strrchr
#define T_unlink unlink
#define T_main main
#define SARG "%s"
#define T_stat stat
#endif
void fatal(const char *message, ...)
{
va_list argptr;
va_start(argptr, message);
vprintf(message, argptr);
va_end(argptr);
printf("\n");
exit(1);
}
void makefullpath(TCHAR* pdbname)
{
TCHAR* pdbstart = pdbname;
TCHAR fullname[260];
TCHAR* pfullname = fullname;
int drive = 0;
if (pdbname[0] && pdbname[1] == ':')
{
if (pdbname[2] == '\\' || pdbname[2] == '/')
return;
drive = T_toupper (pdbname[0]) - 'A' + 1;
pdbname += 2;
}
else
{
drive = _getdrive();
}
if (*pdbname != '\\' && *pdbname != '/')
{
T_getdcwd(drive, pfullname, sizeof(fullname)/sizeof(fullname[0]) - 2);
pfullname += T_strlen(pfullname);
if (pfullname[-1] != '\\')
*pfullname++ = '\\';
}
else
{
*pfullname++ = 'a' - 1 + drive;
*pfullname++ = ':';
}
T_strcpy(pfullname, pdbname);
T_strcpy(pdbstart, fullname);
for(TCHAR*p = pdbstart; *p; p++)
if (*p == '/')
*p = '\\';
// remove relative parts "./" and "../"
while (TCHAR* p = T_strstr (pdbstart, TEXT("\\.\\")))
T_strcpy(p, p + 2);
while (TCHAR* p = T_strstr (pdbstart, TEXT("\\..\\")))
{
for (TCHAR* q = p - 1; q >= pdbstart; q--)
if (*q == '\\')
{
T_strcpy(q, p + 3);
break;
}
}
}
TCHAR* changeExtension(TCHAR* dbgname, const TCHAR* exename, const TCHAR* ext)
{
T_strcpy(dbgname, exename);
TCHAR *pDot = T_strrchr(dbgname, '.');
if (!pDot || pDot <= T_strrchr(dbgname, '/') || pDot <= T_strrchr(dbgname, '\\'))
T_strcat(dbgname, ext);
else
T_strcpy(pDot, ext);
return dbgname;
}
int T_main(int argc, TCHAR* argv[])
{
double Dversion = 2.072;
const TCHAR* pdbref = 0;
DebugLevel debug = DebugLevel{};
CoInitialize(nullptr);
while (argc > 1 && argv[1][0] == '-')
{
argv++;
argc--;
if (argv[0][1] == '-')
break;
if (argv[0][1] == 'D')
Dversion = T_strtod(argv[0] + 2, 0);
else if (argv[0][1] == 'C')
Dversion = 0;
else if (argv[0][1] == 'n')
demangleSymbols = false;
else if (argv[0][1] == 'e')
useTypedefEnum = true;
else if (!T_strncmp(&argv[0][1], TEXT("debug"), 5)) // debug[level]
{
debug = (DebugLevel)T_strtoul(&argv[0][6], 0, 0);
if (!debug) {
debug = DbgBasic;
}
fprintf(stderr, "Debug set to %x\n", debug);
}
else if (argv[0][1] == 's' && argv[0][2])
dotReplacementChar = (char)argv[0][2];
else if (argv[0][1] == 'p' && argv[0][2])
pdbref = argv[0] + 2;
else
fatal("unknown option: " SARG, argv[0]);
}
if (argc < 2)
{
printf("Convert DMD CodeView/DWARF debug information to PDB files, Version %g\n", VERSION);
printf("Copyright (c) 2009-2012 by Rainer Schuetze, All Rights Reserved\n");
printf("\n");
printf("License for redistribution is given by the Artistic License 2.0\n");
printf("see file LICENSE for further details\n");
printf("\n");
printf("usage: " SARG " [-D<version>|-C|-n|-e|-s<C>|-p<embedded-pdb>] <exe-file> [new-exe-file] [pdb-file]\n", argv[0]);
return -1;
}
PEImage exe, dbg, *img = NULL;
TCHAR dbgname[MAX_PATH];
if (!exe.loadExe(argv[1]))
fatal(SARG ": %s", argv[1], exe.getLastError());
if (exe.countCVEntries() || exe.hasDWARF())
img = &exe;
else
{
// try DBG file alongside executable
changeExtension(dbgname, argv[1], TEXT(".dbg"));
struct _stat buffer;
if (T_stat(dbgname, &buffer) != 0)
fatal(SARG ": no codeview debug entries found", argv[1]);
if (!dbg.loadExe(dbgname))
fatal(SARG ": %s", dbgname, dbg.getLastError());
if (dbg.countCVEntries() == 0)
fatal(SARG ": no codeview debug entries found", dbgname);
img = &dbg;
}
CV2PDB cv2pdb(*img, debug);
cv2pdb.Dversion = Dversion;
cv2pdb.initLibraries();
TCHAR* outname = argv[1];
if (argc > 2 && argv[2][0])
outname = argv[2];
TCHAR pdbname[260];
if (argc > 3)
T_strcpy (pdbname, argv[3]);
else
{
T_strcpy (pdbname, outname);
TCHAR *pDot = T_strrchr (pdbname, '.');
if (!pDot || pDot <= T_strrchr (pdbname, '/') || pDot <= T_strrchr (pdbname, '\\'))
T_strcat (pdbname, TEXT(".pdb"));
else
T_strcpy (pDot, TEXT(".pdb"));
}
makefullpath(pdbname);
T_unlink(pdbname);
if(!cv2pdb.openPDB(pdbname, pdbref))
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if(exe.hasDWARF())
{
if(!exe.relocateDebugLineInfo(0x400000))
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if(!cv2pdb.createDWARFModules())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if(!cv2pdb.addDWARFTypes())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if(!cv2pdb.addDWARFLines())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addDWARFPublics())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.writeDWARFImage(outname))
fatal(SARG ": %s", outname, cv2pdb.getLastError());
}
else
{
if (!cv2pdb.initSegMap())
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if (!cv2pdb.initGlobalSymbols())
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if (!cv2pdb.initGlobalTypes())
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if (!cv2pdb.createModules())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addTypes())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addSymbols())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addSrcLines())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addPublics())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!exe.isDBG())
if (!cv2pdb.writeImage(outname, exe))
fatal(SARG ": %s", outname, cv2pdb.getLastError());
}
return 0;
}
<commit_msg>fix version display<commit_after>// Convert DMD CodeView debug information to PDB files
// Copyright (c) 2009-2010 by Rainer Schuetze, All Rights Reserved
//
// License for redistribution is given by the Artistic License 2.0
// see file LICENSE for further details
#include "PEImage.h"
#include "cv2pdb.h"
#include "symutil.h"
#include <direct.h>
double
#include "../VERSION"
;
#ifdef UNICODE
#define T_toupper towupper
#define T_getdcwd _wgetdcwd
#define T_strlen wcslen
#define T_strcpy wcscpy
#define T_strcat wcscat
#define T_strstr wcsstr
#define T_strncmp wcsncmp
#define T_strtoul wcstoul
#define T_strtod wcstod
#define T_strrchr wcsrchr
#define T_unlink _wremove
#define T_main wmain
#define SARG "%S"
#define T_stat _wstat
#else
#define T_toupper toupper
#define T_getdcwd _getdcwd
#define T_strlen strlen
#define T_strcpy strcpy
#define T_strcat strcat
#define T_strstr strstr
#define T_strncmp strncmp
#define T_strtoul strtoul
#define T_strtod strtod
#define T_strrchr strrchr
#define T_unlink unlink
#define T_main main
#define SARG "%s"
#define T_stat stat
#endif
void fatal(const char *message, ...)
{
va_list argptr;
va_start(argptr, message);
vprintf(message, argptr);
va_end(argptr);
printf("\n");
exit(1);
}
void makefullpath(TCHAR* pdbname)
{
TCHAR* pdbstart = pdbname;
TCHAR fullname[260];
TCHAR* pfullname = fullname;
int drive = 0;
if (pdbname[0] && pdbname[1] == ':')
{
if (pdbname[2] == '\\' || pdbname[2] == '/')
return;
drive = T_toupper (pdbname[0]) - 'A' + 1;
pdbname += 2;
}
else
{
drive = _getdrive();
}
if (*pdbname != '\\' && *pdbname != '/')
{
T_getdcwd(drive, pfullname, sizeof(fullname)/sizeof(fullname[0]) - 2);
pfullname += T_strlen(pfullname);
if (pfullname[-1] != '\\')
*pfullname++ = '\\';
}
else
{
*pfullname++ = 'a' - 1 + drive;
*pfullname++ = ':';
}
T_strcpy(pfullname, pdbname);
T_strcpy(pdbstart, fullname);
for(TCHAR*p = pdbstart; *p; p++)
if (*p == '/')
*p = '\\';
// remove relative parts "./" and "../"
while (TCHAR* p = T_strstr (pdbstart, TEXT("\\.\\")))
T_strcpy(p, p + 2);
while (TCHAR* p = T_strstr (pdbstart, TEXT("\\..\\")))
{
for (TCHAR* q = p - 1; q >= pdbstart; q--)
if (*q == '\\')
{
T_strcpy(q, p + 3);
break;
}
}
}
TCHAR* changeExtension(TCHAR* dbgname, const TCHAR* exename, const TCHAR* ext)
{
T_strcpy(dbgname, exename);
TCHAR *pDot = T_strrchr(dbgname, '.');
if (!pDot || pDot <= T_strrchr(dbgname, '/') || pDot <= T_strrchr(dbgname, '\\'))
T_strcat(dbgname, ext);
else
T_strcpy(pDot, ext);
return dbgname;
}
int T_main(int argc, TCHAR* argv[])
{
double Dversion = 2.072;
const TCHAR* pdbref = 0;
DebugLevel debug = DebugLevel{};
CoInitialize(nullptr);
while (argc > 1 && argv[1][0] == '-')
{
argv++;
argc--;
if (argv[0][1] == '-')
break;
if (argv[0][1] == 'D')
Dversion = T_strtod(argv[0] + 2, 0);
else if (argv[0][1] == 'C')
Dversion = 0;
else if (argv[0][1] == 'n')
demangleSymbols = false;
else if (argv[0][1] == 'e')
useTypedefEnum = true;
else if (!T_strncmp(&argv[0][1], TEXT("debug"), 5)) // debug[level]
{
debug = (DebugLevel)T_strtoul(&argv[0][6], 0, 0);
if (!debug) {
debug = DbgBasic;
}
fprintf(stderr, "Debug set to %x\n", debug);
}
else if (argv[0][1] == 's' && argv[0][2])
dotReplacementChar = (char)argv[0][2];
else if (argv[0][1] == 'p' && argv[0][2])
pdbref = argv[0] + 2;
else
fatal("unknown option: " SARG, argv[0]);
}
if (argc < 2)
{
printf("Convert DMD CodeView/DWARF debug information to PDB files, Version %.02f\n", VERSION);
printf("Copyright (c) 2009-2012 by Rainer Schuetze, All Rights Reserved\n");
printf("\n");
printf("License for redistribution is given by the Artistic License 2.0\n");
printf("see file LICENSE for further details\n");
printf("\n");
printf("usage: " SARG " [-D<version>|-C|-n|-e|-s<C>|-p<embedded-pdb>] <exe-file> [new-exe-file] [pdb-file]\n", argv[0]);
return -1;
}
PEImage exe, dbg, *img = NULL;
TCHAR dbgname[MAX_PATH];
if (!exe.loadExe(argv[1]))
fatal(SARG ": %s", argv[1], exe.getLastError());
if (exe.countCVEntries() || exe.hasDWARF())
img = &exe;
else
{
// try DBG file alongside executable
changeExtension(dbgname, argv[1], TEXT(".dbg"));
struct _stat buffer;
if (T_stat(dbgname, &buffer) != 0)
fatal(SARG ": no codeview debug entries found", argv[1]);
if (!dbg.loadExe(dbgname))
fatal(SARG ": %s", dbgname, dbg.getLastError());
if (dbg.countCVEntries() == 0)
fatal(SARG ": no codeview debug entries found", dbgname);
img = &dbg;
}
CV2PDB cv2pdb(*img, debug);
cv2pdb.Dversion = Dversion;
cv2pdb.initLibraries();
TCHAR* outname = argv[1];
if (argc > 2 && argv[2][0])
outname = argv[2];
TCHAR pdbname[260];
if (argc > 3)
T_strcpy (pdbname, argv[3]);
else
{
T_strcpy (pdbname, outname);
TCHAR *pDot = T_strrchr (pdbname, '.');
if (!pDot || pDot <= T_strrchr (pdbname, '/') || pDot <= T_strrchr (pdbname, '\\'))
T_strcat (pdbname, TEXT(".pdb"));
else
T_strcpy (pDot, TEXT(".pdb"));
}
makefullpath(pdbname);
T_unlink(pdbname);
if(!cv2pdb.openPDB(pdbname, pdbref))
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if(exe.hasDWARF())
{
if(!exe.relocateDebugLineInfo(0x400000))
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if(!cv2pdb.createDWARFModules())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if(!cv2pdb.addDWARFTypes())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if(!cv2pdb.addDWARFLines())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addDWARFPublics())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.writeDWARFImage(outname))
fatal(SARG ": %s", outname, cv2pdb.getLastError());
}
else
{
if (!cv2pdb.initSegMap())
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if (!cv2pdb.initGlobalSymbols())
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if (!cv2pdb.initGlobalTypes())
fatal(SARG ": %s", argv[1], cv2pdb.getLastError());
if (!cv2pdb.createModules())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addTypes())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addSymbols())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addSrcLines())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!cv2pdb.addPublics())
fatal(SARG ": %s", pdbname, cv2pdb.getLastError());
if (!exe.isDBG())
if (!cv2pdb.writeImage(outname, exe))
fatal(SARG ": %s", outname, cv2pdb.getLastError());
}
return 0;
}
<|endoftext|> |
<commit_before>#include <iostream>
#include "lib/bios_opencv/frame_grabber/video_file.h"
#include "lib/bios_opencv/filter_chain/filter_chain.h"
#include "lib/bios_opencv/filter/all_filters.h"
using namespace std;
using namespace BiosOpenCV;
int main(int argc, const char * argv[])
{
bool paused = false;
// Set step to true to execute at least once to allow Display filters to initialize
// an opencv window
bool step = true;
FilterChain filters;
cv::Mat original;
#if defined(USE_VIDEO_FILE)
std::string filename = "./video_samples/sample.mp4";
if (argc >= 2) {
filename = std::string(argv[1]);
}
VideoFile frameGrabber(filename);
paused = true;
std::cout << "Watch it. Video is currently paused. Press p to pause/unpause, s to step and esc to quit" << std::endl;
#endif
filters.add(new GrabFrame(original, &frameGrabber));
filters.add(new Display(original, "Original"));
do {
if (!paused || step) {
filters.execute();
step = false;
}
char key = cv::waitKey(10);
if(key == 'p') {
paused = !paused;
} else if (key == 's') {
step = true;
} else if (key == 27) {
break;
}
} while (true);
return 0;
}
<commit_msg>Threshold to find potty backplate<commit_after>#include <iostream>
#include "lib/bios_opencv/frame_grabber/video_file.h"
#include "lib/bios_opencv/filter_chain/filter_chain.h"
#include "lib/bios_opencv/filter/all_filters.h"
using namespace std;
using namespace BiosOpenCV;
int main(int argc, const char * argv[])
{
bool paused = false;
// Set step to true to execute at least once to allow Display filters to initialize
// an opencv window
bool step = true;
FilterChain filters;
cv::Mat original;
cv::Mat processed;
#if defined(USE_VIDEO_FILE)
std::string filename = "./video_samples/sample.mp4";
if (argc >= 2) {
filename = std::string(argv[1]);
}
VideoFile frameGrabber(filename);
paused = true;
std::cout << "Watch it. Video is currently paused. Press p to pause/unpause, s to step and esc to quit" << std::endl;
#endif
filters.add(new GrabFrame(original, &frameGrabber));
filters.add(new GrayScale(original, processed));
filters.add(new BinaryThreshold(processed, 140));
filters.add(new Display(processed, "Processed"));
do {
if (!paused || step) {
filters.execute();
step = false;
}
char key = cv::waitKey(10);
if(key == 'p') {
paused = !paused;
} else if (key == 's') {
step = true;
} else if (key == 27) {
break;
}
} while (true);
return 0;
}
<|endoftext|> |
<commit_before>/******************************************************************************
* Fake Frog *
* An Arduino-based project to build a frog-shaped temperature logger. *
* Author: David Lougheed. Copyright 2017. *
******************************************************************************/
#define VERSION "0.1.0"
// Includes
#include <Arduino.h>
#include <Wire.h>
#include <LiquidCrystal.h>
#include <SD.h>
#include <RTClib.h>
// Compile-Time Settings
#define SERIAL_LOGGING true // Log to the serial display for debug.
#define FILE_LOGGING true // Log to file on SD card. (recommended)
#define DISPLAY_ENABLED true // Show menus and information on an LCD.
#define NUM_SAMPLES 10 // Samples get averaged to reduce noise.
#define SAMPLE_DELAY 10 // Milliseconds between samples.
// Hardware Settings
#define THERMISTOR_PIN A0
#define THERMISTOR_SERIES_RES 10000
#define THERMISTOR_RES_NOM 10000 // Nominal resistance, R0.
#define THERMISTOR_B_COEFF 3950 // Beta coefficient of the thermistor.
#define THERMISTOR_TEMP_NOM 25 // Nominal temperature of R0.
#define SD_CARD_PIN 10
#define RTC_PIN_1 4
#define RTC_PIN_2 5
#define LCD_PIN_RS 6
#define LCD_PIN_EN 7
#define LCD_PIN_DB4 8
#define LCD_PIN_DB5 9
#define LCD_PIN_DB6 11
#define LCD_PIN_DB7 12
#define LCD_ROWS 2
#define LCD_COLUMNS 16
#define RTC_TYPE RTC_PCF8523
// Other Compile-Time Constants
#define MAX_LOG_FILES 1000
#define MAX_DATA_FILES 1000
// Globals
bool serial_logging_started = false;
File log_file;
File data_file;
RTC_TYPE rtc;
LiquidCrystal* lcd;
// To save memory, use global data point variables.
DateTime now;
char formatted_timestamp[] = "0000-00-00T00:00:00";
char* data_file_entry_buffer = (char*) malloc(sizeof(char) * 50);
double latest_temperature;
/*
DISPLAY MODES (ALL WITH LOGGING)
0: Idle
1: Information (clock, space usage)
2: RTC Editor
*/
uint8_t display_mode = 0;
uint16_t i; // 16-bit iterator
// Utility Methods
// Log a generic message.
void log(const char* msg, bool with_newline = true) {
if (SERIAL_LOGGING) {
if(!serial_logging_started) {
Serial.begin(9600);
Serial.println();
serial_logging_started = true;
}
if (with_newline) {
Serial.println(msg);
} else {
Serial.print(msg);
}
}
if (FILE_LOGGING) {
if (log_file) {
if (with_newline) {
log_file.println(msg);
} else {
log_file.print(msg);
}
log_file.flush();
}
}
}
// Log an error message. Uses standard log method, then hangs forever.
void log_error(const char* msg, bool with_newline = true) {
log(msg, with_newline);
while (true); // Loop forever
}
void update_screen() {
if (DISPLAY_ENABLED && lcd) {
lcd->clear();
switch (display_mode) {
case 1:
lcd->print("TBD");
break;
case 2:
lcd->print("TBD");
break;
case 0:
default:
break;
}
}
}
void switch_display_mode(uint8_t m) {
display_mode = m;
update_screen();
}
// Data Methods
// Update the global formatted timestamp string with the contents of 'now'.
void update_formatted_timestamp() {
sprintf(formatted_timestamp, "%u-%u-%uT%u:%u:%u", now.year(),
now.month(), now.day(), now.hour(), now.minute(), now.second());
}
void take_reading() {
now = rtc.now();
latest_temperature = 0;
for (i = 0; i < NUM_SAMPLES; i++) {
latest_temperature += (double) analogRead(THERMISTOR_PIN);
delay(SAMPLE_DELAY);
}
// Formulas: T = 1/(1/B * ln(R/R_0) + (1/T0)) - 273.15 (celcius)
// R = sr / (1023 / mean_of_samples - 1)
// sr = thermistor series resistance
latest_temperature = THERMISTOR_SERIES_RES
/ (1023 / (latest_temperature / NUM_SAMPLES) - 1); // Resistance
latest_temperature = 1 / ((log(latest_temperature / THERMISTOR_RES_NOM)
/ THERMISTOR_B_COEFF) + 1 / (THERMISTOR_TEMP_NOM + 273.15)) - 273.15;
}
void save_reading_to_card() {
if (data_file) {
update_formatted_timestamp();
sprintf(data_file_entry_buffer, "%.2f,%s", latest_temperature,
formatted_timestamp);
data_file.println(data_file_entry_buffer);
data_file.flush();
}
}
// Main Methods
void setup() {
// TODO: Set up pins
// SET UP EXTERNAL ANALOG VOLTAGE REFERENCE
// Typically from 3.3V Arduino supply. This reduces the voltage noise seen
// from reading analog values.
analogReference(EXTERNAL);
// INITIALIZE SD CARD
log("Initializing SD card... ", false);
pinMode(SD_CARD_PIN, OUTPUT);
if (!SD.begin()) {
log_error("Failed.");
}
log("Done.");
// SET UP LOG FILE
if (FILE_LOGGING) {
log("Creating log file... ", false);
char log_file_name[] = "log_000.txt";
for (i = 0; i < MAX_LOG_FILES; i++) {
// Increment until we can find a log file slot.
// Need to add 32 to get ASCII number characters.
log_file_name[6] = i / 100 + 32;
log_file_name[7] = i / 10 + 32;
log_file_name[8] = i % 10 + 32;
if (!SD.exists(log_file_name)) {
log_file = SD.open(log_file_name, FILE_WRITE);
break;
}
}
if (log_file) {
log("Done.");
} else {
log_error("Failed.");
}
}
// SET UP RTC
log("Initializing RTC...", false);
Wire.begin();
if (!rtc.begin()) {
log_error("Failed.");
}
log("Done.");
// TODO: Calibrate RTC
// SET UP DATA FILE
log("Creating data file...");
char data_file_name[] = "data_000.csv";
for (i = 0; i < MAX_DATA_FILES; i++) {
// Increment until we can find a data file slot.
// Need to add 32 to get ASCII digit characters.
data_file_name[6] = i / 100 + 32;
data_file_name[7] = i / 10 + 32;
data_file_name[8] = i % 10 + 32;
if (!SD.exists(data_file_name)) {
data_file = SD.open(data_file_name, FILE_WRITE);
break;
}
}
if (data_file) {
log("Done.");
} else {
log_error("Failed.");
}
// PRINT DATA FILE CSV HEADERS
data_file.println("Timestamp,Temperature");
data_file.flush();
// SET UP LCD
if (DISPLAY_ENABLED) {
lcd = new LiquidCrystal(LCD_PIN_RS, LCD_PIN_EN, LCD_PIN_DB4,
LCD_PIN_DB5, LCD_PIN_DB6, LCD_PIN_DB7);
lcd->begin(LCD_COLUMNS, LCD_ROWS);
}
// Finished everything!
now = rtc.now();
update_formatted_timestamp();
log("Data logger started at ", false);
log(formatted_timestamp, false);
log(". Software version: ", false);
log(VERSION);
}
void loop() {
// TODO: (Optional) Exit sleep
take_reading();
save_reading_to_card();
// TODO: (Optional) Enter sleep
delay(1000);
}
<commit_msg>Move temperature calculation into a dedicated function (for future re-use with error calculation).<commit_after>/******************************************************************************
* Fake Frog *
* An Arduino-based project to build a frog-shaped temperature logger. *
* Author: David Lougheed. Copyright 2017. *
******************************************************************************/
#define VERSION "0.1.0"
// Includes
#include <Arduino.h>
#include <Wire.h>
#include <LiquidCrystal.h>
#include <SD.h>
#include <RTClib.h>
// Compile-Time Settings
#define SERIAL_LOGGING true // Log to the serial display for debug.
#define FILE_LOGGING true // Log to file on SD card. (recommended)
#define DISPLAY_ENABLED true // Show menus and information on an LCD.
#define NUM_SAMPLES 10 // Samples get averaged to reduce noise.
#define SAMPLE_DELAY 10 // Milliseconds between samples.
// Hardware Settings
#define THERMISTOR_PIN A0
#define THERMISTOR_SERIES_RES 10000
#define THERMISTOR_RES_NOM 10000 // Nominal resistance, R0.
#define THERMISTOR_B_COEFF 3950 // Beta coefficient of the thermistor.
#define THERMISTOR_TEMP_NOM 25 // Nominal temperature of R0.
#define SD_CARD_PIN 10
#define RTC_PIN_1 4
#define RTC_PIN_2 5
#define LCD_PIN_RS 6
#define LCD_PIN_EN 7
#define LCD_PIN_DB4 8
#define LCD_PIN_DB5 9
#define LCD_PIN_DB6 11
#define LCD_PIN_DB7 12
#define LCD_ROWS 2
#define LCD_COLUMNS 16
#define RTC_TYPE RTC_PCF8523
// Other Compile-Time Constants
#define MAX_LOG_FILES 1000
#define MAX_DATA_FILES 1000
// Globals
bool serial_logging_started = false;
File log_file;
File data_file;
RTC_TYPE rtc;
LiquidCrystal* lcd;
// To save memory, use global data point variables.
DateTime now;
char formatted_timestamp[] = "0000-00-00T00:00:00";
char* data_file_entry_buffer = (char*) malloc(sizeof(char) * 50);
double latest_resistance;
double latest_temperature;
/*
DISPLAY MODES (ALL WITH LOGGING)
0: Idle
1: Information (clock, space usage)
2: RTC Editor
*/
uint8_t display_mode = 0;
uint16_t i; // 16-bit iterator
// Utility Methods
// Log a generic message.
void log(const char* msg, bool with_newline = true) {
if (SERIAL_LOGGING) {
if(!serial_logging_started) {
Serial.begin(9600);
Serial.println();
serial_logging_started = true;
}
if (with_newline) {
Serial.println(msg);
} else {
Serial.print(msg);
}
}
if (FILE_LOGGING) {
if (log_file) {
if (with_newline) {
log_file.println(msg);
} else {
log_file.print(msg);
}
log_file.flush();
}
}
}
// Log an error message. Uses standard log method, then hangs forever.
void log_error(const char* msg, bool with_newline = true) {
log(msg, with_newline);
while (true); // Loop forever
}
void update_screen() {
if (DISPLAY_ENABLED && lcd) {
lcd->clear();
switch (display_mode) {
case 1:
lcd->print("TBD");
break;
case 2:
lcd->print("TBD");
break;
case 0:
default:
break;
}
}
}
void switch_display_mode(uint8_t m) {
display_mode = m;
update_screen();
}
// Data Methods
// Update the global formatted timestamp string with the contents of 'now'.
void update_formatted_timestamp() {
sprintf(formatted_timestamp, "%u-%u-%uT%u:%u:%u", now.year(),
now.month(), now.day(), now.hour(), now.minute(), now.second());
}
double resistance_to_temperature(double resistance) {
// Formula: T = 1/(1/B * ln(R/R_0) + (1/T0)) - 273.15 (celcius)
return 1 / ((log(resistance / THERMISTOR_RES_NOM) / THERMISTOR_B_COEFF) + 1
/ (THERMISTOR_TEMP_NOM + 273.15)) - 273.15;
}
void take_reading() {
now = rtc.now();
latest_resistance = 0;
for (i = 0; i < NUM_SAMPLES; i++) {
latest_resistance += (double) analogRead(THERMISTOR_PIN);
delay(SAMPLE_DELAY);
}
// Formulas: R = sr / (1023 / mean_of_samples - 1)
// sr = thermistor series resistance
latest_resistance = THERMISTOR_SERIES_RES
/ (1023 / (latest_resistance / NUM_SAMPLES) - 1); // Resistance
latest_temperature = resistance_to_temperature(latest_resistance);
// TODO: Error calculations
}
void save_reading_to_card() {
if (data_file) {
update_formatted_timestamp();
sprintf(data_file_entry_buffer, "%.2f,%s", latest_temperature,
formatted_timestamp);
data_file.println(data_file_entry_buffer);
data_file.flush();
}
}
// Main Methods
void setup() {
// TODO: Set up pins
// SET UP EXTERNAL ANALOG VOLTAGE REFERENCE
// Typically from 3.3V Arduino supply. This reduces the voltage noise seen
// from reading analog values.
analogReference(EXTERNAL);
// INITIALIZE SD CARD
log("Initializing SD card... ", false);
pinMode(SD_CARD_PIN, OUTPUT);
if (!SD.begin()) {
log_error("Failed.");
}
log("Done.");
// SET UP LOG FILE
if (FILE_LOGGING) {
log("Creating log file... ", false);
char log_file_name[] = "log_000.txt";
for (i = 0; i < MAX_LOG_FILES; i++) {
// Increment until we can find a log file slot.
// Need to add 32 to get ASCII number characters.
log_file_name[6] = i / 100 + 32;
log_file_name[7] = i / 10 + 32;
log_file_name[8] = i % 10 + 32;
if (!SD.exists(log_file_name)) {
log_file = SD.open(log_file_name, FILE_WRITE);
break;
}
}
if (log_file) {
log("Done.");
} else {
log_error("Failed.");
}
}
// SET UP RTC
log("Initializing RTC...", false);
Wire.begin();
if (!rtc.begin()) {
log_error("Failed.");
}
log("Done.");
// TODO: Calibrate RTC
// SET UP DATA FILE
log("Creating data file...");
char data_file_name[] = "data_000.csv";
for (i = 0; i < MAX_DATA_FILES; i++) {
// Increment until we can find a data file slot.
// Need to add 32 to get ASCII digit characters.
data_file_name[6] = i / 100 + 32;
data_file_name[7] = i / 10 + 32;
data_file_name[8] = i % 10 + 32;
if (!SD.exists(data_file_name)) {
data_file = SD.open(data_file_name, FILE_WRITE);
break;
}
}
if (data_file) {
log("Done.");
} else {
log_error("Failed.");
}
// PRINT DATA FILE CSV HEADERS
data_file.println("Timestamp,Temperature");
data_file.flush();
// SET UP LCD
if (DISPLAY_ENABLED) {
lcd = new LiquidCrystal(LCD_PIN_RS, LCD_PIN_EN, LCD_PIN_DB4,
LCD_PIN_DB5, LCD_PIN_DB6, LCD_PIN_DB7);
lcd->begin(LCD_COLUMNS, LCD_ROWS);
}
// Finished everything!
now = rtc.now();
update_formatted_timestamp();
log("Data logger started at ", false);
log(formatted_timestamp, false);
log(". Software version: ", false);
log(VERSION);
}
void loop() {
// TODO: (Optional) Exit sleep
take_reading();
save_reading_to_card();
// TODO: (Optional) Enter sleep
delay(1000);
}
<|endoftext|> |
<commit_before>#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
struct tree
{
tree *leftSon;
tree *rightSon;
int value;
};
void addNumber(tree *binaryTree, int value)
{
if (value == binaryTree->value)
{
cout << " " << endl;
return;
}
else
{
if (value < binaryTree->value)
{
if (!binaryTree->leftSon)
{
binaryTree->leftSon = new tree{ nullptr, nullptr, value };
}
else
{
addNumber(binaryTree->leftSon, value);
}
}
else
{
if (!binaryTree->rightSon)
{
binaryTree->rightSon = new tree{ nullptr, nullptr, value };
}
else
{
addNumber(binaryTree->rightSon, value);
}
}
}
}
bool foundingOfNumber(tree *binaryTree, int value)
{
if (binaryTree->value != value)
{
if (binaryTree->value > value)
{
if (binaryTree->leftSon)
{
return foundingOfNumber(binaryTree->leftSon, value);
}
else
{
cout << " " << endl << endl;
return false;
}
}
if (binaryTree->value < value)
{
if (binaryTree->rightSon)
{
return foundingOfNumber(binaryTree->rightSon, value);
}
else
{
cout << " " << endl << endl;
return false;
}
}
}
else
{
cout << " " << endl << endl;
return true;
}
}
void printBinaryTreeIncrease(tree *binaryTree)
{
if (binaryTree->leftSon)
{
printBinaryTreeIncrease(binaryTree->leftSon);
}
cout << binaryTree->value << " ";
if (binaryTree->rightSon)
{
printBinaryTreeIncrease(binaryTree->rightSon);
}
}
void printBinaryTreeDecrease(tree *binaryTree)
{
if (binaryTree->rightSon)
{
printBinaryTreeDecrease(binaryTree->rightSon);
}
cout << binaryTree->value << " ";
if (binaryTree->leftSon)
{
printBinaryTreeDecrease(binaryTree->leftSon);
}
}
void deleteElementFromTree(tree *binaryTree, int value)
{
if ((binaryTree->value > value) || (binaryTree->value < value))
{
if (binaryTree->value > value)
{
deleteElementFromTree(binaryTree->leftSon, value);
return;
}
else
{
deleteElementFromTree(binaryTree->rightSon, value);
return;
}
}
if (!(binaryTree->leftSon || binaryTree->rightSon))
{
delete binaryTree;
binaryTree = nullptr;
return;
}
if ((!binaryTree->leftSon) && binaryTree->rightSon)
{
tree *oldElement = binaryTree;
binaryTree->rightSon = binaryTree->rightSon;
delete oldElement;
return;
}
if (binaryTree->leftSon && (!binaryTree->rightSon))
{
tree *oldElement = binaryTree;
binaryTree->rightSon = binaryTree->leftSon;
delete oldElement;
return;
}
}
int main()
{
setlocale(LC_ALL, "Russian");
int command = -1;
cout << " , , ";
int numberInRoot = 0;
cin >> numberInRoot;
cout << endl;
tree *root = new tree{ nullptr, nullptr, numberInRoot };
cout << " " << endl << endl;
while (command != 0)
{
cout << " 0 " << endl;
cout << " 1 " << endl;
cout << " 2 " << endl;
cout << " 3 " << endl;
cout << " 4 " << endl;
cout << " 5 " << endl;
cin >> command;
switch (command)
{
case (1):
{
cout << " , ";
int number = 0;
cin >> number;
cout << endl;
addNumber(root, number);
break;
}
case(2):
{
cout << " : ";
int number = 0;
cin >> number;
cout << endl;
if (foundingOfNumber(root, number))
{
deleteElementFromTree(root, number);
}
break;
}
case(3):
{
cout << " ";
int number = 0;
cin >> number;
cout << endl;
foundingOfNumber(root, number);
break;
}
case(4):
{
printBinaryTreeIncrease(root);
cout << endl;
break;
}
case(5):
{
printBinaryTreeDecrease(root);
cout << endl;
break;
}
}
}
return 0;
}<commit_msg>Complete Deleting end finish HomeWork 7.1<commit_after>#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;
struct tree
{
tree *leftSon;
tree *rightSon;
int value;
};
void addNumber(tree *&binaryTree, int value)
{
if (value == binaryTree->value)
{
cout << " " << endl;
return;
}
else
{
if (value < binaryTree->value)
{
if (!binaryTree->leftSon)
{
binaryTree->leftSon = new tree{ nullptr, nullptr, value };
}
else
{
addNumber(binaryTree->leftSon, value);
}
}
else
{
if (!binaryTree->rightSon)
{
binaryTree->rightSon = new tree{ nullptr, nullptr, value };
}
else
{
addNumber(binaryTree->rightSon, value);
}
}
}
}
bool foundingOfNumber(tree *&binaryTree, int value)
{
if (binaryTree->value != value)
{
if (binaryTree->value > value)
{
if (binaryTree->leftSon)
{
return foundingOfNumber(binaryTree->leftSon, value);
}
else
{
cout << " " << endl << endl;
return false;
}
}
if (binaryTree->value < value)
{
if (binaryTree->rightSon)
{
return foundingOfNumber(binaryTree->rightSon, value);
}
else
{
cout << " " << endl << endl;
return false;
}
}
}
else
{
cout << " " << endl << endl;
return true;
}
}
void printBinaryTreeIncrease(tree *&binaryTree)
{
if (binaryTree->leftSon)
{
printBinaryTreeIncrease(binaryTree->leftSon);
}
cout << binaryTree->value << " ";
if (binaryTree->rightSon)
{
printBinaryTreeIncrease(binaryTree->rightSon);
}
}
void printBinaryTreeDecrease(tree *&binaryTree)
{
if (binaryTree->rightSon)
{
printBinaryTreeDecrease(binaryTree->rightSon);
}
cout << binaryTree->value << " ";
if (binaryTree->leftSon)
{
printBinaryTreeDecrease(binaryTree->leftSon);
}
}
void deleteElementFromTree(tree *&binaryTree, int value)
{
if ((binaryTree->value > value) || (binaryTree->value < value))
{
if (binaryTree->value > value)
{
deleteElementFromTree(binaryTree->leftSon, value);
return;
}
else
{
deleteElementFromTree(binaryTree->rightSon, value);
return;
}
}
if (!(binaryTree->leftSon || binaryTree->rightSon))
{
delete binaryTree;
binaryTree = nullptr;
return;
}
if ((!binaryTree->leftSon) && binaryTree->rightSon)
{
tree *oldElement = binaryTree;
binaryTree = binaryTree->rightSon;
delete oldElement;
oldElement = nullptr;
return;
}
if (binaryTree->leftSon && (!binaryTree->rightSon))
{
tree *oldElement = binaryTree;
binaryTree = binaryTree->leftSon;
delete oldElement;
oldElement = nullptr;
return;
}
tree *&newElement = binaryTree->leftSon;
while (newElement->rightSon)
{
newElement = newElement->rightSon;
}
binaryTree->value = newElement->value;
deleteElementFromTree(newElement, newElement->value);
}
int main()
{
setlocale(LC_ALL, "Russian");
int command = -1;
cout << " , , ";
int numberInRoot = 0;
cin >> numberInRoot;
cout << endl;
tree *root = new tree{ nullptr, nullptr, numberInRoot };
cout << " " << endl << endl;
while (command != 0)
{
cout << " 0 " << endl;
cout << " 1 " << endl;
cout << " 2 " << endl;
cout << " 3 " << endl;
cout << " 4 " << endl;
cout << " 5 " << endl;
cin >> command;
switch (command)
{
case (1):
{
cout << " , ";
int number = 0;
cin >> number;
cout << endl;
addNumber(root, number);
break;
}
case(2):
{
cout << " : ";
int number = 0;
cin >> number;
cout << endl;
if (foundingOfNumber(root, number))
{
deleteElementFromTree(root, number);
}
break;
}
case(3):
{
cout << " ";
int number = 0;
cin >> number;
cout << endl;
foundingOfNumber(root, number);
break;
}
case(4):
{
printBinaryTreeIncrease(root);
cout << endl;
break;
}
case(5):
{
printBinaryTreeDecrease(root);
cout << endl;
break;
}
}
}
return 0;
}<|endoftext|> |
<commit_before>// Copyright (c) 2010 - 2013 Leap Motion. All rights reserved. Proprietary and confidential.
#include "stdafx.h"
#include "CoreThreadTest.h"
#include "Autowired.h"
#include "TestFixtures/SimpleThreaded.h"
#include <boost/thread/thread.hpp>
#include <boost/thread.hpp>
class SpamguardTest:
public CoreThread
{
public:
SpamguardTest(void):
m_hit(false),
m_multiHit(false)
{
}
bool m_hit;
bool m_multiHit;
void Run(void) override {
if(m_hit) {
m_multiHit = true;
return;
}
m_hit = false;
boost::unique_lock<boost::mutex> lk(m_lock);
m_stateCondition.wait(lk, [this] () {return ShouldStop();});
}
};
TEST_F(CoreThreadTest, VerifyStartSpam) {
// Create our thread class:
AutoRequired<SpamguardTest> instance;
m_create->InitiateCoreThreads();
// This shouldn't cause another thread to be created:
instance->Start(std::shared_ptr<Object>(new Object));
EXPECT_FALSE(instance->m_multiHit) << "Thread was run more than once unexpectedly";
}
class InvokesIndefiniteWait:
public CoreThread
{
public:
virtual void Run(void) override {
AcceptDispatchDelivery();
// Wait for one event using an indefinite timeout, then quit:
WaitForEvent(boost::chrono::steady_clock::time_point::max());
}
};
TEST_F(CoreThreadTest, VerifyIndefiniteDelay) {
AutoRequired<InvokesIndefiniteWait> instance;
m_create->InitiateCoreThreads();
// Verify that the instance does not quit until we pend something:
ASSERT_FALSE(instance->WaitFor(boost::chrono::milliseconds(10))) << "Thread instance exited prematurely, when it should have been waiting indefinitely";
// Now we pend an arbitrary event and verify that we can wait:
*instance += [] {};
ASSERT_TRUE(instance->WaitFor(boost::chrono::milliseconds(10))) << "Instance did not exit after an event was pended which should have woken up its dispatch loop";
}
TEST_F(CoreThreadTest, VerifyNestedTermination) {
std::shared_ptr<SimpleThreaded> st;
// Insert a thread into a second-order subcontext:
{
AutoCreateContext outer;
CurrentContextPusher outerPshr(outer);
AutoRequired<SimpleThreaded>();
outer->InitiateCoreThreads();
{
AutoCreateContext ctxt;
CurrentContextPusher pshr(ctxt);
ctxt->InitiateCoreThreads();
st = AutoRequired<SimpleThreaded>();
}
}
// Everything should be running by now:
ASSERT_TRUE(st->IsRunning()) << "Child thread was not running as expected";
// Shut down the enclosing context:
m_create->SignalTerminate(true);
// Verify that the child thread has stopped:
ASSERT_FALSE(st->IsRunning()) << "Child thread was running even though the enclosing context was terminated";
}
class SleepEvent : public virtual EventReceiver
{
public:
virtual Deferred SleepFor(int seconds) = 0;
virtual Deferred SleepForThenThrow(int seconds) = 0;
};
class ListenThread :
public CoreThread,
public SleepEvent
{
public:
ListenThread() : CoreThread("ListenThread") {}
Deferred SleepFor(int seconds) override {
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
if(ShouldStop())
throw std::runtime_error("Execution aborted");
return Deferred(this);
}
Deferred SleepForThenThrow(int seconds) override {
return Deferred(this);
}
};
TEST_F(CoreThreadTest, VerifyDispatchQueueShutdown) {
AutoCreateContext ctxt;
CurrentContextPusher pusher(ctxt);
AutoRequired<ListenThread> listener;
try
{
ctxt->InitiateCoreThreads();
listener->DelayUntilCanAccept();
AutoFired<SleepEvent> evt;
// Spam in a bunch of events:
for(size_t i = 100; i--;)
evt(&SleepEvent::SleepFor)(0);
// Graceful termination then enclosing context shutdown:
listener->Stop(true);
ctxt->SignalShutdown(true);
}
catch (...) {}
ASSERT_EQ(listener->GetDispatchQueueLength(), static_cast<size_t>(0));
}
TEST_F(CoreThreadTest, VerifyNoLeakOnExecptions) {
AutoCreateContext ctxt;
CurrentContextPusher pshr(ctxt);
AutoRequired<ListenThread> listener;
std::shared_ptr<std::string> value(new std::string("sentinal"));
std::weak_ptr<std::string> watcher(value);
try
{
ctxt->InitiateCoreThreads();
listener->DelayUntilCanAccept();
*listener += [value] { throw std::exception(); };
value.reset();
ctxt->SignalShutdown(true);
}
catch (...) {}
ASSERT_TRUE(watcher.expired()) << "Leaked memory on exception in a dispatch event";
}
TEST_F(CoreThreadTest, VerifyDelayedDispatchQueueSimple) {
// Run our threads immediately, no need to wait
m_create->InitiateCoreThreads();
// Create a thread which we'll use just to pend dispatch events:
AutoRequired<CoreThread> t;
// Thread should be running by now:
ASSERT_TRUE(t->IsRunning()) << "Thread added to a running context was not marked running";
// Delay until the dispatch loop is actually running, then wait an additional 1ms to let the
// WaitForEvent call catch on:
t->DelayUntilCanAccept();
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
// These are flags--we'll set them to true as the test proceeds
std::shared_ptr<bool> x(new bool(false));
std::shared_ptr<bool> y(new bool(false));
// Pend a delayed event first, and then an immediate event right afterwards:
*t += boost::chrono::milliseconds(25), [x] { *x = true; };
*t += [y] { *y = true; };
// Verify that, after 1ms, the first event is called and the second event is NOT called:
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
ASSERT_TRUE(*y) << "A simple ready call was not dispatched within 10ms of being pended";
ASSERT_FALSE(*x) << "An event which should not have been executed for 25ms was executed early";
// Now delay another 90ms and see if the second event got called:
boost::this_thread::sleep_for(boost::chrono::milliseconds(90));
ASSERT_TRUE(*x) << "A delayed event was not made ready and executed as expected";
}
TEST_F(CoreThreadTest, VerifyNoDelayDoubleFree) {
m_create->InitiateCoreThreads();
// We won't actually be referencing this, we just want to make sure it's not destroyed early
std::shared_ptr<bool> x(new bool);
// This deferred pend will never actually be executed:
AutoRequired<CoreThread> t;
t->DelayUntilCanAccept();
*t += boost::chrono::hours(1), [x] {};
// Verify that we have exactly one pended event at this point.
ASSERT_EQ(1UL, t->GetDispatchQueueLength()) << "Dispatch queue had an unexpected number of pended events";
// Verify that the shared pointer isn't unique at this point. If it is, it's because our CoreThread deleted
// the event even though it was supposed to have pended it.
ASSERT_FALSE(x.unique()) << "A pended event was freed before it was called, and appears to be present in a dispatch queue";
}
TEST_F(CoreThreadTest, VerifyDoublePendedDispatchDelay) {
// Immediately pend threads:
m_create->InitiateCoreThreads();
// Some variables that we will set to true as the test proceeds:
std::shared_ptr<bool> x(new bool(false));
std::shared_ptr<bool> y(new bool(false));
// Create a thread as before, and pend a few events. The order, here, is important. We intentionally
// pend an event that won't happen for awhile, in order to trick the dispatch queue into waiting for
// a lot longer than it should for the next event.
AutoRequired<CoreThread> t;
t->DelayUntilCanAccept();
*t += boost::chrono::hours(1), [x] { *x = true; };
// Now pend an event that will be ready just about right away:
*t += boost::chrono::nanoseconds(1), [y] { *y = true; };
// Delay for a short period of time, then check our variable states:
boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
// This one shouldn't have been hit yet, it isn't scheduled to be hit for 10s
ASSERT_FALSE(*x) << "A delayed dispatch was invoked extremely early";
// This one should have been ready almost at the same time as it was pended
ASSERT_TRUE(*y) << "An out-of-order delayed dispatch was not executed in time as expected";
}
TEST_F(CoreThreadTest, VerifyTimedSort) {
m_create->InitiateCoreThreads();
AutoRequired<CoreThread> t;
std::vector<size_t> v;
// Pend a stack of lambdas. Each lambda waits 3i milliseconds, and pushes the value
// i to the back of a vector. If the delay method is implemented correctly, the resulting
// vector will always wind up sorted, no matter how we push elements to the queue.
// To doubly verify this property, we don't trivially increment i from the minimum to the
// maximum--rather, we use a simple PRNG called a linear congruential generator and hop around
// the interval [1...12] instead.
for(size_t i = 1; i != 0; i = (i * 5 + 1) % 16)
*t += boost::chrono::milliseconds(i * 3), [&v, i] { v.push_back(i); };
// Delay 50ms for the thread to finish up. Technically this is 11ms more than we need.
boost::this_thread::sleep_for(boost::chrono::seconds(1));
// Verify that the resulting vector is sorted.
ASSERT_TRUE(std::is_sorted(v.begin(), v.end())) << "A timed sort implementation did not generate a sorted sequence as expected";
}
TEST_F(CoreThreadTest, VerifyPendByTimePoint) {
m_create->InitiateCoreThreads();
AutoRequired<CoreThread> t;
t->DelayUntilCanAccept();
// Pend by an absolute time point, nothing really special here
std::shared_ptr<bool> x(new bool(false));
*t += (boost::chrono::high_resolution_clock::now() + boost::chrono::milliseconds(1)), [&x] { *x = true; };
// Verify that we hit this after one ms of delay
ASSERT_FALSE(*x) << "A timepoint-based delayed dispatch was invoked early";
boost::this_thread::sleep_for(boost::chrono::milliseconds(2));
ASSERT_TRUE(*x) << "A timepoint-based delayed dispatch was not invoked in a timely fashion";
}
template<ThreadPriority priority>
class JustIncrementsANumber:
public CoreThread
{
public:
JustIncrementsANumber():
val(0)
{}
volatile int64_t val;
// This will be a hotly contested conditional variable
AutoRequired<boost::mutex> contended;
void Run(void) override {
ElevatePriority p(*this, priority);
while(!ShouldStop()) {
// Obtain the lock and then increment our value:
boost::lock_guard<boost::mutex> lk(*contended);
val++;
}
}
};
#ifdef _MSC_VER
TEST_F(CoreThreadTest, VerifyCanBoostPriority) {
// Create two spinners and kick them off at the same time:
AutoRequired<JustIncrementsANumber<ThreadPriority::Normal>> lower;
AutoRequired<JustIncrementsANumber<ThreadPriority::AboveNormal>> higher;
m_create->InitiateCoreThreads();
// Poke the conditional variable a lot:
AutoRequired<boost::mutex> contended;
for(size_t i = 100; i--;) {
// We sleep while holding contention lock to force waiting threads into the sleep queue. The reason we have to do
// this is due to the way that mutex is implemented under the hood. The STL mutex uses a high-frequency variable
// and attempts to perform a CAS (check-and-set) on this variable. If it succeeds, the lock is obtained; if it
// fails, it will put the thread into a non-ready state by calling WaitForSingleObject on Windows or one of the
// mutex_lock methods on Unix.
//
// When a thread can't be run, it's moved from the OS's ready queue to the sleep queue. The scheduler knows that
// the thread can be moved back to the ready queue if a particular object is signalled, but in the case of a lock,
// only one of the threads waiting on the object can actually be moved to the ready queue. It's at THIS POINT that
// the operating system consults the thread priority--if only thread can be moved over, then the highest priority
// thread will wind up in the ready queue every time.
//
// Thread priority does _not_ necessarily influence the amount of time the scheduler allocates allocated to a ready
// thread with respect to other threads of the same process. This is why we hold the lock for a full millisecond,
// in order to force the thread over to the sleep queue and ensure that the priority resolution mechanism is
// directly tested.
boost::lock_guard<boost::mutex> lk(*contended);
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
}
// Need to terminate before we try running a comparison.
m_create->SignalTerminate();
ASSERT_LE(lower->val, higher->val) << "A lower-priority thread was moved out of the sleep queue more frequently than a high-priority thread";
}
#else
#pragma message "Warning: SetThreadPriority not implemented on Unix"
#endif<commit_msg>Relaxing another test constraint so that bypass behavior is evaluated separately<commit_after>// Copyright (c) 2010 - 2013 Leap Motion. All rights reserved. Proprietary and confidential.
#include "stdafx.h"
#include "CoreThreadTest.h"
#include "Autowired.h"
#include "TestFixtures/SimpleThreaded.h"
#include <boost/thread/thread.hpp>
#include <boost/thread.hpp>
class SpamguardTest:
public CoreThread
{
public:
SpamguardTest(void):
m_hit(false),
m_multiHit(false)
{
}
bool m_hit;
bool m_multiHit;
void Run(void) override {
if(m_hit) {
m_multiHit = true;
return;
}
m_hit = false;
boost::unique_lock<boost::mutex> lk(m_lock);
m_stateCondition.wait(lk, [this] () {return ShouldStop();});
}
};
TEST_F(CoreThreadTest, VerifyStartSpam) {
// Create our thread class:
AutoRequired<SpamguardTest> instance;
m_create->InitiateCoreThreads();
// This shouldn't cause another thread to be created:
instance->Start(std::shared_ptr<Object>(new Object));
EXPECT_FALSE(instance->m_multiHit) << "Thread was run more than once unexpectedly";
}
class InvokesIndefiniteWait:
public CoreThread
{
public:
virtual void Run(void) override {
AcceptDispatchDelivery();
// Wait for one event using an indefinite timeout, then quit:
WaitForEvent(boost::chrono::steady_clock::time_point::max());
}
};
TEST_F(CoreThreadTest, VerifyIndefiniteDelay) {
AutoRequired<InvokesIndefiniteWait> instance;
m_create->InitiateCoreThreads();
// Verify that the instance does not quit until we pend something:
ASSERT_FALSE(instance->WaitFor(boost::chrono::milliseconds(10))) << "Thread instance exited prematurely, when it should have been waiting indefinitely";
// Now we pend an arbitrary event and verify that we can wait:
*instance += [] {};
ASSERT_TRUE(instance->WaitFor(boost::chrono::milliseconds(10))) << "Instance did not exit after an event was pended which should have woken up its dispatch loop";
}
TEST_F(CoreThreadTest, VerifyNestedTermination) {
std::shared_ptr<SimpleThreaded> st;
// Insert a thread into a second-order subcontext:
{
AutoCreateContext outer;
CurrentContextPusher outerPshr(outer);
AutoRequired<SimpleThreaded>();
outer->InitiateCoreThreads();
{
AutoCreateContext ctxt;
CurrentContextPusher pshr(ctxt);
ctxt->InitiateCoreThreads();
st = AutoRequired<SimpleThreaded>();
}
}
// Everything should be running by now:
ASSERT_TRUE(st->IsRunning()) << "Child thread was not running as expected";
// Shut down the enclosing context:
m_create->SignalTerminate(true);
// Verify that the child thread has stopped:
ASSERT_FALSE(st->IsRunning()) << "Child thread was running even though the enclosing context was terminated";
}
class SleepEvent : public virtual EventReceiver
{
public:
virtual Deferred SleepFor(int seconds) = 0;
virtual Deferred SleepForThenThrow(int seconds) = 0;
};
class ListenThread :
public CoreThread,
public SleepEvent
{
public:
ListenThread() : CoreThread("ListenThread") {}
Deferred SleepFor(int seconds) override {
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
if(ShouldStop())
throw std::runtime_error("Execution aborted");
return Deferred(this);
}
Deferred SleepForThenThrow(int seconds) override {
return Deferred(this);
}
};
TEST_F(CoreThreadTest, VerifyDispatchQueueShutdown) {
AutoCreateContext ctxt;
CurrentContextPusher pusher(ctxt);
AutoRequired<ListenThread> listener;
try
{
ctxt->InitiateCoreThreads();
listener->DelayUntilCanAccept();
AutoFired<SleepEvent> evt;
// Spam in a bunch of events:
for(size_t i = 100; i--;)
evt(&SleepEvent::SleepFor)(0);
// Graceful termination then enclosing context shutdown:
listener->Stop(true);
ctxt->SignalShutdown(true);
}
catch (...) {}
ASSERT_EQ(listener->GetDispatchQueueLength(), static_cast<size_t>(0));
}
TEST_F(CoreThreadTest, VerifyNoLeakOnExecptions) {
AutoCreateContext ctxt;
CurrentContextPusher pshr(ctxt);
AutoRequired<ListenThread> listener;
std::shared_ptr<std::string> value(new std::string("sentinal"));
std::weak_ptr<std::string> watcher(value);
try
{
ctxt->InitiateCoreThreads();
listener->DelayUntilCanAccept();
*listener += [value] { throw std::exception(); };
value.reset();
ctxt->SignalShutdown(true);
}
catch (...) {}
ASSERT_TRUE(watcher.expired()) << "Leaked memory on exception in a dispatch event";
}
TEST_F(CoreThreadTest, VerifyDelayedDispatchQueueSimple) {
// Run our threads immediately, no need to wait
m_create->InitiateCoreThreads();
// Create a thread which we'll use just to pend dispatch events:
AutoRequired<CoreThread> t;
// Thread should be running by now:
ASSERT_TRUE(t->IsRunning()) << "Thread added to a running context was not marked running";
// Delay until the dispatch loop is actually running, then wait an additional 1ms to let the
// WaitForEvent call catch on:
t->DelayUntilCanAccept();
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
// These are flags--we'll set them to true as the test proceeds
std::shared_ptr<bool> x(new bool(false));
std::shared_ptr<bool> y(new bool(false));
// Pend a delayed event first, and then an immediate event right afterwards:
*t += boost::chrono::hours(1), [x] { *x = true; };
*t += [y] { *y = true; };
// Verify that, after 10ms, the first event is called and the second event is NOT called:
boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
ASSERT_TRUE(*y) << "A simple ready call was not dispatched within 10ms of being pended";
ASSERT_FALSE(*x) << "An event which should not have been executed for 25ms was executed early";
}
TEST_F(CoreThreadTest, VerifyNoDelayDoubleFree) {
m_create->InitiateCoreThreads();
// We won't actually be referencing this, we just want to make sure it's not destroyed early
std::shared_ptr<bool> x(new bool);
// This deferred pend will never actually be executed:
AutoRequired<CoreThread> t;
t->DelayUntilCanAccept();
*t += boost::chrono::hours(1), [x] {};
// Verify that we have exactly one pended event at this point.
ASSERT_EQ(1UL, t->GetDispatchQueueLength()) << "Dispatch queue had an unexpected number of pended events";
// Verify that the shared pointer isn't unique at this point. If it is, it's because our CoreThread deleted
// the event even though it was supposed to have pended it.
ASSERT_FALSE(x.unique()) << "A pended event was freed before it was called, and appears to be present in a dispatch queue";
}
TEST_F(CoreThreadTest, VerifyDoublePendedDispatchDelay) {
// Immediately pend threads:
m_create->InitiateCoreThreads();
// Some variables that we will set to true as the test proceeds:
std::shared_ptr<bool> x(new bool(false));
std::shared_ptr<bool> y(new bool(false));
// Create a thread as before, and pend a few events. The order, here, is important. We intentionally
// pend an event that won't happen for awhile, in order to trick the dispatch queue into waiting for
// a lot longer than it should for the next event.
AutoRequired<CoreThread> t;
t->DelayUntilCanAccept();
*t += boost::chrono::hours(1), [x] { *x = true; };
// Now pend an event that will be ready just about right away:
*t += boost::chrono::nanoseconds(1), [y] { *y = true; };
// Delay for a short period of time, then check our variable states:
boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
// This one shouldn't have been hit yet, it isn't scheduled to be hit for 10s
ASSERT_FALSE(*x) << "A delayed dispatch was invoked extremely early";
// This one should have been ready almost at the same time as it was pended
ASSERT_TRUE(*y) << "An out-of-order delayed dispatch was not executed in time as expected";
}
TEST_F(CoreThreadTest, VerifyTimedSort) {
m_create->InitiateCoreThreads();
AutoRequired<CoreThread> t;
std::vector<size_t> v;
// Pend a stack of lambdas. Each lambda waits 3i milliseconds, and pushes the value
// i to the back of a vector. If the delay method is implemented correctly, the resulting
// vector will always wind up sorted, no matter how we push elements to the queue.
// To doubly verify this property, we don't trivially increment i from the minimum to the
// maximum--rather, we use a simple PRNG called a linear congruential generator and hop around
// the interval [1...12] instead.
for(size_t i = 1; i != 0; i = (i * 5 + 1) % 16)
*t += boost::chrono::milliseconds(i * 3), [&v, i] { v.push_back(i); };
// Delay 50ms for the thread to finish up. Technically this is 11ms more than we need.
boost::this_thread::sleep_for(boost::chrono::seconds(1));
// Verify that the resulting vector is sorted.
ASSERT_TRUE(std::is_sorted(v.begin(), v.end())) << "A timed sort implementation did not generate a sorted sequence as expected";
}
TEST_F(CoreThreadTest, VerifyPendByTimePoint) {
m_create->InitiateCoreThreads();
AutoRequired<CoreThread> t;
t->DelayUntilCanAccept();
// Pend by an absolute time point, nothing really special here
std::shared_ptr<bool> x(new bool(false));
*t += (boost::chrono::high_resolution_clock::now() + boost::chrono::milliseconds(1)), [&x] { *x = true; };
// Verify that we hit this after one ms of delay
ASSERT_FALSE(*x) << "A timepoint-based delayed dispatch was invoked early";
boost::this_thread::sleep_for(boost::chrono::milliseconds(2));
ASSERT_TRUE(*x) << "A timepoint-based delayed dispatch was not invoked in a timely fashion";
}
template<ThreadPriority priority>
class JustIncrementsANumber:
public CoreThread
{
public:
JustIncrementsANumber():
val(0)
{}
volatile int64_t val;
// This will be a hotly contested conditional variable
AutoRequired<boost::mutex> contended;
void Run(void) override {
ElevatePriority p(*this, priority);
while(!ShouldStop()) {
// Obtain the lock and then increment our value:
boost::lock_guard<boost::mutex> lk(*contended);
val++;
}
}
};
#ifdef _MSC_VER
TEST_F(CoreThreadTest, VerifyCanBoostPriority) {
// Create two spinners and kick them off at the same time:
AutoRequired<JustIncrementsANumber<ThreadPriority::Normal>> lower;
AutoRequired<JustIncrementsANumber<ThreadPriority::AboveNormal>> higher;
m_create->InitiateCoreThreads();
// Poke the conditional variable a lot:
AutoRequired<boost::mutex> contended;
for(size_t i = 100; i--;) {
// We sleep while holding contention lock to force waiting threads into the sleep queue. The reason we have to do
// this is due to the way that mutex is implemented under the hood. The STL mutex uses a high-frequency variable
// and attempts to perform a CAS (check-and-set) on this variable. If it succeeds, the lock is obtained; if it
// fails, it will put the thread into a non-ready state by calling WaitForSingleObject on Windows or one of the
// mutex_lock methods on Unix.
//
// When a thread can't be run, it's moved from the OS's ready queue to the sleep queue. The scheduler knows that
// the thread can be moved back to the ready queue if a particular object is signalled, but in the case of a lock,
// only one of the threads waiting on the object can actually be moved to the ready queue. It's at THIS POINT that
// the operating system consults the thread priority--if only thread can be moved over, then the highest priority
// thread will wind up in the ready queue every time.
//
// Thread priority does _not_ necessarily influence the amount of time the scheduler allocates allocated to a ready
// thread with respect to other threads of the same process. This is why we hold the lock for a full millisecond,
// in order to force the thread over to the sleep queue and ensure that the priority resolution mechanism is
// directly tested.
boost::lock_guard<boost::mutex> lk(*contended);
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
}
// Need to terminate before we try running a comparison.
m_create->SignalTerminate();
ASSERT_LE(lower->val, higher->val) << "A lower-priority thread was moved out of the sleep queue more frequently than a high-priority thread";
}
#else
#pragma message "Warning: SetThreadPriority not implemented on Unix"
#endif<|endoftext|> |
<commit_before>#include "cnn/nodes.h"
#include "cnn/cnn.h"
#include "cnn/training.h"
#include "cnn/gpu-ops.h"
#include "cnn/expr.h"
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/algorithm/string.hpp>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <utility>
#include <sstream>
#include <random>
using namespace std;
using namespace cnn;
using namespace cnn::expr;
typedef pair<cnn::real, cnn::real> Datum;
const unsigned num_children = 2;
struct Workload {
pid_t pid;
unsigned start;
unsigned end;
int pipe[2];
};
struct ModelParameters {
Parameters* m;
Parameters* b;
};
void BuildComputationGraph(ComputationGraph& cg, ModelParameters& model_parameters, cnn::real* x_value, cnn::real* y_value) {
Expression m = parameter(cg, model_parameters.m);
Expression b = parameter(cg, model_parameters.b);
Expression x = input(cg, x_value);
Expression y_star = input(cg, y_value);
Expression y = m * x + b;
Expression loss = squared_distance(y, y_star);
}
vector<Datum> ReadData(string filename) {
vector<Datum> data;
ifstream fs(filename);
string line;
while (getline(fs, line)) {
if (line.size() > 0 && line[0] == '#') {
continue;
}
vector<string> parts;
boost::split(parts, line, boost::is_any_of("\t"));
data.push_back(make_pair(atof(parts[0].c_str()), atof(parts[1].c_str())));
}
return data;
}
unsigned SpawnChildren(vector<Workload>& workloads) {
assert (workloads.size() == num_children);
pid_t pid;
unsigned cid;
for (cid = 0; cid < num_children; ++cid) {
pid = fork();
if (pid == -1) {
cerr << "Fork failed. Exiting ...";
return 1;
}
else if (pid == 0) {
// children shouldn't continue looping
break;
}
workloads[cid].pid = pid;
}
return cid;
}
int RunChild(unsigned cid, ComputationGraph& cg, Trainer* trainer, vector<Workload>& workloads,
const vector<Datum>& data, cnn::real& x_value, cnn::real& y_value, ModelParameters& model_params) {
assert (cid >= 0 && cid < num_children);
unsigned start = workloads[cid].start;
unsigned end = workloads[cid].end;
assert (start < end);
assert (end <= data.size());
cnn::real loss = 0;
for (auto it = data.begin() + start; it != data.begin() + end; ++it) {
auto p = *it;
x_value = get<0>(p);
y_value = get<1>(p);
loss += as_scalar(cg.forward());
cg.backward();
trainer->update(1.0);
}
loss /= (end - start);
cnn::real m_end = as_scalar(model_params.m->values);
cnn::real b_end = as_scalar(model_params.b->values);
write(workloads[cid].pipe[1], (char*)&m_end, sizeof(cnn::real));
write(workloads[cid].pipe[1], (char*)&b_end, sizeof(cnn::real));
write(workloads[cid].pipe[1], (char*)&loss, sizeof(cnn::real));
return 0;
}
void RunParent(unsigned iter, vector<Workload>& workloads, ModelParameters& model_params, Trainer* trainer) {
vector<cnn::real> m_values;
vector<cnn::real> b_values;
vector<cnn::real> loss_values;
for(unsigned cid = 0; cid < num_children; ++cid) {
cnn::real m, b, loss;
read(workloads[cid].pipe[0], (char*)&m, sizeof(cnn::real));
read(workloads[cid].pipe[0], (char*)&b, sizeof(cnn::real));
read(workloads[cid].pipe[0], (char*)&loss, sizeof(cnn::real));
m_values.push_back(m);
b_values.push_back(b);
loss_values.push_back(loss);
wait(NULL);
}
cnn::real m = 0.0;
cnn::real b = 0.0;
cnn::real loss = 0.0;
for (unsigned i = 0; i < m_values.size(); ++i) {
m += m_values[i];
b += b_values[i];
loss += loss_values[i];
}
m /= m_values.size();
b /= b_values.size();
// Update parameters to use the new m and b values
TensorTools::SetElements(model_params.m->values, {m});
TensorTools::SetElements(model_params.b->values, {b});
trainer->update_epoch();
cerr << iter << "\t" << "loss = " << loss << "\tm = " << m << "\tb = " << b << endl;
}
int main(int argc, char** argv) {
cnn::Initialize(argc, argv);
if (argc < 2) {
cerr << "Usage: " << argv[0] << " data.txt" << endl;
cerr << "Where data.txt contains tab-delimited pairs of floats." << endl;
return 1;
}
vector<Datum> data = ReadData(argv[1]);
vector<Workload> workloads(num_children);
Model model;
AdamTrainer sgd(&model, 0.0);
ComputationGraph cg;
cnn::real x_value, y_value;
Parameters* m_param = model.add_parameters({1, 1});
Parameters* b_param = model.add_parameters({1});
ModelParameters model_params = {m_param, b_param};
BuildComputationGraph(cg, model_params, &x_value, &y_value);
for (unsigned cid = 0; cid < num_children; cid++) {
unsigned start = (unsigned)(1.0 * cid / num_children * data.size() + 0.5);
unsigned end = (unsigned)(1.0 * (cid + 1) / num_children * data.size() + 0.5);
workloads[cid].start = start;
workloads[cid].end = end;
pipe(workloads[cid].pipe);
}
// train the parameters
for (unsigned iter = 0; true; ++iter) {
random_shuffle(data.begin(), data.end());
unsigned cid = SpawnChildren(workloads);
if (cid < num_children) {
return RunChild(cid, cg, &sgd, workloads, data, x_value, y_value, model_params);
}
else {
RunParent(iter, workloads, model_params, &sgd);
}
}
}
<commit_msg>more minor cleanup<commit_after>#include "cnn/cnn.h"
#include "cnn/training.h"
#include "cnn/expr.h"
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/algorithm/string.hpp>
#include <sys/types.h>
#include <sys/wait.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <utility>
#include <sstream>
#include <random>
using namespace std;
using namespace cnn;
using namespace cnn::expr;
typedef pair<cnn::real, cnn::real> Datum;
const unsigned num_children = 2;
cnn::real ReadReal(int pipe) {
cnn::real v;
read(pipe, &v, sizeof(cnn::real));
return v;
}
void WriteReal(int pipe, cnn::real v) {
write(pipe, &v, sizeof(cnn::real));
}
cnn::real Mean(const vector<cnn::real>& values) {
return accumulate(values.begin(), values.end(), 0.0) / values.size();
}
struct Workload {
pid_t pid;
unsigned start;
unsigned end;
int pipe[2];
};
struct ModelParameters {
Parameters* m;
Parameters* b;
};
void BuildComputationGraph(ComputationGraph& cg, ModelParameters& model_parameters, cnn::real* x_value, cnn::real* y_value) {
Expression m = parameter(cg, model_parameters.m);
Expression b = parameter(cg, model_parameters.b);
Expression x = input(cg, x_value);
Expression y_star = input(cg, y_value);
Expression y = m * x + b;
Expression loss = squared_distance(y, y_star);
}
vector<Datum> ReadData(string filename) {
vector<Datum> data;
ifstream fs(filename);
string line;
while (getline(fs, line)) {
if (line.size() > 0 && line[0] == '#') {
continue;
}
vector<string> parts;
boost::split(parts, line, boost::is_any_of("\t"));
data.push_back(make_pair(atof(parts[0].c_str()), atof(parts[1].c_str())));
}
return data;
}
unsigned SpawnChildren(vector<Workload>& workloads) {
assert (workloads.size() == num_children);
pid_t pid;
unsigned cid;
for (cid = 0; cid < num_children; ++cid) {
pid = fork();
if (pid == -1) {
cerr << "Fork failed. Exiting ...";
return 1;
}
else if (pid == 0) {
// children shouldn't continue looping
break;
}
workloads[cid].pid = pid;
}
return cid;
}
int RunChild(unsigned cid, ComputationGraph& cg, Trainer* trainer, vector<Workload>& workloads,
const vector<Datum>& data, cnn::real& x_value, cnn::real& y_value, ModelParameters& model_params) {
assert (cid >= 0 && cid < num_children);
unsigned start = workloads[cid].start;
unsigned end = workloads[cid].end;
assert (start < end);
assert (end <= data.size());
cnn::real loss = 0;
for (auto it = data.begin() + start; it != data.begin() + end; ++it) {
auto p = *it;
x_value = get<0>(p);
y_value = get<1>(p);
loss += as_scalar(cg.forward());
cg.backward();
trainer->update(1.0);
}
loss /= (end - start);
cnn::real m_end = as_scalar(model_params.m->values);
cnn::real b_end = as_scalar(model_params.b->values);
write(workloads[cid].pipe[1], (char*)&m_end, sizeof(cnn::real));
write(workloads[cid].pipe[1], (char*)&b_end, sizeof(cnn::real));
write(workloads[cid].pipe[1], (char*)&loss, sizeof(cnn::real));
return 0;
}
void RunParent(unsigned iter, vector<Workload>& workloads, ModelParameters& model_params, Trainer* trainer) {
vector<cnn::real> m_values;
vector<cnn::real> b_values;
vector<cnn::real> loss_values;
for(unsigned cid = 0; cid < num_children; ++cid) {
cnn::real m = ReadReal(workloads[cid].pipe[0]);
cnn::real b = ReadReal(workloads[cid].pipe[0]);
cnn::real loss = ReadReal(workloads[cid].pipe[0]);
m_values.push_back(m);
b_values.push_back(b);
loss_values.push_back(loss);
wait(NULL);
}
cnn::real m = Mean(m_values);
cnn::real b = 0.0;
cnn::real loss = 0.0;
for (unsigned i = 0; i < m_values.size(); ++i) {
b += b_values[i];
loss += loss_values[i];
}
b /= b_values.size();
// Update parameters to use the new m and b values
TensorTools::SetElements(model_params.m->values, {m});
TensorTools::SetElements(model_params.b->values, {b});
trainer->update_epoch();
cerr << iter << "\t" << "loss = " << loss << "\tm = " << m << "\tb = " << b << endl;
}
int main(int argc, char** argv) {
cnn::Initialize(argc, argv);
if (argc < 2) {
cerr << "Usage: " << argv[0] << " data.txt" << endl;
cerr << "Where data.txt contains tab-delimited pairs of floats." << endl;
return 1;
}
vector<Datum> data = ReadData(argv[1]);
vector<Workload> workloads(num_children);
Model model;
AdamTrainer sgd(&model, 0.0);
ComputationGraph cg;
cnn::real x_value, y_value;
Parameters* m_param = model.add_parameters({1, 1});
Parameters* b_param = model.add_parameters({1});
ModelParameters model_params = {m_param, b_param};
BuildComputationGraph(cg, model_params, &x_value, &y_value);
for (unsigned cid = 0; cid < num_children; cid++) {
unsigned start = (unsigned)(1.0 * cid / num_children * data.size() + 0.5);
unsigned end = (unsigned)(1.0 * (cid + 1) / num_children * data.size() + 0.5);
workloads[cid].start = start;
workloads[cid].end = end;
pipe(workloads[cid].pipe);
}
// train the parameters
for (unsigned iter = 0; true; ++iter) {
random_shuffle(data.begin(), data.end());
unsigned cid = SpawnChildren(workloads);
if (cid < num_children) {
return RunChild(cid, cg, &sgd, workloads, data, x_value, y_value, model_params);
}
else {
RunParent(iter, workloads, model_params, &sgd);
}
}
}
<|endoftext|> |
<commit_before>#include <iostream>
#include <iomanip> // << fixed << setprecision(xxx)
#include <algorithm> // do { } while ( next_permutation(A, A+xxx) ) ;
#include <vector>
#include <string> // to_string(nnn) // substr(m, n) // stoi(nnn)
#include <complex>
#include <tuple> // get<n>(xxx)
#include <queue>
#include <stack>
#include <map> // if (M.find(key) != M.end()) { }
#include <set> // S.insert(M);
// if (S.find(key) != S.end()) { }
// for (auto it=S.begin(); it != S.end(); it++) { }
// auto it = S.lower_bound(M);
#include <random> // random_device rd; mt19937 mt(rd());
#include <cctype>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib> // atoi(xxx)
using namespace std;
#define DEBUG 1 // change 0 -> 1 if we need debug.
// insert #if<tab> by my emacs. #if DEBUG == 1 ... #end
typedef long long ll;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// const int C = 1e6+10;
const ll infty = 10000000000000007;
struct edge {
int to;
ll cap;
int rev;
};
vector<edge> G[100010];
bool used[100010];
void add_edge(int from, int to, ll cap) {
G[from].push_back((edge){to, cap, (int)G[to].size()});
G[to].push_back((edge){to, 0, (int)G[to].size()-1});
}
ll dfs(int v, int t, ll f) {
if (v == t) return f;
used[v] = true;
for (auto& e : G[v]) {
if (!used[e.to] && e.cap > 0) {
ll d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(int s, int t) {
ll flow = 0;
while (true) {
fill(used, used+100010, false);
ll f = dfs(s, t, infty);
if (f == 0) return flow;
flow += f;
}
}
int R, C;
string S[100];
int src, dst;
int vertex = 0;
bool valid(int i, int j) {
return (0 <= i && i < R && 0 <= j && j < C && S[i][j] == '.');
}
int num(int i, int j) {
return i * C + j;
}
void add_edge_grid(int i, int j) {
if (!valid(i, j)) return;
int now = num(i, j);
vertex++;
if (i+j % 2 == 0) {
for (auto k = 0; k < 4; ++k) {
int x = i + dx[k];
int y = j + dy[k];
if (valid(x, y)) {
add_edge(now, num(x, y), 1);
#if DEBUG == 1
cerr << "add_edge(" << now << ", " << num(x, y) << ", 1)" << endl;
#endif
}
add_edge(src, now, 1);
}
} else {
add_edge(now, dst, 1);
}
}
int main () {
cin >> R >> C;
for (auto i = 0; i < R; ++i) {
cin >> S[i];
}
src = R * C;
dst = R * C + 1;
for (auto i = 0; i < R; ++i) {
for (auto j = 0; j < C; ++j) {
add_edge_grid(i, j);
}
}
ll maxi = max_flow(src, dst);
#if DEBUG == 1
cerr << "vertex = " << vertex << endl;
cerr << "maxi = " << maxi << endl;
#endif
cout << vertex - maxi << endl;
}
<commit_msg>tried C2.cpp to 'C'<commit_after>#include <iostream>
#include <iomanip> // << fixed << setprecision(xxx)
#include <algorithm> // do { } while ( next_permutation(A, A+xxx) ) ;
#include <vector>
#include <string> // to_string(nnn) // substr(m, n) // stoi(nnn)
#include <complex>
#include <tuple> // get<n>(xxx)
#include <queue>
#include <stack>
#include <map> // if (M.find(key) != M.end()) { }
#include <set> // S.insert(M);
// if (S.find(key) != S.end()) { }
// for (auto it=S.begin(); it != S.end(); it++) { }
// auto it = S.lower_bound(M);
#include <random> // random_device rd; mt19937 mt(rd());
#include <cctype>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib> // atoi(xxx)
using namespace std;
#define DEBUG 0 // change 0 -> 1 if we need debug.
// insert #if<tab> by my emacs. #if DEBUG == 1 ... #end
typedef long long ll;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// const int C = 1e6+10;
const ll infty = 10000000000000007;
struct edge {
int to;
ll cap;
int rev;
};
vector<edge> G[100010];
bool used[100010];
void add_edge(int from, int to, ll cap) {
G[from].push_back((edge){to, cap, (int)G[to].size()});
G[to].push_back((edge){to, 0, (int)G[to].size()-1});
}
ll dfs(int v, int t, ll f) {
if (v == t) return f;
used[v] = true;
for (auto& e : G[v]) {
if (!used[e.to] && e.cap > 0) {
ll d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(int s, int t) {
ll flow = 0;
while (true) {
fill(used, used+100010, false);
ll f = dfs(s, t, infty);
if (f == 0) return flow;
flow += f;
}
}
int R, C;
string S[100];
int src, dst;
int vertex = 0;
bool valid(int i, int j) {
return (0 <= i && i < R && 0 <= j && j < C && S[i][j] == '.');
}
int num(int i, int j) {
return i * C + j;
}
void add_edge_grid(int i, int j) {
if (!valid(i, j)) return;
int now = num(i, j);
vertex++;
if ((i+j) % 2 == 0) {
for (auto k = 0; k < 4; ++k) {
int x = i + dx[k];
int y = j + dy[k];
if (valid(x, y)) {
add_edge(now, num(x, y), 1);
#if DEBUG == 1
cerr << "add_edge(" << now << ", " << num(x, y) << ", 1)" << endl;
#endif
}
add_edge(src, now, 1);
}
} else {
add_edge(now, dst, 1);
}
}
int main () {
cin >> R >> C;
for (auto i = 0; i < R; ++i) {
cin >> S[i];
}
src = R * C;
dst = R * C + 1;
for (auto i = 0; i < R; ++i) {
for (auto j = 0; j < C; ++j) {
add_edge_grid(i, j);
}
}
ll maxi = max_flow(src, dst);
#if DEBUG == 1
cerr << "vertex = " << vertex << endl;
cerr << "maxi = " << maxi << endl;
#endif
cout << vertex - maxi << endl;
}
<|endoftext|> |
<commit_before>/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "otbWrapperApplication.h"
#include "otbWrapperApplicationFactory.h"
#include "otbStatisticsXMLFileWriter.h"
#include "otbStreamingStatisticsVectorImageFilter.h"
namespace otb
{
namespace Wrapper
{
class ComputeImagesStatistics: public Application
{
public:
/** Standard class typedefs. */
typedef ComputeImagesStatistics Self;
typedef Application Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Standard macro */
itkNewMacro(Self);
itkTypeMacro(ComputeImagesStatistics, otb::Application);
private:
void DoInit()
{
SetName("ComputeImagesStatistics");
SetDescription("Computes global mean and standard deviation for each band from a set of images and optionally saves the results in an XML file.");
SetDocName("Compute Images second order statistics");
SetDocLongDescription("This application computes a global mean and standard deviation for each band of a set of images and optionally saves the results in an XML file. The output XML is intended to be used an input for the TrainImagesClassifier application to normalize samples before learning.");
SetDocLimitations("Each image of the set must contain the same bands as the others (i.e. same types, in the same order).");
SetDocAuthors("OTB-Team");
SetDocSeeAlso("Documentation of the TrainImagesClassifier application.");
AddDocTag(Tags::Learning);
AddDocTag(Tags::Analysis);
AddParameter(ParameterType_InputImageList, "il", "Input images");
SetParameterDescription( "il", "List of input images filenames." );
AddParameter(ParameterType_OutputFilename, "out", "Output XML file");
SetParameterDescription( "out", "XML filename where the statistics are saved for future reuse." );
MandatoryOff("out");
// Doc example parameter settings
SetDocExampleParameterValue("il", "QB_1_ortho.tif");
SetDocExampleParameterValue("out", "EstimateImageStatisticsQB1.xml");
}
void DoUpdateParameters()
{
// Nothing to do here : all parameters are independent
}
void DoExecute()
{
//Statistics estimator
typedef otb::StreamingStatisticsVectorImageFilter<FloatVectorImageType> StreamingStatisticsVImageFilterType;
// Samples
typedef double ValueType;
typedef itk::VariableLengthVector<ValueType> MeasurementType;
unsigned int nbSamples = 0;
unsigned int nbBands = 0;
// Build a Measurement Vector of mean
MeasurementType mean;
// Build a MeasurementVector of variance
MeasurementType variance;
FloatVectorImageListType* imageList = GetParameterImageList("il");
//Iterate over all input images
for (unsigned int imageId = 0; imageId < imageList->Size(); ++imageId)
{
FloatVectorImageType* image = imageList->GetNthElement(imageId);
if (nbBands == 0)
{
nbBands = image->GetNumberOfComponentsPerPixel();
}
else if (nbBands != image->GetNumberOfComponentsPerPixel())
{
itkExceptionMacro(<< "The image #" << imageId << " has " << image->GetNumberOfComponentsPerPixel()
<< " bands, while the first one has " << nbBands );
}
FloatVectorImageType::SizeType size = image->GetLargestPossibleRegion().GetSize();
//Set the measurement vectors size if it's the first iteration
if (imageId == 0)
{
mean.SetSize(nbBands);
mean.Fill(0.);
variance.SetSize(nbBands);
variance.Fill(0.);
}
// Compute Statistics of each VectorImage
StreamingStatisticsVImageFilterType::Pointer statsEstimator = StreamingStatisticsVImageFilterType::New();
statsEstimator->SetInput(image);
statsEstimator->Update();
mean += statsEstimator->GetMean();
for (unsigned int itBand = 0; itBand < nbBands; itBand++)
{
variance[itBand] += (size[0] * size[1] - 1) * (statsEstimator->GetCovariance())(itBand, itBand);
}
//Increment nbSamples
nbSamples += size[0] * size[1] * nbBands;
}
//Divide by the number of input images to get the mean over all layers
mean /= imageList->Size();
//Apply the pooled variance formula
variance /= (nbSamples - imageList->Size());
MeasurementType stddev;
stddev.SetSize(nbBands);
stddev.Fill(0.);
for (unsigned int i = 0; i < variance.GetSize(); ++i)
{
stddev[i] = vcl_sqrt(variance[i]);
}
if( HasValue( "out" )==true )
{
// Write the Statistics via the statistic writer
typedef otb::StatisticsXMLFileWriter<MeasurementType> StatisticsWriter;
StatisticsWriter::Pointer writer = StatisticsWriter::New();
writer->SetFileName(GetParameterString("out"));
writer->AddInput("mean", mean);
writer->AddInput("stddev", stddev);
writer->Update();
}
else
{
otbAppLogINFO("Mean: "<<mean<<std::endl);
otbAppLogINFO("Standard Deviation: "<<stddev<<std::endl);
}
}
itk::LightObject::Pointer m_FilterRef;
};
}
}
OTB_APPLICATION_EXPORT(otb::Wrapper::ComputeImagesStatistics)
<commit_msg>ENH: provide access to user defined ignored value in ComputeImagesStatistics application<commit_after>/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "otbWrapperApplication.h"
#include "otbWrapperApplicationFactory.h"
#include "otbStatisticsXMLFileWriter.h"
#include "otbStreamingStatisticsVectorImageFilter.h"
namespace otb
{
namespace Wrapper
{
class ComputeImagesStatistics: public Application
{
public:
/** Standard class typedefs. */
typedef ComputeImagesStatistics Self;
typedef Application Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Standard macro */
itkNewMacro(Self);
itkTypeMacro(ComputeImagesStatistics, otb::Application);
private:
void DoInit()
{
SetName("ComputeImagesStatistics");
SetDescription("Computes global mean and standard deviation for each band from a set of images and optionally saves the results in an XML file.");
SetDocName("Compute Images second order statistics");
SetDocLongDescription("This application computes a global mean and standard deviation for each band of a set of images and optionally saves the results in an XML file. The output XML is intended to be used an input for the TrainImagesClassifier application to normalize samples before learning.");
SetDocLimitations("Each image of the set must contain the same bands as the others (i.e. same types, in the same order).");
SetDocAuthors("OTB-Team");
SetDocSeeAlso("Documentation of the TrainImagesClassifier application.");
AddDocTag(Tags::Learning);
AddDocTag(Tags::Analysis);
AddParameter(ParameterType_InputImageList, "il", "Input images");
SetParameterDescription( "il", "List of input images filenames." );
AddParameter(ParameterType_Float, "bv", "Background Value");
SetParameterDescription( "bv", "Background value to ignore in statistics computation." );
MandatoryOff("bv");
AddParameter(ParameterType_OutputFilename, "out", "Output XML file");
SetParameterDescription( "out", "XML filename where the statistics are saved for future reuse." );
MandatoryOff("out");
// Doc example parameter settings
SetDocExampleParameterValue("il", "QB_1_ortho.tif");
SetDocExampleParameterValue("out", "EstimateImageStatisticsQB1.xml");
}
void DoUpdateParameters()
{
// Nothing to do here : all parameters are independent
}
void DoExecute()
{
//Statistics estimator
typedef otb::StreamingStatisticsVectorImageFilter<FloatVectorImageType> StreamingStatisticsVImageFilterType;
// Samples
typedef double ValueType;
typedef itk::VariableLengthVector<ValueType> MeasurementType;
unsigned int nbSamples = 0;
unsigned int nbBands = 0;
// Build a Measurement Vector of mean
MeasurementType mean;
// Build a MeasurementVector of variance
MeasurementType variance;
FloatVectorImageListType* imageList = GetParameterImageList("il");
//Iterate over all input images
for (unsigned int imageId = 0; imageId < imageList->Size(); ++imageId)
{
FloatVectorImageType* image = imageList->GetNthElement(imageId);
if (nbBands == 0)
{
nbBands = image->GetNumberOfComponentsPerPixel();
}
else if (nbBands != image->GetNumberOfComponentsPerPixel())
{
itkExceptionMacro(<< "The image #" << imageId << " has " << image->GetNumberOfComponentsPerPixel()
<< " bands, while the first one has " << nbBands );
}
FloatVectorImageType::SizeType size = image->GetLargestPossibleRegion().GetSize();
//Set the measurement vectors size if it's the first iteration
if (imageId == 0)
{
mean.SetSize(nbBands);
mean.Fill(0.);
variance.SetSize(nbBands);
variance.Fill(0.);
}
// Compute Statistics of each VectorImage
StreamingStatisticsVImageFilterType::Pointer statsEstimator = StreamingStatisticsVImageFilterType::New();
statsEstimator->SetInput(image);
if( HasValue( "bv" )==true )
{
statsEstimator->SetIgnoreUserDefinedValue(true);
statsEstimator->SetUserIgnoredValue(GetParameterFloat("bv"));
}
statsEstimator->Update();
mean += statsEstimator->GetMean();
for (unsigned int itBand = 0; itBand < nbBands; itBand++)
{
variance[itBand] += (size[0] * size[1] - 1) * (statsEstimator->GetCovariance())(itBand, itBand);
}
//Increment nbSamples
nbSamples += size[0] * size[1] * nbBands;
}
//Divide by the number of input images to get the mean over all layers
mean /= imageList->Size();
//Apply the pooled variance formula
variance /= (nbSamples - imageList->Size());
MeasurementType stddev;
stddev.SetSize(nbBands);
stddev.Fill(0.);
for (unsigned int i = 0; i < variance.GetSize(); ++i)
{
stddev[i] = vcl_sqrt(variance[i]);
}
if( HasValue( "out" )==true )
{
// Write the Statistics via the statistic writer
typedef otb::StatisticsXMLFileWriter<MeasurementType> StatisticsWriter;
StatisticsWriter::Pointer writer = StatisticsWriter::New();
writer->SetFileName(GetParameterString("out"));
writer->AddInput("mean", mean);
writer->AddInput("stddev", stddev);
writer->Update();
}
else
{
otbAppLogINFO("Mean: "<<mean<<std::endl);
otbAppLogINFO("Standard Deviation: "<<stddev<<std::endl);
}
}
itk::LightObject::Pointer m_FilterRef;
};
}
}
OTB_APPLICATION_EXPORT(otb::Wrapper::ComputeImagesStatistics)
<|endoftext|> |
<commit_before>// $Id$
AliEmcalPhysicsSelectionTask* AddTaskEmcalPhysicsSelection(
Bool_t exFOnly,
Bool_t wHistos = kTRUE,
UInt_t triggers = 0,
Double_t minE = -1,
Double_t minPt = -1,
Double_t vz = -1,
Bool_t vzdiff = kFALSE,
Double_t cmin = -1,
Double_t cmax = -1,
Double_t minCellTrackScale = -1,
Double_t maxCellTrackScale = -1
)
{
// Add EMCAL physics selection task.
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskEmcalPhysicsSelection", "No analysis manager found.");
return 0;
}
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskEmcalPhysicsSelection", "This task requires an input event handler");
return NULL;
}
Bool_t isMC = (mgr->GetMCtruthEventHandler()) ? kTRUE:kFALSE;
AliEmcalPhysicsSelectionTask *pseltask = new AliEmcalPhysicsSelectionTask("EmcalPSel");
pseltask->SetDoWriteHistos(wHistos);
AliEmcalPhysicsSelection *physSel = static_cast<AliEmcalPhysicsSelection*>(pseltask->GetPhysicsSelection());
if (physSel) {
physSel->SetSkipFastOnly(exFOnly);
if (isMC)
physSel->SetAnalyzeMC();
physSel->SetClusMinE(minE);
physSel->SetTrackMinPt(minPt);
physSel->SetTriggers(triggers);
physSel->SetCentRange(cmin,cmax);
physSel->SetZVertex(vz);
physSel->SetCheckZvertexDiff(vzdiff);
physSel->SetCellTrackScale(minCellTrackScale,maxCellTrackScale);
} else {
::Error("AddTaskEmcalPhysicsSelection", "No AliEmcalPhysicsSelection object found.");
}
mgr->AddTask(pseltask);
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput = mgr->CreateContainer("cstatsout",
TList::Class(),
AliAnalysisManager::kOutputContainer,
"EventStat_temp.root");
mgr->ConnectInput(pseltask, 0, cinput);
mgr->ConnectOutput(pseltask, 1, coutput);
return pseltask;
}
<commit_msg>Added a bypass variable in the AddTaskEmcalPhysicsSelection macro<commit_after>// $Id$
AliEmcalPhysicsSelectionTask* AddTaskEmcalPhysicsSelection(
Bool_t exFOnly,
Bool_t wHistos = kTRUE,
UInt_t triggers = 0,
Double_t minE = -1,
Double_t minPt = -1,
Double_t vz = -1,
Bool_t vzdiff = kFALSE,
Double_t cmin = -1,
Double_t cmax = -1,
Double_t minCellTrackScale = -1,
Double_t maxCellTrackScale = -1,
Bool_t byPassPhysSelTask = kFALSE
)
{
if(byPassPhysSelTask)
return 0;
// Add EMCAL physics selection task.
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskEmcalPhysicsSelection", "No analysis manager found.");
return 0;
}
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskEmcalPhysicsSelection", "This task requires an input event handler");
return NULL;
}
Bool_t isMC = (mgr->GetMCtruthEventHandler()) ? kTRUE:kFALSE;
AliEmcalPhysicsSelectionTask *pseltask = new AliEmcalPhysicsSelectionTask("EmcalPSel");
pseltask->SetDoWriteHistos(wHistos);
AliEmcalPhysicsSelection *physSel = static_cast<AliEmcalPhysicsSelection*>(pseltask->GetPhysicsSelection());
if (physSel) {
physSel->SetSkipFastOnly(exFOnly);
if (isMC)
physSel->SetAnalyzeMC();
physSel->SetClusMinE(minE);
physSel->SetTrackMinPt(minPt);
physSel->SetTriggers(triggers);
physSel->SetCentRange(cmin,cmax);
physSel->SetZVertex(vz);
physSel->SetCheckZvertexDiff(vzdiff);
physSel->SetCellTrackScale(minCellTrackScale,maxCellTrackScale);
} else {
::Error("AddTaskEmcalPhysicsSelection", "No AliEmcalPhysicsSelection object found.");
}
mgr->AddTask(pseltask);
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput = mgr->CreateContainer("cstatsout",
TList::Class(),
AliAnalysisManager::kOutputContainer,
"EventStat_temp.root");
mgr->ConnectInput(pseltask, 0, cinput);
mgr->ConnectOutput(pseltask, 1, coutput);
return pseltask;
}
<|endoftext|> |
<commit_before>#define DEBUG 1
/**
* File : E.cpp
* Author : Kazune Takahashi
* Created : 6/14/2020, 3:06:06 AM
* Powered by Visual Studio Code
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// ----- boost -----
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
// ----- using directives and manipulations -----
using namespace std;
using boost::rational;
using boost::multiprecision::cpp_int;
using ll = long long;
using ld = long double;
template <typename T>
using max_heap = priority_queue<T>;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
// ----- constexpr for Mint and Combination -----
constexpr ll MOD{1'000'000'007LL};
// constexpr ll MOD{998'244'353LL}; // be careful
constexpr ll MAX_SIZE{3'000'010LL};
// constexpr ll MAX_SIZE{30'000'010LL}; // if 10^7 is needed
// ----- ch_max and ch_min -----
template <typename T>
void ch_max(T &left, T right)
{
if (left < right)
{
left = right;
}
}
template <typename T>
void ch_min(T &left, T right)
{
if (left > right)
{
left = right;
}
}
// ----- Mint -----
template <ll MOD = MOD>
class Mint
{
public:
ll x;
Mint() : x{0LL} {}
Mint(ll x) : x{(x % MOD + MOD) % MOD} {}
Mint operator-() const { return x ? MOD - x : 0; }
Mint &operator+=(Mint const &a)
{
if ((x += a.x) >= MOD)
{
x -= MOD;
}
return *this;
}
Mint &operator-=(Mint const &a) { return *this += -a; }
Mint &operator++() { return *this += 1; }
Mint operator++(int)
{
Mint tmp{*this};
++*this;
return tmp;
}
Mint &operator--() { return *this -= 1; }
Mint operator--(int)
{
Mint tmp{*this};
--*this;
return tmp;
}
Mint &operator*=(Mint const &a)
{
(x *= a.x) %= MOD;
return *this;
}
Mint &operator/=(Mint const &a)
{
Mint b{a};
return *this *= b.power(MOD - 2);
}
Mint operator+(Mint const &a) const { return Mint(*this) += a; }
Mint operator-(Mint const &a) const { return Mint(*this) -= a; }
Mint operator*(Mint const &a) const { return Mint(*this) *= a; }
Mint operator/(Mint const &a) const { return Mint(*this) /= a; }
bool operator<(Mint const &a) const { return x < a.x; }
bool operator<=(Mint const &a) const { return x <= a.x; }
bool operator>(Mint const &a) const { return x > a.x; }
bool operator>=(Mint const &a) const { return x >= a.x; }
bool operator==(Mint const &a) const { return x == a.x; }
bool operator!=(Mint const &a) const { return !(*this == a); }
Mint power(ll N) const
{
if (N == 0)
{
return 1;
}
else if (N % 2 == 1)
{
return *this * power(N - 1);
}
else
{
Mint half = power(N / 2);
return half * half;
}
}
};
template <ll MOD>
Mint<MOD> operator+(ll lhs, Mint<MOD> const &rhs) { return rhs + lhs; }
template <ll MOD>
Mint<MOD> operator-(ll lhs, Mint<MOD> const &rhs) { return -rhs + lhs; }
template <ll MOD>
Mint<MOD> operator*(ll lhs, Mint<MOD> const &rhs) { return rhs * lhs; }
template <ll MOD>
Mint<MOD> operator/(ll lhs, Mint<MOD> const &rhs) { return Mint<MOD>{lhs} / rhs; }
template <ll MOD>
istream &operator>>(istream &stream, Mint<MOD> &a) { return stream >> a.x; }
template <ll MOD>
ostream &operator<<(ostream &stream, Mint<MOD> const &a) { return stream << a.x; }
// ----- Combination -----
template <ll MOD = MOD, ll MAX_SIZE = MAX_SIZE>
class Combination
{
public:
vector<Mint<MOD>> inv, fact, factinv;
Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)
{
inv[1] = 1;
for (auto i{2LL}; i < MAX_SIZE; i++)
{
inv[i] = (-inv[MOD % i]) * (MOD / i);
}
fact[0] = factinv[0] = 1;
for (auto i{1LL}; i < MAX_SIZE; i++)
{
fact[i] = Mint<MOD>(i) * fact[i - 1];
factinv[i] = inv[i] * factinv[i - 1];
}
}
Mint<MOD> operator()(int n, int k)
{
if (n >= 0 && k >= 0 && n - k >= 0)
{
return fact[n] * factinv[k] * factinv[n - k];
}
return 0;
}
Mint<MOD> catalan(int x, int y)
{
return (*this)(x + y, y) - (*this)(x + y, y - 1);
}
};
// ----- for C++14 -----
using mint = Mint<MOD>;
using combination = Combination<MOD, MAX_SIZE>;
template <typename T>
T gcd(T x, T y) { return y ? gcd(y, x % y) : x; }
template <typename T>
T lcm(T x, T y) { return x / gcd(x, y) * y; }
// ----- for C++17 -----
template <typename T>
int popcount(T x) // C++20
{
int ans{0};
while (x != 0)
{
ans += x & 1;
x >>= 1;
}
return ans;
}
// ----- Infty -----
template <typename T>
constexpr T Infty() { return numeric_limits<T>::max(); }
template <typename T>
constexpr T mInfty() { return numeric_limits<T>::min(); }
// ----- frequently used constexpr -----
// constexpr double epsilon{1e-10};
// constexpr ll infty{1'000'000'000'000'010LL}; // or
// constexpr int infty{1'000'000'010};
// constexpr int dx[4] = {1, 0, -1, 0};
// constexpr int dy[4] = {0, 1, 0, -1};
// ----- Yes() and No() -----
void Yes()
{
cout << "Yes" << endl;
exit(0);
}
void No()
{
cout << "0" << endl;
exit(0);
}
// ----- Solve -----
constexpr int C{18};
ll comb(ll n, ll k)
{
ll ans{1};
for (auto i{0LL}; i < k; ++i)
{
ans *= n - i;
ans /= i + 1;
}
return ans;
}
class Solve
{
int N, S, T;
int M;
ll K;
vector<int> A;
public:
Solve(int N) : N{N}, A(N)
{
cin >> K >> S >> T;
for (auto i{0}; i < N; ++i)
{
cin >> A[i];
}
#if DEBUG == 1
cerr << "N = " << N << endl;
for (auto i{0}; i < N; ++i)
{
cerr << "A[" << i << "] = " << A[i] << endl;
}
#endif
normalize();
#if DEBUG == 1
cerr << "N = " << N << endl;
for (auto i{0}; i < N; ++i)
{
cerr << "A[" << i << "] = " << A[i] << endl;
}
cerr << "M = " << M << endl;
#endif
}
void flush()
{
ll ans{0};
for (auto mask{0}; mask < 1 << M; ++mask)
{
if (popcount(mask) & 1)
{
ans -= calc(mask);
}
else
{
ans += calc(mask);
}
}
cout << ans << endl;
}
private:
ll calc(int mask)
{
map<int, ll> X;
for (auto i{0}; i < N; ++i)
{
int tmp{A[i] & mask};
X[tmp];
X[tmp]++;
}
ll ans{1};
for (auto [mask, cnt] : X)
{
for (auto i{1}; i <= min(K, cnt); ++i)
{
ans += comb(cnt, i);
}
}
return ans;
}
void normalize()
{
vector<bool> ok(N, true);
for (auto i{0}; i < C; ++i)
{
auto s{static_cast<bool>(S >> i & 1)};
auto t{static_cast<bool>(T >> i & 1)};
if (s && !t)
{
No();
}
if (s ^ !t)
{
for (auto j{0}; j < N; ++j)
{
if ((A[j] >> i & 1) != static_cast<int>(s))
{
ok[j] = false;
}
}
}
}
vector<int> B;
for (auto i{0}; i < C; ++i)
{
if (ok[i])
{
B.push_back(A[i]);
}
}
#if DEBUG == 1
cerr << "B.size() = " << B.size() << endl;
#endif
swap(A, B);
N = static_cast<int>(A.size());
int k{0};
B = vector<int>(N, 0);
for (auto i{0}; i < C; ++i)
{
auto s{static_cast<bool>(S >> i & 1)};
auto t{static_cast<bool>(T >> i & 1)};
if (!(!s && t))
{
continue;
}
for (auto j{0}; j < N; ++j)
{
B[j] |= (A[j] >> i & 1) << k;
}
++k;
}
swap(A, B);
M = k;
}
};
// ----- main() -----
int main()
{
int N;
cin >> N;
Solve solve(N);
solve.flush();
}
<commit_msg>tried E.cpp to 'E'<commit_after>#define DEBUG 1
/**
* File : E.cpp
* Author : Kazune Takahashi
* Created : 6/14/2020, 3:06:06 AM
* Powered by Visual Studio Code
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// ----- boost -----
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
// ----- using directives and manipulations -----
using namespace std;
using boost::rational;
using boost::multiprecision::cpp_int;
using ll = long long;
using ld = long double;
template <typename T>
using max_heap = priority_queue<T>;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
// ----- constexpr for Mint and Combination -----
constexpr ll MOD{1'000'000'007LL};
// constexpr ll MOD{998'244'353LL}; // be careful
constexpr ll MAX_SIZE{3'000'010LL};
// constexpr ll MAX_SIZE{30'000'010LL}; // if 10^7 is needed
// ----- ch_max and ch_min -----
template <typename T>
void ch_max(T &left, T right)
{
if (left < right)
{
left = right;
}
}
template <typename T>
void ch_min(T &left, T right)
{
if (left > right)
{
left = right;
}
}
// ----- Mint -----
template <ll MOD = MOD>
class Mint
{
public:
ll x;
Mint() : x{0LL} {}
Mint(ll x) : x{(x % MOD + MOD) % MOD} {}
Mint operator-() const { return x ? MOD - x : 0; }
Mint &operator+=(Mint const &a)
{
if ((x += a.x) >= MOD)
{
x -= MOD;
}
return *this;
}
Mint &operator-=(Mint const &a) { return *this += -a; }
Mint &operator++() { return *this += 1; }
Mint operator++(int)
{
Mint tmp{*this};
++*this;
return tmp;
}
Mint &operator--() { return *this -= 1; }
Mint operator--(int)
{
Mint tmp{*this};
--*this;
return tmp;
}
Mint &operator*=(Mint const &a)
{
(x *= a.x) %= MOD;
return *this;
}
Mint &operator/=(Mint const &a)
{
Mint b{a};
return *this *= b.power(MOD - 2);
}
Mint operator+(Mint const &a) const { return Mint(*this) += a; }
Mint operator-(Mint const &a) const { return Mint(*this) -= a; }
Mint operator*(Mint const &a) const { return Mint(*this) *= a; }
Mint operator/(Mint const &a) const { return Mint(*this) /= a; }
bool operator<(Mint const &a) const { return x < a.x; }
bool operator<=(Mint const &a) const { return x <= a.x; }
bool operator>(Mint const &a) const { return x > a.x; }
bool operator>=(Mint const &a) const { return x >= a.x; }
bool operator==(Mint const &a) const { return x == a.x; }
bool operator!=(Mint const &a) const { return !(*this == a); }
Mint power(ll N) const
{
if (N == 0)
{
return 1;
}
else if (N % 2 == 1)
{
return *this * power(N - 1);
}
else
{
Mint half = power(N / 2);
return half * half;
}
}
};
template <ll MOD>
Mint<MOD> operator+(ll lhs, Mint<MOD> const &rhs) { return rhs + lhs; }
template <ll MOD>
Mint<MOD> operator-(ll lhs, Mint<MOD> const &rhs) { return -rhs + lhs; }
template <ll MOD>
Mint<MOD> operator*(ll lhs, Mint<MOD> const &rhs) { return rhs * lhs; }
template <ll MOD>
Mint<MOD> operator/(ll lhs, Mint<MOD> const &rhs) { return Mint<MOD>{lhs} / rhs; }
template <ll MOD>
istream &operator>>(istream &stream, Mint<MOD> &a) { return stream >> a.x; }
template <ll MOD>
ostream &operator<<(ostream &stream, Mint<MOD> const &a) { return stream << a.x; }
// ----- Combination -----
template <ll MOD = MOD, ll MAX_SIZE = MAX_SIZE>
class Combination
{
public:
vector<Mint<MOD>> inv, fact, factinv;
Combination() : inv(MAX_SIZE), fact(MAX_SIZE), factinv(MAX_SIZE)
{
inv[1] = 1;
for (auto i{2LL}; i < MAX_SIZE; i++)
{
inv[i] = (-inv[MOD % i]) * (MOD / i);
}
fact[0] = factinv[0] = 1;
for (auto i{1LL}; i < MAX_SIZE; i++)
{
fact[i] = Mint<MOD>(i) * fact[i - 1];
factinv[i] = inv[i] * factinv[i - 1];
}
}
Mint<MOD> operator()(int n, int k)
{
if (n >= 0 && k >= 0 && n - k >= 0)
{
return fact[n] * factinv[k] * factinv[n - k];
}
return 0;
}
Mint<MOD> catalan(int x, int y)
{
return (*this)(x + y, y) - (*this)(x + y, y - 1);
}
};
// ----- for C++14 -----
using mint = Mint<MOD>;
using combination = Combination<MOD, MAX_SIZE>;
template <typename T>
T gcd(T x, T y) { return y ? gcd(y, x % y) : x; }
template <typename T>
T lcm(T x, T y) { return x / gcd(x, y) * y; }
// ----- for C++17 -----
template <typename T>
int popcount(T x) // C++20
{
int ans{0};
while (x != 0)
{
ans += x & 1;
x >>= 1;
}
return ans;
}
// ----- Infty -----
template <typename T>
constexpr T Infty() { return numeric_limits<T>::max(); }
template <typename T>
constexpr T mInfty() { return numeric_limits<T>::min(); }
// ----- frequently used constexpr -----
// constexpr double epsilon{1e-10};
// constexpr ll infty{1'000'000'000'000'010LL}; // or
// constexpr int infty{1'000'000'010};
// constexpr int dx[4] = {1, 0, -1, 0};
// constexpr int dy[4] = {0, 1, 0, -1};
// ----- Yes() and No() -----
void Yes()
{
cout << "Yes" << endl;
exit(0);
}
void No()
{
cout << "0" << endl;
exit(0);
}
// ----- Solve -----
constexpr int C{18};
ll comb(ll n, ll k)
{
ll ans{1};
for (auto i{0LL}; i < k; ++i)
{
ans *= n - i;
ans /= i + 1;
}
return ans;
}
class Solve
{
int N, S, T;
int M;
ll K;
vector<int> A;
public:
Solve(int N) : N{N}, A(N)
{
cin >> K >> S >> T;
for (auto i{0}; i < N; ++i)
{
cin >> A[i];
}
#if DEBUG == 1
cerr << "N = " << N << endl;
for (auto i{0}; i < N; ++i)
{
cerr << "A[" << i << "] = " << A[i] << endl;
}
#endif
normalize();
#if DEBUG == 1
cerr << "N = " << N << endl;
for (auto i{0}; i < N; ++i)
{
cerr << "A[" << i << "] = " << A[i] << endl;
}
cerr << "M = " << M << endl;
#endif
}
void flush()
{
ll ans{0};
for (auto mask{0}; mask < 1 << M; ++mask)
{
if (popcount(mask) & 1)
{
ans -= calc(mask);
}
else
{
ans += calc(mask);
}
}
cout << ans << endl;
}
private:
ll calc(int mask)
{
map<int, ll> X;
for (auto i{0}; i < N; ++i)
{
int tmp{A[i] & mask};
X[tmp];
X[tmp]++;
}
ll ans{1};
for (auto [mask, cnt] : X)
{
for (auto i{1}; i <= min(K, cnt); ++i)
{
ans += comb(cnt, i);
}
}
return ans;
}
void normalize()
{
vector<bool> ok(N, true);
for (auto i{0}; i < C; ++i)
{
auto s{static_cast<bool>(S >> i & 1)};
auto t{static_cast<bool>(T >> i & 1)};
if (s && !t)
{
No();
}
if (s ^ !t)
{
for (auto j{0}; j < N; ++j)
{
if ((A[j] >> i & 1) != static_cast<int>(s))
{
ok[j] = false;
}
}
}
}
vector<int> B;
#if DEBUG == 1
cerr << "B.size() = " << B.size() << endl;
#endif
for (auto i{0}; i < C; ++i)
{
if (ok[i])
{
B.push_back(A[i]);
}
}
#if DEBUG == 1
cerr << "B.size() = " << B.size() << endl;
#endif
swap(A, B);
N = static_cast<int>(A.size());
int k{0};
B = vector<int>(N, 0);
for (auto i{0}; i < C; ++i)
{
auto s{static_cast<bool>(S >> i & 1)};
auto t{static_cast<bool>(T >> i & 1)};
if (!(!s && t))
{
continue;
}
for (auto j{0}; j < N; ++j)
{
B[j] |= (A[j] >> i & 1) << k;
}
++k;
}
swap(A, B);
M = k;
}
};
// ----- main() -----
int main()
{
int N;
cin >> N;
Solve solve(N);
solve.flush();
}
<|endoftext|> |
<commit_before>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/proxy/proxy_resolver_mac.h"
#include <CoreFoundation/CoreFoundation.h>
#include "base/logging.h"
#include "base/mac/foundation_util.h"
#include "base/mac/scoped_cftyperef.h"
#include "base/strings/string_util.h"
#include "base/strings/sys_string_conversions.h"
#include "net/base/net_errors.h"
#include "net/proxy/proxy_info.h"
#include "net/proxy/proxy_server.h"
#if defined(OS_IOS)
#include <CFNetwork/CFProxySupport.h>
#else
#include <CoreServices/CoreServices.h>
#endif
namespace {
// Utility function to map a CFProxyType to a ProxyServer::Scheme.
// If the type is unknown, returns ProxyServer::SCHEME_INVALID.
net::ProxyServer::Scheme GetProxyServerScheme(CFStringRef proxy_type) {
if (CFEqual(proxy_type, kCFProxyTypeNone))
return net::ProxyServer::SCHEME_DIRECT;
if (CFEqual(proxy_type, kCFProxyTypeHTTP))
return net::ProxyServer::SCHEME_HTTP;
if (CFEqual(proxy_type, kCFProxyTypeHTTPS)) {
// The "HTTPS" on the Mac side here means "proxy applies to https://" URLs;
// the proxy itself is still expected to be an HTTP proxy.
return net::ProxyServer::SCHEME_HTTP;
}
if (CFEqual(proxy_type, kCFProxyTypeSOCKS)) {
// We can't tell whether this was v4 or v5. We will assume it is
// v5 since that is the only version OS X supports.
return net::ProxyServer::SCHEME_SOCKS5;
}
return net::ProxyServer::SCHEME_INVALID;
}
// Callback for CFNetworkExecuteProxyAutoConfigurationURL. |client| is a pointer
// to a CFTypeRef. This stashes either |error| or |proxies| in that location.
void ResultCallback(void* client, CFArrayRef proxies, CFErrorRef error) {
DCHECK((proxies != NULL) == (error == NULL));
CFTypeRef* result_ptr = reinterpret_cast<CFTypeRef*>(client);
DCHECK(result_ptr != NULL);
DCHECK(*result_ptr == NULL);
if (error != NULL) {
*result_ptr = CFRetain(error);
} else {
*result_ptr = CFRetain(proxies);
}
CFRunLoopStop(CFRunLoopGetCurrent());
}
} // namespace
namespace net {
ProxyResolverMac::ProxyResolverMac()
: ProxyResolver(false /*expects_pac_bytes*/) {
}
ProxyResolverMac::~ProxyResolverMac() {}
// Gets the proxy information for a query URL from a PAC. Implementation
// inspired by http://developer.apple.com/samplecode/CFProxySupportTool/
int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
ProxyInfo* results,
const CompletionCallback& /*callback*/,
RequestHandle* /*request*/,
const BoundNetLog& net_log) {
base::ScopedCFTypeRef<CFStringRef> query_ref(
base::SysUTF8ToCFStringRef(query_url.spec()));
base::ScopedCFTypeRef<CFURLRef> query_url_ref(
CFURLCreateWithString(kCFAllocatorDefault, query_ref.get(), NULL));
if (!query_url_ref.get())
return ERR_FAILED;
base::ScopedCFTypeRef<CFStringRef> pac_ref(base::SysUTF8ToCFStringRef(
script_data_->type() == ProxyResolverScriptData::TYPE_AUTO_DETECT
? std::string()
: script_data_->url().spec()));
base::ScopedCFTypeRef<CFURLRef> pac_url_ref(
CFURLCreateWithString(kCFAllocatorDefault, pac_ref.get(), NULL));
if (!pac_url_ref.get())
return ERR_FAILED;
// Work around <rdar://problem/5530166>. This dummy call to
// CFNetworkCopyProxiesForURL initializes some state within CFNetwork that is
// required by CFNetworkExecuteProxyAutoConfigurationURL.
CFArrayRef dummy_result = CFNetworkCopyProxiesForURL(query_url_ref.get(),
NULL);
if (dummy_result)
CFRelease(dummy_result);
// We cheat here. We need to act as if we were synchronous, so we pump the
// runloop ourselves. Our caller moved us to a new thread anyway, so this is
// OK to do. (BTW, CFNetworkExecuteProxyAutoConfigurationURL returns a
// runloop source we need to release despite its name.)
CFTypeRef result = NULL;
CFStreamClientContext context = { 0, &result, NULL, NULL, NULL };
base::ScopedCFTypeRef<CFRunLoopSourceRef> runloop_source(
CFNetworkExecuteProxyAutoConfigurationURL(
pac_url_ref.get(), query_url_ref.get(), ResultCallback, &context));
if (!runloop_source)
return ERR_FAILED;
const CFStringRef private_runloop_mode =
CFSTR("org.chromium.ProxyResolverMac");
CFRunLoopAddSource(CFRunLoopGetCurrent(), runloop_source.get(),
private_runloop_mode);
CFRunLoopRunInMode(private_runloop_mode, DBL_MAX, false);
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), runloop_source.get(),
private_runloop_mode);
DCHECK(result != NULL);
if (CFGetTypeID(result) == CFErrorGetTypeID()) {
// TODO(avi): do something better than this
CFRelease(result);
return ERR_FAILED;
}
base::ScopedCFTypeRef<CFArrayRef> proxy_array_ref(
base::mac::CFCastStrict<CFArrayRef>(result));
DCHECK(proxy_array_ref != NULL);
// This string will be an ordered list of <proxy-uri> entries, separated by
// semi-colons. It is the format that ProxyInfo::UseNamedProxy() expects.
// proxy-uri = [<proxy-scheme>"://"]<proxy-host>":"<proxy-port>
// (This also includes entries for direct connection, as "direct://").
std::string proxy_uri_list;
CFIndex proxy_array_count = CFArrayGetCount(proxy_array_ref.get());
for (CFIndex i = 0; i < proxy_array_count; ++i) {
CFDictionaryRef proxy_dictionary = base::mac::CFCastStrict<CFDictionaryRef>(
CFArrayGetValueAtIndex(proxy_array_ref.get(), i));
DCHECK(proxy_dictionary != NULL);
// The dictionary may have the following keys:
// - kCFProxyTypeKey : The type of the proxy
// - kCFProxyHostNameKey
// - kCFProxyPortNumberKey : The meat we're after.
// - kCFProxyUsernameKey
// - kCFProxyPasswordKey : Despite the existence of these keys in the
// documentation, they're never populated. Even if a
// username/password were to be set in the network
// proxy system preferences, we'd need to fetch it
// from the Keychain ourselves. CFProxy is such a
// tease.
// - kCFProxyAutoConfigurationURLKey : If the PAC file specifies another
// PAC file, I'm going home.
CFStringRef proxy_type = base::mac::GetValueFromDictionary<CFStringRef>(
proxy_dictionary, kCFProxyTypeKey);
ProxyServer proxy_server = ProxyServer::FromDictionary(
GetProxyServerScheme(proxy_type),
proxy_dictionary,
kCFProxyHostNameKey,
kCFProxyPortNumberKey);
if (!proxy_server.is_valid())
continue;
if (!proxy_uri_list.empty())
proxy_uri_list += ";";
proxy_uri_list += proxy_server.ToURI();
}
if (!proxy_uri_list.empty())
results->UseNamedProxy(proxy_uri_list);
// Else do nothing (results is already guaranteed to be in the default state).
return OK;
}
void ProxyResolverMac::CancelRequest(RequestHandle request) {
NOTREACHED();
}
LoadState ProxyResolverMac::GetLoadState(RequestHandle request) const {
NOTREACHED();
return LOAD_STATE_IDLE;
}
void ProxyResolverMac::CancelSetPacScript() {
NOTREACHED();
}
int ProxyResolverMac::SetPacScript(
const scoped_refptr<ProxyResolverScriptData>& script_data,
const CompletionCallback& /*callback*/) {
script_data_ = script_data;
return OK;
}
} // namespace net
<commit_msg>ProxyResolverMac: invalidate resolver source.<commit_after>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/proxy/proxy_resolver_mac.h"
#include <CoreFoundation/CoreFoundation.h>
#include "base/logging.h"
#include "base/mac/foundation_util.h"
#include "base/mac/scoped_cftyperef.h"
#include "base/strings/string_util.h"
#include "base/strings/sys_string_conversions.h"
#include "net/base/net_errors.h"
#include "net/proxy/proxy_info.h"
#include "net/proxy/proxy_server.h"
#if defined(OS_IOS)
#include <CFNetwork/CFProxySupport.h>
#else
#include <CoreServices/CoreServices.h>
#endif
namespace {
// Utility function to map a CFProxyType to a ProxyServer::Scheme.
// If the type is unknown, returns ProxyServer::SCHEME_INVALID.
net::ProxyServer::Scheme GetProxyServerScheme(CFStringRef proxy_type) {
if (CFEqual(proxy_type, kCFProxyTypeNone))
return net::ProxyServer::SCHEME_DIRECT;
if (CFEqual(proxy_type, kCFProxyTypeHTTP))
return net::ProxyServer::SCHEME_HTTP;
if (CFEqual(proxy_type, kCFProxyTypeHTTPS)) {
// The "HTTPS" on the Mac side here means "proxy applies to https://" URLs;
// the proxy itself is still expected to be an HTTP proxy.
return net::ProxyServer::SCHEME_HTTP;
}
if (CFEqual(proxy_type, kCFProxyTypeSOCKS)) {
// We can't tell whether this was v4 or v5. We will assume it is
// v5 since that is the only version OS X supports.
return net::ProxyServer::SCHEME_SOCKS5;
}
return net::ProxyServer::SCHEME_INVALID;
}
// Callback for CFNetworkExecuteProxyAutoConfigurationURL. |client| is a pointer
// to a CFTypeRef. This stashes either |error| or |proxies| in that location.
void ResultCallback(void* client, CFArrayRef proxies, CFErrorRef error) {
DCHECK((proxies != NULL) == (error == NULL));
CFTypeRef* result_ptr = reinterpret_cast<CFTypeRef*>(client);
DCHECK(result_ptr != NULL);
DCHECK(*result_ptr == NULL);
if (error != NULL) {
*result_ptr = CFRetain(error);
} else {
*result_ptr = CFRetain(proxies);
}
CFRunLoopStop(CFRunLoopGetCurrent());
}
} // namespace
namespace net {
ProxyResolverMac::ProxyResolverMac()
: ProxyResolver(false /*expects_pac_bytes*/) {
}
ProxyResolverMac::~ProxyResolverMac() {}
// Gets the proxy information for a query URL from a PAC. Implementation
// inspired by http://developer.apple.com/samplecode/CFProxySupportTool/
int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
ProxyInfo* results,
const CompletionCallback& /*callback*/,
RequestHandle* /*request*/,
const BoundNetLog& net_log) {
base::ScopedCFTypeRef<CFStringRef> query_ref(
base::SysUTF8ToCFStringRef(query_url.spec()));
base::ScopedCFTypeRef<CFURLRef> query_url_ref(
CFURLCreateWithString(kCFAllocatorDefault, query_ref.get(), NULL));
if (!query_url_ref.get())
return ERR_FAILED;
base::ScopedCFTypeRef<CFStringRef> pac_ref(base::SysUTF8ToCFStringRef(
script_data_->type() == ProxyResolverScriptData::TYPE_AUTO_DETECT
? std::string()
: script_data_->url().spec()));
base::ScopedCFTypeRef<CFURLRef> pac_url_ref(
CFURLCreateWithString(kCFAllocatorDefault, pac_ref.get(), NULL));
if (!pac_url_ref.get())
return ERR_FAILED;
// Work around <rdar://problem/5530166>. This dummy call to
// CFNetworkCopyProxiesForURL initializes some state within CFNetwork that is
// required by CFNetworkExecuteProxyAutoConfigurationURL.
CFArrayRef dummy_result = CFNetworkCopyProxiesForURL(query_url_ref.get(),
NULL);
if (dummy_result)
CFRelease(dummy_result);
// We cheat here. We need to act as if we were synchronous, so we pump the
// runloop ourselves. Our caller moved us to a new thread anyway, so this is
// OK to do. (BTW, CFNetworkExecuteProxyAutoConfigurationURL returns a
// runloop source we need to release despite its name.)
CFTypeRef result = NULL;
CFStreamClientContext context = { 0, &result, NULL, NULL, NULL };
base::ScopedCFTypeRef<CFRunLoopSourceRef> runloop_source(
CFNetworkExecuteProxyAutoConfigurationURL(
pac_url_ref.get(), query_url_ref.get(), ResultCallback, &context));
if (!runloop_source)
return ERR_FAILED;
const CFStringRef private_runloop_mode =
CFSTR("org.chromium.ProxyResolverMac");
CFRunLoopAddSource(CFRunLoopGetCurrent(), runloop_source.get(),
private_runloop_mode);
CFRunLoopRunInMode(private_runloop_mode, DBL_MAX, false);
CFRunLoopSourceInvalidate(runloop_source.get());
DCHECK(result != NULL);
if (CFGetTypeID(result) == CFErrorGetTypeID()) {
// TODO(avi): do something better than this
CFRelease(result);
return ERR_FAILED;
}
base::ScopedCFTypeRef<CFArrayRef> proxy_array_ref(
base::mac::CFCastStrict<CFArrayRef>(result));
DCHECK(proxy_array_ref != NULL);
// This string will be an ordered list of <proxy-uri> entries, separated by
// semi-colons. It is the format that ProxyInfo::UseNamedProxy() expects.
// proxy-uri = [<proxy-scheme>"://"]<proxy-host>":"<proxy-port>
// (This also includes entries for direct connection, as "direct://").
std::string proxy_uri_list;
CFIndex proxy_array_count = CFArrayGetCount(proxy_array_ref.get());
for (CFIndex i = 0; i < proxy_array_count; ++i) {
CFDictionaryRef proxy_dictionary = base::mac::CFCastStrict<CFDictionaryRef>(
CFArrayGetValueAtIndex(proxy_array_ref.get(), i));
DCHECK(proxy_dictionary != NULL);
// The dictionary may have the following keys:
// - kCFProxyTypeKey : The type of the proxy
// - kCFProxyHostNameKey
// - kCFProxyPortNumberKey : The meat we're after.
// - kCFProxyUsernameKey
// - kCFProxyPasswordKey : Despite the existence of these keys in the
// documentation, they're never populated. Even if a
// username/password were to be set in the network
// proxy system preferences, we'd need to fetch it
// from the Keychain ourselves. CFProxy is such a
// tease.
// - kCFProxyAutoConfigurationURLKey : If the PAC file specifies another
// PAC file, I'm going home.
CFStringRef proxy_type = base::mac::GetValueFromDictionary<CFStringRef>(
proxy_dictionary, kCFProxyTypeKey);
ProxyServer proxy_server = ProxyServer::FromDictionary(
GetProxyServerScheme(proxy_type),
proxy_dictionary,
kCFProxyHostNameKey,
kCFProxyPortNumberKey);
if (!proxy_server.is_valid())
continue;
if (!proxy_uri_list.empty())
proxy_uri_list += ";";
proxy_uri_list += proxy_server.ToURI();
}
if (!proxy_uri_list.empty())
results->UseNamedProxy(proxy_uri_list);
// Else do nothing (results is already guaranteed to be in the default state).
return OK;
}
void ProxyResolverMac::CancelRequest(RequestHandle request) {
NOTREACHED();
}
LoadState ProxyResolverMac::GetLoadState(RequestHandle request) const {
NOTREACHED();
return LOAD_STATE_IDLE;
}
void ProxyResolverMac::CancelSetPacScript() {
NOTREACHED();
}
int ProxyResolverMac::SetPacScript(
const scoped_refptr<ProxyResolverScriptData>& script_data,
const CompletionCallback& /*callback*/) {
script_data_ = script_data;
return OK;
}
} // namespace net
<|endoftext|> |
<commit_before>#include <iostream>
#include <math.h>
using namespace std;
class Mortgage {
public:
void setLoanAmount(float amount) {
this->loanAmount = amount;
}
void setInterestRate(float rate) {
this->interestRate = rate * Mortgage::HUNDRED;
}
void setYears(float years) {
this->numYears = years;
}
float getMonthlyPayment() {
this->payment();
return this->monthlyPayment;
}
private:
const float NUM_MONTHS = 12.0; // Number of months in a year.
const float ONE = 1.0; // Const for one.
const float HUNDRED = 100.0; // Const for one hundred.
float monthlyPayment = 0.0; // Monthly Payment.
float loanAmount = 0.0; // The dollar amount of the loan.
float interestRate = 0.0; // The annual interest rate.
float numYears = 0.0; // The number of years of the loan.
void payment() {
// This function will calculate the monthly payment on a home loan.
// Required Set: loanAmount, interestRate, numYears.
this->monthlyPayment = (this->loanAmount * (this->interestRate / Mortgage::NUM_MONTHS) * this->term()) / (this->term() - Mortgage::ONE);
}
float term() {
// Required Set: interestRate, numYears.
return pow(Mortgage::ONE + (this->interestRate / Mortgage::NUM_MONTHS), (Mortgage::NUM_MONTHS * this->numYears));
}
bool checkInput(float input) {
if (input < 0) {
return false;
}
else {
return true;
}
}
};
int main() {
float years, rate, amount;
Mortgage homeLoan;
cout << "Loan Amount: $";
cin >> amount;
cout << "Interest Rate: %";
cin >> rate;
cout << "Number of Years for Loan: ";
cin >> years;
homeLoan.setInterestRate(rate);
homeLoan.setLoanAmount(amount);
homeLoan.setYears(years);
cout.precision(2);
cout << "Monthly Payment = $" << fixed << homeLoan.getMonthlyPayment();
return 0;
}
<commit_msg>Update Homework-2.cpp<commit_after>//
// main.cpp
// HW3
//
// Created by Vinlock on 1/28/16.
// Copyright © 2016 PvP All Day. All rights reserved.
//
#include <iostream>
#include <math.h>
using namespace std;
class Mortgage {
public:
void setLoanAmount(float amount) {
this->loanAmount = amount;
}
void setInterestRate(float rate) {
this->interestRate = rate / Mortgage::HUNDRED;
}
void setYears(float years) {
this->numYears = years;
}
float getMonthlyPayment() {
this->payment();
return this->monthlyPayment;
}
private:
const float NUM_MONTHS = 12.0; // Number of months in a year.
const float ONE = 1.0; // Const for one.
const float HUNDRED = 100.0; // Const for one hundred.
float monthlyPayment = 0.0; // Monthly Payment.
float loanAmount = 0.0; // The dollar amount of the loan.
float interestRate = 0.0; // The annual interest rate.
float numYears = 0.0; // The number of years of the loan.
void payment() {
// This function will calculate the monthly payment on a home loan.
// Required Set: loanAmount, interestRate, numYears.
this->monthlyPayment = (this->loanAmount * (this->interestRate / Mortgage::NUM_MONTHS) * this->term()) / (this->term() - Mortgage::ONE);
}
float term() {
// Required Set: interestRate, numYears.
return pow(Mortgage::ONE + (this->interestRate / Mortgage::NUM_MONTHS), (Mortgage::NUM_MONTHS * this->numYears));
}
bool checkInput(float input) {
if (input < 0) {
return false;
}
else {
return true;
}
}
};
int main() {
float years, rate, amount;
Mortgage homeLoan;
cout << "Loan Amount: $";
cin >> amount;
cout << "Interest Rate (Percent): %";
cin >> rate;
cout << "Number of Years for Loan: ";
cin >> years;
homeLoan.setInterestRate(rate);
homeLoan.setLoanAmount(amount);
homeLoan.setYears(years);
cout.precision(2);
cout << "Monthly Payment = $" << fixed << homeLoan.getMonthlyPayment();
return 0;
}
<|endoftext|> |
<commit_before>/*=========================================================================
*
* Copyright Leiden University Medical Center, Erasmus University Medical
* Center and contributors
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "selxSuperElastixFilter.h"
#include "selxAnyFileReader.h"
#include "selxAnyFileWriter.h"
#include "selxLogger.h"
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <string>
#include <stdexcept>
template< class T >
std::ostream &
operator<<( std::ostream & os, const std::vector< T > & v )
{
std::copy( v.begin(), v.end(), std::ostream_iterator< T >( os, " " ) );
return os;
}
namespace selx
{
// helper function to parse command line arguments for log level
std::istream& operator>>(std::istream& in, selx::LogLevel& loglevel)
{
std::string token;
in >> token;
if (token == "off")
loglevel = selx::LogLevel::OFF;
else if (token == "critical")
loglevel = selx::LogLevel::CRT;
else if (token == "error")
loglevel = selx::LogLevel::ERR;
else if (token == "warning")
loglevel = selx::LogLevel::WRN;
else if (token == "info")
loglevel = selx::LogLevel::INF;
else if (token == "debug")
loglevel = selx::LogLevel::DBG;
else if (token == "trace")
loglevel = selx::LogLevel::TRC;
else
in.setstate(std::ios_base::failbit);
return in;
}
}
int
main( int ac, char * av[] )
{
selx::Logger::Pointer logger = selx::Logger::New();
logger->AddStream( "cout", std::cout );
logger->SetLogLevel( selx::LogLevel::TRC );
try
{
typedef std::vector< std::string > VectorOfStringsType;
typedef std::vector< boost::filesystem::path > VectorOfPathsType;
boost::filesystem::path logPath;
// default log level
selx::LogLevel logLevel = selx::LogLevel::WRN;
boost::filesystem::path configurationPath;
VectorOfPathsType configurationPaths;
VectorOfStringsType inputPairs;
VectorOfStringsType outputPairs;
boost::program_options::options_description desc("Allowed options");
desc.add_options()
( "help", "produce help message" )
("conf", boost::program_options::value< VectorOfPathsType >(&configurationPaths)->required()->multitoken(), "Configuration file")
("in", boost::program_options::value< VectorOfStringsType >(&inputPairs)->multitoken(), "Input data: images, labels, meshes, etc. Usage <name>=<path>")
("out", boost::program_options::value< VectorOfStringsType >(&outputPairs)->multitoken(), "Output data: images, labels, meshes, etc. Usage <name>=<path>")
("graphout", boost::program_options::value< boost::filesystem::path >(), "Output Graphviz dot file")
("logfile", boost::program_options::value< boost::filesystem::path >(&logPath), "Log output file")
("loglevel", boost::program_options::value< selx::LogLevel >(&logLevel), "Log level")
;
boost::program_options::variables_map vm;
boost::program_options::store(boost::program_options::parse_command_line(ac, av, desc), vm);
boost::program_options::notify(vm);
if( vm.count( "help" ) )
{
std::cout << desc << "\n";
return 0;
}
// optionally, stream to log file
std::ofstream outfile;
if ( vm.count("logfile") )
{
outfile = std::ofstream(logPath.c_str());
logger->AddStream("logfile", outfile);
}
logger->AddStream("SELXcout", std::cout);
logger->SetLogLevel(logLevel);
// instantiate a SuperElastixFilter that is loaded with default components
selx::SuperElastixFilter::Pointer superElastixFilter = selx::SuperElastixFilter::New();
superElastixFilter->SetLogger(logger);
// create empty blueprint
selx::Blueprint::Pointer blueprint = selx::Blueprint::New();
blueprint->SetLogger(logger);
for (const auto & configurationPath : configurationPaths)
{
blueprint->MergeFromFile(configurationPath.string());
}
if( vm.count( "graphout" ) )
{
blueprint->Write(vm["graphout"].as< boost::filesystem::path >().string());
}
// The Blueprint needs to be set to superElastixFilter before GetInputFileReader and GetOutputFileWriter should be called.
superElastixFilter->SetBlueprint(blueprint);
// Store the readers so that they will not be destroyed before the pipeline is executed.
std::vector< selx::AnyFileReader::Pointer > fileReaders;
// Store the writers for the update call
std::vector< selx::AnyFileWriter::Pointer > fileWriters;
if( vm.count( "in" ) )
{
logger->Log( selx::LogLevel::INF, "Preparing input data ... ");
int index = 0;
for( const auto & inputPair : inputPairs )
{
VectorOfStringsType nameAndPath;
boost::split( nameAndPath, inputPair, boost::is_any_of( "=" ) ); // NameAndPath == { "name","path" }
const std::string & name = nameAndPath[ 0 ];
const std::string & path = nameAndPath[ 1 ];
// since we do not know which reader type we should instantiate for input "name",
// we ask SuperElastix for a reader that matches the type of the source component "name"
logger->Log( selx::LogLevel::INF, "Preparing input " + name + " ..." );
selx::AnyFileReader::Pointer reader = superElastixFilter->GetInputFileReader( name );
reader->SetFileName( path );
superElastixFilter->SetInput( name, reader->GetOutput() );
fileReaders.push_back( reader );
logger->Log( selx::LogLevel::INF, "Preparing input " + name + "... Done" );
std::cout << "Input data " << index << " " << name << " : " << path << "\n";
++index;
}
logger->Log( selx::LogLevel::INF, "Preparing input data ... Done");
}
else
{
logger->Log( selx::LogLevel::INF, "No input data specified.");
}
if( vm.count( "out" ) )
{
logger->Log( selx::LogLevel::INF, "Preparing output data ... ");
int index = 0;
for( const auto & outputPair : outputPairs )
{
VectorOfStringsType nameAndPath;
boost::split( nameAndPath, outputPair, boost::is_any_of( "=" ) ); // NameAndPath == { "name","path" }
const std::string & name = nameAndPath[ 0 ];
const std::string & path = nameAndPath[ 1 ];
// since we do not know which writer type we should instantiate for output "name",
// we ask SuperElastix for a writer that matches the type of the sink component "name"
logger->Log( selx::LogLevel::INF, "Preparing output " + name + " ..." );
selx::AnyFileWriter::Pointer writer = superElastixFilter->GetOutputFileWriter( name );
//ImageWriter2DType::Pointer writer = ImageWriter2DType::New();
writer->SetFileName( path );
//writer->SetInput(superElastixFilter->GetOutput<Image2DType>(name));
writer->SetInput( superElastixFilter->GetOutput( name ) );
fileWriters.push_back( writer );
logger->Log( selx::LogLevel::INF, "Preparing output " + name + " ... Done" );
++index;
}
}
else
{
logger->Log( selx::LogLevel::INF, "No output data specified.");
}
/* Execute SuperElastix by updating the writers */
logger->Log( selx::LogLevel::INF, "Executing ...");
for( auto & writer : fileWriters )
{
writer->Update();
}
logger->Log(selx:: LogLevel::INF, "Executing ... Done");
}
catch( std::exception & e )
{
logger->Log( selx::LogLevel::ERR, "Executing ... Error");
std::cerr << "error: " << e.what() << "\n";
return 1;
}
catch( ... )
{
logger->Log( selx::LogLevel::ERR, "Executing ... Error");
std::cerr << "Exception of unknown type!\n";
}
return 0;
}
<commit_msg>GIT: Fix merge error (duplicate code); STYLE: Do not prepend cout stream name with SELX<commit_after>/*=========================================================================
*
* Copyright Leiden University Medical Center, Erasmus University Medical
* Center and contributors
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "selxSuperElastixFilter.h"
#include "selxAnyFileReader.h"
#include "selxAnyFileWriter.h"
#include "selxLogger.h"
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <string>
#include <stdexcept>
template< class T >
std::ostream &
operator<<( std::ostream & os, const std::vector< T > & v )
{
std::copy( v.begin(), v.end(), std::ostream_iterator< T >( os, " " ) );
return os;
}
namespace selx
{
// helper function to parse command line arguments for log level
std::istream& operator>>(std::istream& in, selx::LogLevel& loglevel)
{
std::string token;
in >> token;
if (token == "off")
loglevel = selx::LogLevel::OFF;
else if (token == "critical")
loglevel = selx::LogLevel::CRT;
else if (token == "error")
loglevel = selx::LogLevel::ERR;
else if (token == "warning")
loglevel = selx::LogLevel::WRN;
else if (token == "info")
loglevel = selx::LogLevel::INF;
else if (token == "debug")
loglevel = selx::LogLevel::DBG;
else if (token == "trace")
loglevel = selx::LogLevel::TRC;
else
in.setstate(std::ios_base::failbit);
return in;
}
}
int
main( int ac, char * av[] )
{
selx::Logger::Pointer logger = selx::Logger::New();
try
{
typedef std::vector< std::string > VectorOfStringsType;
typedef std::vector< boost::filesystem::path > VectorOfPathsType;
boost::filesystem::path logPath;
// default log level
selx::LogLevel logLevel = selx::LogLevel::WRN;
boost::filesystem::path configurationPath;
VectorOfPathsType configurationPaths;
VectorOfStringsType inputPairs;
VectorOfStringsType outputPairs;
boost::program_options::options_description desc("Allowed options");
desc.add_options()
( "help", "produce help message" )
("conf", boost::program_options::value< VectorOfPathsType >(&configurationPaths)->required()->multitoken(), "Configuration file")
("in", boost::program_options::value< VectorOfStringsType >(&inputPairs)->multitoken(), "Input data: images, labels, meshes, etc. Usage <name>=<path>")
("out", boost::program_options::value< VectorOfStringsType >(&outputPairs)->multitoken(), "Output data: images, labels, meshes, etc. Usage <name>=<path>")
("graphout", boost::program_options::value< boost::filesystem::path >(), "Output Graphviz dot file")
("logfile", boost::program_options::value< boost::filesystem::path >(&logPath), "Log output file")
("loglevel", boost::program_options::value< selx::LogLevel >(&logLevel), "Log level")
;
boost::program_options::variables_map vm;
boost::program_options::store(boost::program_options::parse_command_line(ac, av, desc), vm);
boost::program_options::notify(vm);
if( vm.count( "help" ) )
{
std::cout << desc << "\n";
return 0;
}
// optionally, stream to log file
std::ofstream outfile;
if ( vm.count("logfile") )
{
outfile = std::ofstream(logPath.c_str());
logger->AddStream("logfile", outfile);
}
logger->AddStream("cout", std::cout);
logger->SetLogLevel(logLevel);
// instantiate a SuperElastixFilter that is loaded with default components
selx::SuperElastixFilter::Pointer superElastixFilter = selx::SuperElastixFilter::New();
superElastixFilter->SetLogger(logger);
// create empty blueprint
selx::Blueprint::Pointer blueprint = selx::Blueprint::New();
blueprint->SetLogger(logger);
for (const auto & configurationPath : configurationPaths)
{
blueprint->MergeFromFile(configurationPath.string());
}
if( vm.count( "graphout" ) )
{
blueprint->Write(vm["graphout"].as< boost::filesystem::path >().string());
}
// The Blueprint needs to be set to superElastixFilter before GetInputFileReader and GetOutputFileWriter should be called.
superElastixFilter->SetBlueprint(blueprint);
// Store the readers so that they will not be destroyed before the pipeline is executed.
std::vector< selx::AnyFileReader::Pointer > fileReaders;
// Store the writers for the update call
std::vector< selx::AnyFileWriter::Pointer > fileWriters;
if( vm.count( "in" ) )
{
logger->Log( selx::LogLevel::INF, "Preparing input data ... ");
int index = 0;
for( const auto & inputPair : inputPairs )
{
VectorOfStringsType nameAndPath;
boost::split( nameAndPath, inputPair, boost::is_any_of( "=" ) ); // NameAndPath == { "name","path" }
const std::string & name = nameAndPath[ 0 ];
const std::string & path = nameAndPath[ 1 ];
// since we do not know which reader type we should instantiate for input "name",
// we ask SuperElastix for a reader that matches the type of the source component "name"
logger->Log( selx::LogLevel::INF, "Preparing input " + name + " ..." );
selx::AnyFileReader::Pointer reader = superElastixFilter->GetInputFileReader( name );
reader->SetFileName( path );
superElastixFilter->SetInput( name, reader->GetOutput() );
fileReaders.push_back( reader );
logger->Log( selx::LogLevel::INF, "Preparing input " + name + "... Done" );
std::cout << "Input data " << index << " " << name << " : " << path << "\n";
++index;
}
logger->Log( selx::LogLevel::INF, "Preparing input data ... Done");
}
else
{
logger->Log( selx::LogLevel::INF, "No input data specified.");
}
if( vm.count( "out" ) )
{
logger->Log( selx::LogLevel::INF, "Preparing output data ... ");
int index = 0;
for( const auto & outputPair : outputPairs )
{
VectorOfStringsType nameAndPath;
boost::split( nameAndPath, outputPair, boost::is_any_of( "=" ) ); // NameAndPath == { "name","path" }
const std::string & name = nameAndPath[ 0 ];
const std::string & path = nameAndPath[ 1 ];
// since we do not know which writer type we should instantiate for output "name",
// we ask SuperElastix for a writer that matches the type of the sink component "name"
logger->Log( selx::LogLevel::INF, "Preparing output " + name + " ..." );
selx::AnyFileWriter::Pointer writer = superElastixFilter->GetOutputFileWriter( name );
//ImageWriter2DType::Pointer writer = ImageWriter2DType::New();
writer->SetFileName( path );
//writer->SetInput(superElastixFilter->GetOutput<Image2DType>(name));
writer->SetInput( superElastixFilter->GetOutput( name ) );
fileWriters.push_back( writer );
logger->Log( selx::LogLevel::INF, "Preparing output " + name + " ... Done" );
++index;
}
}
else
{
logger->Log( selx::LogLevel::INF, "No output data specified.");
}
/* Execute SuperElastix by updating the writers */
logger->Log( selx::LogLevel::INF, "Executing ...");
for( auto & writer : fileWriters )
{
writer->Update();
}
logger->Log(selx:: LogLevel::INF, "Executing ... Done");
}
catch( std::exception & e )
{
logger->Log( selx::LogLevel::ERR, "Executing ... Error");
std::cerr << "error: " << e.what() << "\n";
return 1;
}
catch( ... )
{
logger->Log( selx::LogLevel::ERR, "Executing ... Error");
std::cerr << "Exception of unknown type!\n";
}
return 0;
}
<|endoftext|> |
<commit_before><commit_msg>nspluginwrapper compat fixes, part 1: Set the correct size in NP_GetEntryPoints. The old code was assigning the size of the _pointer_ (i.e., 4). Apparently most browsers ignore this or else O3D wouldn't have worked anywhere, but nspluginwrapper started to care about this very much somewhere between 1.2.2 and 1.3.1-Pre (20090625). With the old code it stops before even calling our NPP_New because it thinks we don't have one.<commit_after><|endoftext|> |
<commit_before>//------------------------------------------------------------------------------
//
// Arion
//
// Extract metadata and create beautiful thumbnails of your images.
//
// ------------
// main.cpp
// ------------
//
// Copyright (c) 2015 Paul Filitchkin, Snapwire
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// * Neither the name of the organization nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//------------------------------------------------------------------------------
// Local
#include "models/operation.hpp"
#include "models/resize.hpp"
#include "models/read_meta.hpp"
#include "utils/utils.hpp"
#include "arion.hpp"
// Boost
#include <boost/exception/info.hpp>
#include <boost/exception/error_info.hpp>
#include <boost/exception/all.hpp>
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/program_options.hpp>
#include <boost/lexical_cast.hpp>
// Stdlib
#include <iostream>
#include <string>
using namespace boost::program_options;
using namespace std;
#define ARION_VERSION "0.3.3"
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void showHelp(options_description &desc) {
cerr << desc << endl;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int main(int argc, char *argv[]) {
try {
positional_options_description p;
p.add("input", 1);
string description = "Arion v";
description += ARION_VERSION;
description += "\n\n Arguments";
options_description desc(description);
desc.add_options()
("help", "Produce this help message")
("version", "Print version")
("input", value<string>(), "The input operations to execute in JSON");
variables_map vm;
store(command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
notify(vm);
string inputJson;
if (vm.count("help")) {
showHelp(desc);
return 1;
}
if (vm.count("version")) {
cout << "{\"version\":\"" << ARION_VERSION << "\"}" << endl;
return 0;
}
if (vm.count("input")) {
inputJson = vm["input"].as<string>();
} else {
cout << "You must provide the input operations to execute" << endl << endl;
showHelp(desc);
return 1;
}
Arion arion;
if (!arion.setup(inputJson)) {
cout << arion.getJson();
exit(-1);
}
bool result = arion.run();
cout << arion.getJson();
if (result) {
exit(0);
} else {
exit(-1);
}
}
catch (std::exception &e) {
Utils::exitWithError(e.what());
}
return 0;
}
<commit_msg>0.3.4<commit_after>//------------------------------------------------------------------------------
//
// Arion
//
// Extract metadata and create beautiful thumbnails of your images.
//
// ------------
// main.cpp
// ------------
//
// Copyright (c) 2015 Paul Filitchkin, Snapwire
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// * Neither the name of the organization nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//------------------------------------------------------------------------------
// Local
#include "models/operation.hpp"
#include "models/resize.hpp"
#include "models/read_meta.hpp"
#include "utils/utils.hpp"
#include "arion.hpp"
// Boost
#include <boost/exception/info.hpp>
#include <boost/exception/error_info.hpp>
#include <boost/exception/all.hpp>
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <boost/program_options.hpp>
#include <boost/lexical_cast.hpp>
// Stdlib
#include <iostream>
#include <string>
using namespace boost::program_options;
using namespace std;
#define ARION_VERSION "0.3.4"
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void showHelp(options_description &desc) {
cerr << desc << endl;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int main(int argc, char *argv[]) {
try {
positional_options_description p;
p.add("input", 1);
string description = "Arion v";
description += ARION_VERSION;
description += "\n\n Arguments";
options_description desc(description);
desc.add_options()
("help", "Produce this help message")
("version", "Print version")
("input", value<string>(), "The input operations to execute in JSON");
variables_map vm;
store(command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
notify(vm);
string inputJson;
if (vm.count("help")) {
showHelp(desc);
return 1;
}
if (vm.count("version")) {
cout << "{\"version\":\"" << ARION_VERSION << "\"}" << endl;
return 0;
}
if (vm.count("input")) {
inputJson = vm["input"].as<string>();
} else {
cout << "You must provide the input operations to execute" << endl << endl;
showHelp(desc);
return 1;
}
Arion arion;
if (!arion.setup(inputJson)) {
cout << arion.getJson();
exit(-1);
}
bool result = arion.run();
cout << arion.getJson();
if (result) {
exit(0);
} else {
exit(-1);
}
}
catch (std::exception &e) {
Utils::exitWithError(e.what());
}
return 0;
}
<|endoftext|> |
<commit_before>#include <allegro5\allegro.h>
#include "objects.h"
//Global variables
const int WIDTH = 800;
const int HEIGHT = 600;
int main()
{
//primitve variables
bool done = false; //event loop fundamental variable
//Allegro variables
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
//inits
if(!al_init())
return -1;
display = al_create_display(WIDTH, HEIGHT);
if(!display)
return -1;
al_install_keyboard();
event_queue = al_create_event_queue();
//event registers
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
//gameloop
while(!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
done = true;
}
}
//deallocating memory used for allegro objects
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}<commit_msg>Included timer into the gameloop + minor changes<commit_after>#include <allegro5\allegro.h>
#include "objects.h"
//Global variables
const int WIDTH = 800;
const int HEIGHT = 600;
bool keys[] = {false, false, false, false};
int main()
{
//primitve variables
bool done = false; //event loop fundamental variable
bool redraw = true; //check whether the display needs an update
const int FPS = 60;
//Allegro variables
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
//inits
if(!al_init())
return -1;
display = al_create_display(WIDTH, HEIGHT);
if(!display)
return -1;
al_install_keyboard();
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / FPS);
//event registers
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_start_timer(timer);
//gameloop
while(!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
if(ev.type == ALLEGRO_EVENT_TIMER)
{
redraw = true;
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
done = true; //closing the game after clicking X on top-right corner
}
if(redraw && al_is_event_queue_empty(event_queue))
{
redraw = false;
al_flip_display();
al_clear_to_color(al_map_rgb(0,0,0)); //black background
}
}
//deallocating memory used for allegro objects
al_destroy_display(display);
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
return 0;
}<|endoftext|> |
<commit_before>#include <cstdlib>
#include <iostream>
/*
* Add command line arguments
* ideas:
* difficulty (speed), color, graphics
* debugging, etc.
*/
int main( void )
{
//load board
//set up screen
while( true ) //game loop
{
//take user input
//action from input
//check for collisions
//check for lines? (maybe should go somewhere else)
//update board
//update screen
if( true ) //end game conditional
break;
}
exit( EXIT_SUCCESS );
}
<commit_msg>Add getopt skeleton<commit_after>#include <cstdlib>
#include <iostream>
#include <GetOpt.h>
/*
* Add command line arguments
* ideas:
* difficulty (speed), color, graphics
* debugging, etc.
*/
int main( int argc, char **argv )
{
GetOpt getopt( argc, argv, "lscgd:" );
int opt;
int level;
bool debug = false;
while( ( opt = getopt() ) != EOF )
{
switch( opt )
{
case 'l':
level = atoi( getopt.optarg );
break;
case 'd':
debug = true;
break;
case 's':
break;
case 'c':
break;
case 'g':
break;
default:
break;
}
}
//load board
//set up screen
while( true ) //game loop
{
//take user input
//action from input
//check for collisions
//check for lines? (maybe should go somewhere else)
//update board
//update screen
if( true ) //end game conditional
break;
}
exit( EXIT_SUCCESS );
}
<|endoftext|> |
<commit_before>/**
* Copyright (C) 2014 Jonathan Gillett, Joseph Heron, Khalil Fazal, Daniel Smullen
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <Writer.hpp>
#include <Reader.hpp>
#include <unistd.h>
//Declare the maximum buffer size for interacting with the socket.
#define MAX_BUFFER_SIZE 256
int open(const char* hostname, const uint16_t port) {
// The socket address
struct sockaddr_in address;
// The socket host
struct hostent* host = gethostbyname(hostname);
// The socket's file descriptor
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
// allocate address with null bytes
bzero((char *) &address, sizeof(address));
// set the address format to IPV4
address.sin_family = AF_INET;
// set the host in the address
memmove((char *) &address.sin_addr.s_addr, (char *) host->h_addr, host->h_length);
// set the port in the address
address.sin_port = htons(port);
// connect to the socket
connect(sockfd, (struct sockaddr *) &address, sizeof(address));
// return the socket
return sockfd;
}
int main(int argc, char** argv) {
(void) argc;
(void) argv;
//Declare a socket instance here.
/*struct sockaddr_in server;
string address = "192.168.0.1";
server.sin_port = htons(1234);
inet_aton(address., &server.sin_addr.s_addr);
//Open the socket. If it fails to bind, terminate.
int s = socket(AF_INET, SOCK_STREAM, 0);
if (s == -1) {
cout << "Invalid socket descriptor.";
return -1;
} else {
cout << "Socket bound.";
}
//Connect to the socket. If it fails to connect, terminate.
cout << "Connecting to socket on address: " << address << " port: "
<< server.sin_port << endl;
if (connect(s, (struct sockaddr *) &server, sizeof(server)) == -1) {
cout << "Socket connection failed.";
return -1;
}*/
int s = open("192.168.0.1", 1234);
//Instantiate reader thread here; bind to connected socket.
Reader r(s, MAX_BUFFER_SIZE);
//Instantiate writer thread here; bind to connected socket.
Writer w(s, MAX_BUFFER_SIZE);
//Signal the writer thread to subscribe to the events.
//Put the following into the buffer, and notify the writer thread:
//w.sendCommand("request(100,view)\n");
//Begin main control loop:
for(;;){
//Check if we've received something from the socket.
//Output it to the console.
cout << r.readCommand() << endl;
}
//Join and release the reader thread.
r.release();
//Join and release the writer thread.
w.release();
return 0;
}
<commit_msg>added send command for initialization.<commit_after>/**
* Copyright (C) 2014 Jonathan Gillett, Joseph Heron, Khalil Fazal, Daniel Smullen
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <Writer.hpp>
#include <Reader.hpp>
#include <unistd.h>
//Declare the maximum buffer size for interacting with the socket.
#define MAX_BUFFER_SIZE 256
int open(const char* hostname, const uint16_t port) {
// The socket address
struct sockaddr_in address;
// The socket host
struct hostent* host = gethostbyname(hostname);
// The socket's file descriptor
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
// allocate address with null bytes
bzero((char *) &address, sizeof(address));
// set the address format to IPV4
address.sin_family = AF_INET;
// set the host in the address
memmove((char *) &address.sin_addr.s_addr, (char *) host->h_addr, host->h_length);
// set the port in the address
address.sin_port = htons(port);
// connect to the socket
connect(sockfd, (struct sockaddr *) &address, sizeof(address));
// return the socket
return sockfd;
}
int main(int argc, char** argv) {
(void) argc;
(void) argv;
//Declare a socket instance here.
/*struct sockaddr_in server;
string address = "192.168.0.1";
server.sin_port = htons(1234);
inet_aton(address., &server.sin_addr.s_addr);
//Open the socket. If it fails to bind, terminate.
int s = socket(AF_INET, SOCK_STREAM, 0);
if (s == -1) {
cout << "Invalid socket descriptor.";
return -1;
} else {
cout << "Socket bound.";
}
//Connect to the socket. If it fails to connect, terminate.
cout << "Connecting to socket on address: " << address << " port: "
<< server.sin_port << endl;
if (connect(s, (struct sockaddr *) &server, sizeof(server)) == -1) {
cout << "Socket connection failed.";
return -1;
}*/
int s = open("192.168.0.1", 1234);
//Instantiate reader thread here; bind to connected socket.
Reader r(s, MAX_BUFFER_SIZE);
//Instantiate writer thread here; bind to connected socket.
Writer w(s, MAX_BUFFER_SIZE);
//1. Request control of the train
//w.sendCommand("request(1005,control,force)\n");
//2. Signal the writer thread to subscribe to the events.
// Put the following into the buffer, and notify the writer thread:
//w.sendCommand("request(100,view)\n");
//3. Get Control of F1
//w.sendCommand("request(20002,control,force)\n");
// TODO: sleep(100 ms)
usleep(100000);
//4. Get Control of F2
//w.sendCommand("request(20000,control,force)\n");
// TODO: sleep(100 ms)
usleep(100000);
//5. Get Control of J1
//w.sendCommand("request(20001,control,force)\n");
// TODO: sleep(100 ms)
usleep(100000);
//6. Get Control of J2
//w.sendCommand("request(20003,control,force)\n");
//7.
//Begin main control loop:
while (true) {
//Check if we've received something from the socket.
//Output it to the console.
cout << r.readCommand() << endl;
}
//Join and release the reader thread.
r.release();
//Join and release the writer thread.
w.release();
return 0;
}
<|endoftext|> |
<commit_before>#include "mraa.h"
#include <chrono>
#include <thread>
#include <stdio.h>
#include <string.h>
#include <curl/curl.h>
enum COMMAND
{
IDLE = 0,
FORWARD = 1,
REVERSE = 2,
LEFT = 4,
RIGHT = 8
};
const char* COMMAND_NAMES[] = {"IDLE","FORWARD","REVERSE","INVALID","LEFT","INVALID","INVALID","INVALID","RIGHT"};
struct context
{
mraa_gpio_context drive_context;
mraa_gpio_context reverse_context;
};
int getCommand();
void loop(context& gpio_context);
int gMagnitude = 0;
bool gReverseEnabled = false;
const char* RC_ADDRESS = "http://192.168.1.243:8080/CommandServer/currentCommand";
#define DRIVE_MOTOR_GPIO 31 //GP44
#define REVERSE_ENGAGE_GPIO 32 //GP46
#define DEFAULT_WAIT_TIME_MS 300
int main(int argc, char** argv)
{
curl_global_init(CURL_GLOBAL_DEFAULT);
mraa_init();
mraa_gpio_context drive_context = mraa_gpio_init(DRIVE_MOTOR_GPIO);
if(drive_context == NULL || mraa_gpio_dir(drive_context, MRAA_GPIO_OUT) != MRAA_SUCCESS) exit(1);
mraa_gpio_write(drive_context, false);
mraa_gpio_context reverse_context = mraa_gpio_init(REVERSE_ENGAGE_GPIO);
if(reverse_context == NULL || mraa_gpio_dir(reverse_context, MRAA_GPIO_OUT) != MRAA_SUCCESS) exit(1);
mraa_gpio_write(reverse_context, false);
printf("%s Wifi RC Interface\n", mraa_get_platform_name());
context session;
session.drive_context = drive_context;
session.reverse_context = reverse_context;
while(true) loop(session);
curl_global_cleanup();
mraa_deinit();
return 0;
}
size_t curl_write_function(void* buffer, size_t size, size_t nmemb, int* p)
{
static const char* NAME_STRING = "Name";
static const char* VALUE_STRING = "Value";
static const char* RESPONSE_STRING = "Response";
static const char* TERMINAL_STRING = "Terminal";
static const char* directionTerminal = "direction";
static const char* magnitudeTerminal = "magnitude";
char test[64];
char name[64];
char value[64];
char* parse = strstr((char*)buffer, RESPONSE_STRING)+strlen(RESPONSE_STRING)+1;
memset(test, '\0', 64);
memcpy(test, parse+3, strlen(RESPONSE_STRING));
while(strcmp(test, RESPONSE_STRING))
{
parse = strstr(parse, TERMINAL_STRING)+strlen(TERMINAL_STRING)+1;
parse = strstr(parse, NAME_STRING)+strlen(NAME_STRING)+1;
int length = strchr(parse, '<')-parse;
memset(name, '\0', 64);
memcpy(name, parse, length);
parse = strstr(parse, VALUE_STRING)+strlen(VALUE_STRING)+1;
length = strchr(parse, '<')-parse;
memset(value, '\0', 64);
memcpy(value, parse, length);
parse = strstr(parse, TERMINAL_STRING)+strlen(TERMINAL_STRING)+1;
memset(test, '\0', 64);
memcpy(test, parse+3, strlen(RESPONSE_STRING));
if(!strcmp(name, directionTerminal))
{
*p = atoi(value);
}
if(!strcmp(name, magnitudeTerminal))
{
gMagnitude = atoi(value);
}
}
return size*nmemb;
}
int getCommand()
{
int command = IDLE;
CURL* pCURL = curl_easy_init();
if(pCURL)
{
int temp;
curl_easy_setopt(pCURL, CURLOPT_URL, RC_ADDRESS);
curl_easy_setopt(pCURL, CURLOPT_WRITEFUNCTION, curl_write_function);
curl_easy_setopt(pCURL, CURLOPT_WRITEDATA, &temp);
CURLcode result = curl_easy_perform(pCURL);
if(result == CURLE_OK)
{
command = temp;
}
curl_easy_cleanup(pCURL);
}
return command;
}
void enableReverse(bool enabled, context& gpio_context)
{
mraa_gpio_write(gpio_context.drive_context, false);
std::this_thread::sleep_for(std::chrono::milliseconds(DEFAULT_WAIT_TIME_MS));
mraa_gpio_write(gpio_context.reverse_context, enabled);
gReverseEnabled = enabled;
}
void loop(context& gpio_context)
{
int raw = getCommand();
int value = raw;
if(value > 3) value &= 0xC;
printf("%s\n", COMMAND_NAMES[value]);
bool killReverse = true;
bool shouldDrive = false;
switch(raw &= 0x3)
{
case FORWARD:
shouldDrive = true;
break;
case REVERSE:
killReverse = false;
if(!gReverseEnabled) enableReverse(true, gpio_context);
shouldDrive = true;
break;
case IDLE:
default:
break;
}
if(gReverseEnabled && killReverse) enableReverse(false, gpio_context);
mraa_gpio_write(gpio_context.drive_context, shouldDrive);
std::this_thread::sleep_for(std::chrono::milliseconds(gMagnitude > 0 ? gMagnitude: DEFAULT_WAIT_TIME_MS));
}
<commit_msg>Prep for programmatic headlight control<commit_after>#include "mraa.h"
#include <chrono>
#include <thread>
#include <stdio.h>
#include <string.h>
#include <curl/curl.h>
enum COMMAND
{
IDLE = 0,
FORWARD = 1,
REVERSE = 2,
LEFT = 4,
RIGHT = 8
};
const char* COMMAND_NAMES[] = {"IDLE","FORWARD","REVERSE","INVALID","LEFT","INVALID","INVALID","INVALID","RIGHT"};
struct context
{
mraa_gpio_context drive_context;
mraa_gpio_context reverse_context;
mraa_gpio_context light_context;
};
int getCommand();
void loop(context& gpio_context);
int gMagnitude = 0;
bool gReverseEnabled = false;
const char* RC_ADDRESS = "http://192.168.1.243:8080/CommandServer/currentCommand";
#define DRIVE_MOTOR_GPIO 31 //GP44
#define REVERSE_ENGAGE_GPIO 32 //GP46
#define LIGHT_GPIO 33 //GP48
#define DEFAULT_WAIT_TIME_MS 300
int main(int argc, char** argv)
{
curl_global_init(CURL_GLOBAL_DEFAULT);
mraa_init();
mraa_gpio_context drive_context = mraa_gpio_init(DRIVE_MOTOR_GPIO);
if(drive_context == NULL || mraa_gpio_dir(drive_context, MRAA_GPIO_OUT) != MRAA_SUCCESS) exit(1);
mraa_gpio_write(drive_context, false);
mraa_gpio_context reverse_context = mraa_gpio_init(REVERSE_ENGAGE_GPIO);
if(reverse_context == NULL || mraa_gpio_dir(reverse_context, MRAA_GPIO_OUT) != MRAA_SUCCESS) exit(1);
mraa_gpio_write(reverse_context, false);
mraa_gpio_context light_context = mraa_gpio_init(LIGHT_GPIO);
if(light_context == NULL || mraa_gpio_dir(light_context, MRAA_GPIO_OUT) != MRAA_SUCCESS) exit(1);
mraa_gpio_write(light_context, false);
printf("%s Wifi RC Interface\n", mraa_get_platform_name());
context session;
session.drive_context = drive_context;
session.reverse_context = reverse_context;
session.light_context = light_context;
while(true) loop(session);
curl_global_cleanup();
mraa_deinit();
return 0;
}
size_t curl_write_function(void* buffer, size_t size, size_t nmemb, int* p)
{
static const char* NAME_STRING = "Name";
static const char* VALUE_STRING = "Value";
static const char* RESPONSE_STRING = "Response";
static const char* TERMINAL_STRING = "Terminal";
static const char* directionTerminal = "direction";
static const char* magnitudeTerminal = "magnitude";
char test[64];
char name[64];
char value[64];
char* parse = strstr((char*)buffer, RESPONSE_STRING)+strlen(RESPONSE_STRING)+1;
memset(test, '\0', 64);
memcpy(test, parse+3, strlen(RESPONSE_STRING));
while(strcmp(test, RESPONSE_STRING))
{
parse = strstr(parse, TERMINAL_STRING)+strlen(TERMINAL_STRING)+1;
parse = strstr(parse, NAME_STRING)+strlen(NAME_STRING)+1;
int length = strchr(parse, '<')-parse;
memset(name, '\0', 64);
memcpy(name, parse, length);
parse = strstr(parse, VALUE_STRING)+strlen(VALUE_STRING)+1;
length = strchr(parse, '<')-parse;
memset(value, '\0', 64);
memcpy(value, parse, length);
parse = strstr(parse, TERMINAL_STRING)+strlen(TERMINAL_STRING)+1;
memset(test, '\0', 64);
memcpy(test, parse+3, strlen(RESPONSE_STRING));
if(!strcmp(name, directionTerminal))
{
*p = atoi(value);
}
if(!strcmp(name, magnitudeTerminal))
{
gMagnitude = atoi(value);
}
}
return size*nmemb;
}
int getCommand()
{
int command = IDLE;
CURL* pCURL = curl_easy_init();
if(pCURL)
{
int temp;
curl_easy_setopt(pCURL, CURLOPT_URL, RC_ADDRESS);
curl_easy_setopt(pCURL, CURLOPT_WRITEFUNCTION, curl_write_function);
curl_easy_setopt(pCURL, CURLOPT_WRITEDATA, &temp);
CURLcode result = curl_easy_perform(pCURL);
if(result == CURLE_OK)
{
command = temp;
}
curl_easy_cleanup(pCURL);
}
return command;
}
void enableReverse(bool enabled, context& gpio_context)
{
mraa_gpio_write(gpio_context.drive_context, false);
std::this_thread::sleep_for(std::chrono::milliseconds(DEFAULT_WAIT_TIME_MS));
mraa_gpio_write(gpio_context.reverse_context, enabled);
gReverseEnabled = enabled;
}
void loop(context& gpio_context)
{
int raw = getCommand();
int value = raw;
if(value > 3) value &= 0xC;
printf("%s\n", COMMAND_NAMES[value]);
bool killReverse = true;
bool shouldDrive = false;
switch(raw &= 0x3)
{
case FORWARD:
shouldDrive = true;
break;
case REVERSE:
killReverse = false;
if(!gReverseEnabled) enableReverse(true, gpio_context);
shouldDrive = true;
break;
case IDLE:
default:
break;
}
if(gReverseEnabled && killReverse) enableReverse(false, gpio_context);
mraa_gpio_write(gpio_context.drive_context, shouldDrive);
std::this_thread::sleep_for(std::chrono::milliseconds(gMagnitude > 0 ? gMagnitude: DEFAULT_WAIT_TIME_MS));
}
<|endoftext|> |
<commit_before>/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "otbSarImageMetadataInterface.h"
#include "otbSentinel1ImageMetadataInterface.h"
#include "otbMacro.h"
#include "itkMetaDataObject.h"
#include "otbImageKeywordlist.h"
//useful constants
#include <otbMath.h>
namespace otb
{
Sentinel1ImageMetadataInterface
::Sentinel1ImageMetadataInterface()
{
}
bool
Sentinel1ImageMetadataInterface::CanRead() const
{
std::string sensorID = GetSensorID();
if (sensorID.find("SENTINEL-1") != std::string::npos)
{
return true;
}
else
return false;
}
void
Sentinel1ImageMetadataInterface
::CreateCalibrationLookupData(const short type)
{
bool sigmaLut = false;
bool betaLut = false;
bool gammaLut = false;
bool dnLut = false;
switch (type)
{
case SarCalibrationLookupData::BETA:
{
betaLut = true;
}
break;
case SarCalibrationLookupData::GAMMA:
{
gammaLut = true;
}
break;
case SarCalibrationLookupData::DN:
{
dnLut = true;
}
break;
case SarCalibrationLookupData::SIGMA:
default:
sigmaLut = true;
break;
}
const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist();
const double firstLineTime = Utils::LexicalCast<double>(imageKeywordlist.GetMetadataByKey("calibration.startTime"), "calibration.startTime(double)");
const double lastLineTime = Utils::LexicalCast<double>(imageKeywordlist.GetMetadataByKey("calibration.stopTime"), "calibration.stopTime(double)");
const std::string bandPrefix = "Band[0]."; //make && use GetBandPrefix(subSwath, polarisation)
const int numOfLines = Utils::LexicalCast<int>(imageKeywordlist.GetMetadataByKey(bandPrefix + "number_lines"), bandPrefix + "number_lines(int)");
const int count = Utils::LexicalCast<int>(imageKeywordlist.GetMetadataByKey("calibration.count"), "calibration.count");
std::vector<Sentinel1CalibrationStruct> calibrationVectorList(count);
for(int i = 0; i < count; i++)
{
Sentinel1CalibrationStruct calibrationVector;
std::stringstream prefix;
prefix << "calibration.calibrationVector[" << i << "].";
calibrationVector.line = Utils::LexicalCast<int>(imageKeywordlist.GetMetadataByKey(prefix.str() + "line"), prefix.str() + "line");
calibrationVector.timeMJD = Utils::LexicalCast<double>(imageKeywordlist.GetMetadataByKey(prefix.str() + "azimuthTime"), prefix.str() + "azimuthTime");
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "pixel"), calibrationVector.pixels, prefix.str() + "pixel");
if (sigmaLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "sigmaNought"), calibrationVector.vect, prefix.str() + "sigmaNought");
}
if (betaLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "betaNought"), calibrationVector.vect, prefix.str() + "betaNought");
}
if (gammaLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "gamma"), calibrationVector.vect, prefix.str() + "gamma");
}
if (dnLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "dn"), calibrationVector.vect, prefix.str() + "dn");
}
calibrationVectorList[i] = calibrationVector;
}
Sentinel1CalibrationLookupData::Pointer sarLut;
sarLut = Sentinel1CalibrationLookupData::New();
sarLut->InitParameters(type, firstLineTime, lastLineTime, numOfLines, count, calibrationVectorList);
this->SetCalibrationLookupData(sarLut);
}
void
Sentinel1ImageMetadataInterface
::ParseDateTime(const char* key, std::vector<int>& dateFields) const
{
if(dateFields.size() < 1 )
{
//parse from keyword list
if (!this->CanRead())
{
itkExceptionMacro(<< "Invalid Metadata, not a valid product");
}
const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist();
if (!imageKeywordlist.HasKey(key))
{
itkExceptionMacro( << "no key named " << key );
}
const std::string date_time_str = imageKeywordlist.GetMetadataByKey(key);
Utils::ConvertStringToVector(date_time_str, dateFields, key, " T:-.");
}
}
int
Sentinel1ImageMetadataInterface::GetYear() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 0 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[0], " support_data.image_date:year(int)" );
}
else
{
itkExceptionMacro( << "Invalid year" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetMonth() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 1 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[1], " support_data.image_date:month(int)" );
}
else
{
itkExceptionMacro( << "Invalid month" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetDay() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 2 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[2], " support_data.image_date:day(int)");
}
else
{
itkExceptionMacro( << "Invalid day" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetHour() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 3 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[3], " support_data.image_date:hour(int)");
}
else
{
itkExceptionMacro( << "Invalid hour" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetMinute() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 4 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[4], " support_data.image_date:minute(int)");
}
else
{
itkExceptionMacro( << "Invalid minute" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetProductionYear() const
{
int value = 0;
ParseDateTime("support_data.date", m_ProductionDateFields);
if(m_ProductionDateFields.size() > 0 )
{
value = Utils::LexicalCast<int>( m_ProductionDateFields[0], " support_data.date:year(int)" );
}
else
{
itkExceptionMacro( << "Invalid production year" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetProductionMonth() const
{
int value = 0;
ParseDateTime("support_data.date", m_ProductionDateFields);
if(m_ProductionDateFields.size() > 1 )
{
value = Utils::LexicalCast<int>( m_ProductionDateFields[1], " support_data.date:month(int)" );
}
else
{
itkExceptionMacro( << "Invalid production month" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetProductionDay() const
{
int value = 0;
ParseDateTime("support_data.date", m_ProductionDateFields);
if(m_ProductionDateFields.size() > 2 )
{
value = Utils::LexicalCast<int>( m_ProductionDateFields[2], " support_data.date:day(int)" );
}
else
{
itkExceptionMacro( << "Invalid production day" );
}
return value;
}
double
Sentinel1ImageMetadataInterface::GetPRF() const
{
double value = 0;
const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist();
if (!imageKeywordlist.HasKey("support_data.pulse_repetition_frequency"))
{
return value;
}
value = Utils::LexicalCast<double>( imageKeywordlist.GetMetadataByKey("support_data.pulse_repetition_frequency"),
"support_data.pulse_repetition_frequency(double)" );
return value;
}
Sentinel1ImageMetadataInterface::UIntVectorType
Sentinel1ImageMetadataInterface::GetDefaultDisplay() const
{
UIntVectorType rgb(3);
rgb[0] = 0;
rgb[1] = 0;
rgb[2] = 0;
return rgb;
}
double
Sentinel1ImageMetadataInterface::GetRSF() const
{
return 0;
}
double
Sentinel1ImageMetadataInterface::GetRadarFrequency() const
{
return 0;
}
double
Sentinel1ImageMetadataInterface::GetCenterIncidenceAngle() const
{
return 0;
}
} // end namespace otb
<commit_msg>ENH: remove extra space in the errmsg argument<commit_after>/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "otbSarImageMetadataInterface.h"
#include "otbSentinel1ImageMetadataInterface.h"
#include "otbMacro.h"
#include "itkMetaDataObject.h"
#include "otbImageKeywordlist.h"
//useful constants
#include <otbMath.h>
namespace otb
{
Sentinel1ImageMetadataInterface
::Sentinel1ImageMetadataInterface()
{
}
bool
Sentinel1ImageMetadataInterface::CanRead() const
{
std::string sensorID = GetSensorID();
if (sensorID.find("SENTINEL-1") != std::string::npos)
{
return true;
}
else
return false;
}
void
Sentinel1ImageMetadataInterface
::CreateCalibrationLookupData(const short type)
{
bool sigmaLut = false;
bool betaLut = false;
bool gammaLut = false;
bool dnLut = false;
switch (type)
{
case SarCalibrationLookupData::BETA:
{
betaLut = true;
}
break;
case SarCalibrationLookupData::GAMMA:
{
gammaLut = true;
}
break;
case SarCalibrationLookupData::DN:
{
dnLut = true;
}
break;
case SarCalibrationLookupData::SIGMA:
default:
sigmaLut = true;
break;
}
const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist();
const double firstLineTime = Utils::LexicalCast<double>(imageKeywordlist.GetMetadataByKey("calibration.startTime"), "calibration.startTime(double)");
const double lastLineTime = Utils::LexicalCast<double>(imageKeywordlist.GetMetadataByKey("calibration.stopTime"), "calibration.stopTime(double)");
const std::string bandPrefix = "Band[0]."; //make && use GetBandPrefix(subSwath, polarisation)
const int numOfLines = Utils::LexicalCast<int>(imageKeywordlist.GetMetadataByKey(bandPrefix + "number_lines"), bandPrefix + "number_lines(int)");
const int count = Utils::LexicalCast<int>(imageKeywordlist.GetMetadataByKey("calibration.count"), "calibration.count");
std::vector<Sentinel1CalibrationStruct> calibrationVectorList(count);
for(int i = 0; i < count; i++)
{
Sentinel1CalibrationStruct calibrationVector;
std::stringstream prefix;
prefix << "calibration.calibrationVector[" << i << "].";
calibrationVector.line = Utils::LexicalCast<int>(imageKeywordlist.GetMetadataByKey(prefix.str() + "line"), prefix.str() + "line");
calibrationVector.timeMJD = Utils::LexicalCast<double>(imageKeywordlist.GetMetadataByKey(prefix.str() + "azimuthTime"), prefix.str() + "azimuthTime");
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "pixel"), calibrationVector.pixels, prefix.str() + "pixel");
if (sigmaLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "sigmaNought"), calibrationVector.vect, prefix.str() + "sigmaNought");
}
if (betaLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "betaNought"), calibrationVector.vect, prefix.str() + "betaNought");
}
if (gammaLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "gamma"), calibrationVector.vect, prefix.str() + "gamma");
}
if (dnLut) {
Utils::ConvertStringToVector(imageKeywordlist.GetMetadataByKey(prefix.str() + "dn"), calibrationVector.vect, prefix.str() + "dn");
}
calibrationVectorList[i] = calibrationVector;
}
Sentinel1CalibrationLookupData::Pointer sarLut;
sarLut = Sentinel1CalibrationLookupData::New();
sarLut->InitParameters(type, firstLineTime, lastLineTime, numOfLines, count, calibrationVectorList);
this->SetCalibrationLookupData(sarLut);
}
void
Sentinel1ImageMetadataInterface
::ParseDateTime(const char* key, std::vector<int>& dateFields) const
{
if(dateFields.size() < 1 )
{
//parse from keyword list
if (!this->CanRead())
{
itkExceptionMacro(<< "Invalid Metadata, not a valid product");
}
const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist();
if (!imageKeywordlist.HasKey(key))
{
itkExceptionMacro( << "no key named " << key );
}
const std::string date_time_str = imageKeywordlist.GetMetadataByKey(key);
Utils::ConvertStringToVector(date_time_str, dateFields, key, "T:-.");
}
}
int
Sentinel1ImageMetadataInterface::GetYear() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 0 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[0], "support_data.image_date:year(int)" );
}
else
{
itkExceptionMacro( << "Invalid year" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetMonth() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 1 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[1], "support_data.image_date:month(int)" );
}
else
{
itkExceptionMacro( << "Invalid month" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetDay() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 2 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[2], "support_data.image_date:day(int)");
}
else
{
itkExceptionMacro( << "Invalid day" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetHour() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 3 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[3], "support_data.image_date:hour(int)");
}
else
{
itkExceptionMacro( << "Invalid hour" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetMinute() const
{
int value = 0;
ParseDateTime("support_data.image_date", m_AcquisitionDateFields);
if(m_AcquisitionDateFields.size() > 4 )
{
value = Utils::LexicalCast<int>( m_AcquisitionDateFields[4], "support_data.image_date:minute(int)");
}
else
{
itkExceptionMacro( << "Invalid minute" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetProductionYear() const
{
int value = 0;
ParseDateTime("support_data.date", m_ProductionDateFields);
if(m_ProductionDateFields.size() > 0 )
{
value = Utils::LexicalCast<int>( m_ProductionDateFields[0], "support_data.date:year(int)" );
}
else
{
itkExceptionMacro( << "Invalid production year" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetProductionMonth() const
{
int value = 0;
ParseDateTime("support_data.date", m_ProductionDateFields);
if(m_ProductionDateFields.size() > 1 )
{
value = Utils::LexicalCast<int>( m_ProductionDateFields[1], "support_data.date:month(int)" );
}
else
{
itkExceptionMacro( << "Invalid production month" );
}
return value;
}
int
Sentinel1ImageMetadataInterface::GetProductionDay() const
{
int value = 0;
ParseDateTime("support_data.date", m_ProductionDateFields);
if(m_ProductionDateFields.size() > 2 )
{
value = Utils::LexicalCast<int>( m_ProductionDateFields[2], "support_data.date:day(int)" );
}
else
{
itkExceptionMacro( << "Invalid production day" );
}
return value;
}
double
Sentinel1ImageMetadataInterface::GetPRF() const
{
double value = 0;
const ImageKeywordlistType imageKeywordlist = this->GetImageKeywordlist();
if (!imageKeywordlist.HasKey("support_data.pulse_repetition_frequency"))
{
return value;
}
value = Utils::LexicalCast<double>( imageKeywordlist.GetMetadataByKey("support_data.pulse_repetition_frequency"),
"support_data.pulse_repetition_frequency(double)" );
return value;
}
Sentinel1ImageMetadataInterface::UIntVectorType
Sentinel1ImageMetadataInterface::GetDefaultDisplay() const
{
UIntVectorType rgb(3);
rgb[0] = 0;
rgb[1] = 0;
rgb[2] = 0;
return rgb;
}
double
Sentinel1ImageMetadataInterface::GetRSF() const
{
return 0;
}
double
Sentinel1ImageMetadataInterface::GetRadarFrequency() const
{
return 0;
}
double
Sentinel1ImageMetadataInterface::GetCenterIncidenceAngle() const
{
return 0;
}
} // end namespace otb
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: XMLSectionFootnoteConfigImport.cxx,v $
*
* $Revision: 1.9 $
*
* last change: $Author: hr $ $Date: 2007-06-27 16:05:03 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmloff.hxx"
#ifndef _XMLOFF_XMLSECTIONFOOTNOTECONFIGIMPORT_HXX
#include "XMLSectionFootnoteConfigImport.hxx"
#endif
#ifndef _RTL_USTRING
#include <rtl/ustring.hxx>
#endif
#ifndef _COM_SUN_STAR_UNO_REFERENCE_H_
#include <com/sun/star/uno/Reference.h>
#endif
#ifndef _COM_SUN_STAR_XML_SAX_XATTRIBUTELIST_HPP_
#include <com/sun/star/xml/sax/XAttributeList.hpp>
#endif
#ifndef _COM_SUN_STAR_STYLE_NUMBERINGTYPE_HPP_
#include <com/sun/star/style/NumberingType.hpp>
#endif
#ifndef _XMLOFF_XMLIMP_HXX
#include <xmloff/xmlimp.hxx>
#endif
#ifndef _XMLOFF_XMLTOKEN_HXX
#include <xmloff/xmltoken.hxx>
#endif
#ifndef _XMLOFF_XMLUCONV_HXX
#include <xmloff/xmluconv.hxx>
#endif
#ifndef _XMLOFF_PROPERTYSETMAPPER_HXX
#include <xmloff/xmlprmap.hxx>
#endif
#ifndef _XMLOFF_XMLNMSPE_HXX
#include "xmlnmspe.hxx"
#endif
#ifndef _XMLOFF_NMSPMAP_HXX
#include <xmloff/nmspmap.hxx>
#endif
#ifndef _XMLOFF_PROPMAPPINGTYPES_HXX
#include <xmloff/maptype.hxx>
#endif
#ifndef _XMLOFF_XMLNUMI_HXX
#include <xmloff/xmlnumi.hxx>
#endif
#ifndef _XMLOFF_TEXTPRMAP_HXX_
#include <xmloff/txtprmap.hxx>
#endif
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#include <vector>
using namespace ::xmloff::token;
using namespace ::com::sun::star::style;
using ::rtl::OUString;
using ::std::vector;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::xml::sax::XAttributeList;
TYPEINIT1(XMLSectionFootnoteConfigImport, SvXMLImportContext);
XMLSectionFootnoteConfigImport::XMLSectionFootnoteConfigImport(
SvXMLImport& rImport,
sal_uInt16 nPrefix,
const OUString& rLocalName,
vector<XMLPropertyState> & rProps,
const UniReference<XMLPropertySetMapper> & rMapperRef) :
SvXMLImportContext(rImport, nPrefix, rLocalName),
rProperties(rProps),
rMapper(rMapperRef)
{
}
XMLSectionFootnoteConfigImport::~XMLSectionFootnoteConfigImport()
{
}
void XMLSectionFootnoteConfigImport::StartElement(
const Reference<XAttributeList> & xAttrList)
{
sal_Bool bEnd = sal_True; // we're inside the element, so this is true
sal_Bool bNumOwn = sal_False;
sal_Bool bNumRestart = sal_False;
sal_Bool bEndnote = sal_False;
sal_Int16 nNumRestartAt = 0;
OUString sNumPrefix;
OUString sNumSuffix;
OUString sNumFormat;
OUString sNumLetterSync;
// iterate over xattribute list and fill values
sal_Int16 nLength = xAttrList->getLength();
for(sal_Int16 nAttr = 0; nAttr < nLength; nAttr++)
{
OUString sLocalName;
sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
GetKeyByAttrName( xAttrList->getNameByIndex(nAttr),
&sLocalName );
OUString sAttrValue = xAttrList->getValueByIndex(nAttr);
if (XML_NAMESPACE_TEXT == nPrefix)
{
if (IsXMLToken(sLocalName, XML_START_VALUE))
{
sal_Int32 nTmp;
if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue))
{
nNumRestartAt = static_cast< sal_Int16 >( nTmp ) - 1;
bNumRestart = sal_True;
}
}
else if( IsXMLToken( sLocalName, XML_NOTE_CLASS ) )
{
if( IsXMLToken( sAttrValue, XML_ENDNOTE ) )
bEndnote = sal_True;
}
}
else if (XML_NAMESPACE_STYLE == nPrefix)
{
if (IsXMLToken(sLocalName, XML_NUM_PREFIX))
{
sNumPrefix = sAttrValue;
bNumOwn = sal_True;
}
else if (IsXMLToken(sLocalName, XML_NUM_SUFFIX))
{
sNumSuffix = sAttrValue;
bNumOwn = sal_True;
}
else if (IsXMLToken(sLocalName, XML_NUM_FORMAT))
{
sNumFormat = sAttrValue;
bNumOwn = sal_True;
}
else if (IsXMLToken(sLocalName, XML_NUM_LETTER_SYNC))
{
sNumLetterSync = sAttrValue;
bNumOwn = sal_True;
}
}
}
// OK, now we have all values and can fill the XMLPropertyState vector
Any aAny;
aAny.setValue( &bNumOwn, ::getBooleanCppuType() );
sal_Int32 nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_OWN : CTF_SECTION_FOOTNOTE_NUM_OWN );
XMLPropertyState aNumOwn( nIndex, aAny );
rProperties.push_back( aNumOwn );
aAny.setValue( &bNumRestart, ::getBooleanCppuType() );
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_RESTART : CTF_SECTION_FOOTNOTE_NUM_RESTART );
XMLPropertyState aNumRestart( nIndex, aAny );
rProperties.push_back( aNumRestart );
aAny <<= nNumRestartAt;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_RESTART_AT :
CTF_SECTION_FOOTNOTE_NUM_RESTART_AT );
XMLPropertyState aNumRestartAtState( nIndex, aAny );
rProperties.push_back( aNumRestartAtState );
sal_Int16 nNumType = NumberingType::ARABIC;
GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
sNumFormat,
sNumLetterSync );
aAny <<= nNumType;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_TYPE : CTF_SECTION_FOOTNOTE_NUM_TYPE );
XMLPropertyState aNumFormatState( nIndex, aAny );
rProperties.push_back( aNumFormatState );
aAny <<= sNumPrefix;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_PREFIX : CTF_SECTION_FOOTNOTE_NUM_PREFIX );
XMLPropertyState aPrefixState( nIndex, aAny );
rProperties.push_back( aPrefixState );
aAny <<= sNumSuffix;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_SUFFIX : CTF_SECTION_FOOTNOTE_NUM_SUFFIX );
XMLPropertyState aSuffixState( nIndex, aAny );
rProperties.push_back( aSuffixState );
aAny.setValue( &bEnd, ::getBooleanCppuType() );
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_END : CTF_SECTION_FOOTNOTE_END );
XMLPropertyState aEndState( nIndex, aAny );
rProperties.push_back( aEndState );
}
<commit_msg>INTEGRATION: CWS changefileheader (1.9.162); FILE MERGED 2008/04/01 16:10:10 thb 1.9.162.3: #i85898# Stripping all external header guards 2008/04/01 13:05:28 thb 1.9.162.2: #i85898# Stripping all external header guards 2008/03/31 16:28:35 rt 1.9.162.1: #i87441# Change license header to LPGL v3.<commit_after>/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: XMLSectionFootnoteConfigImport.cxx,v $
* $Revision: 1.10 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmloff.hxx"
#include "XMLSectionFootnoteConfigImport.hxx"
#ifndef _RTL_USTRING
#include <rtl/ustring.hxx>
#endif
#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/xml/sax/XAttributeList.hpp>
#include <com/sun/star/style/NumberingType.hpp>
#include <xmloff/xmlimp.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/xmlprmap.hxx>
#include "xmlnmspe.hxx"
#include <xmloff/nmspmap.hxx>
#include <xmloff/maptype.hxx>
#include <xmloff/xmlnumi.hxx>
#include <xmloff/txtprmap.hxx>
#include <tools/debug.hxx>
#include <vector>
using namespace ::xmloff::token;
using namespace ::com::sun::star::style;
using ::rtl::OUString;
using ::std::vector;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::xml::sax::XAttributeList;
TYPEINIT1(XMLSectionFootnoteConfigImport, SvXMLImportContext);
XMLSectionFootnoteConfigImport::XMLSectionFootnoteConfigImport(
SvXMLImport& rImport,
sal_uInt16 nPrefix,
const OUString& rLocalName,
vector<XMLPropertyState> & rProps,
const UniReference<XMLPropertySetMapper> & rMapperRef) :
SvXMLImportContext(rImport, nPrefix, rLocalName),
rProperties(rProps),
rMapper(rMapperRef)
{
}
XMLSectionFootnoteConfigImport::~XMLSectionFootnoteConfigImport()
{
}
void XMLSectionFootnoteConfigImport::StartElement(
const Reference<XAttributeList> & xAttrList)
{
sal_Bool bEnd = sal_True; // we're inside the element, so this is true
sal_Bool bNumOwn = sal_False;
sal_Bool bNumRestart = sal_False;
sal_Bool bEndnote = sal_False;
sal_Int16 nNumRestartAt = 0;
OUString sNumPrefix;
OUString sNumSuffix;
OUString sNumFormat;
OUString sNumLetterSync;
// iterate over xattribute list and fill values
sal_Int16 nLength = xAttrList->getLength();
for(sal_Int16 nAttr = 0; nAttr < nLength; nAttr++)
{
OUString sLocalName;
sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
GetKeyByAttrName( xAttrList->getNameByIndex(nAttr),
&sLocalName );
OUString sAttrValue = xAttrList->getValueByIndex(nAttr);
if (XML_NAMESPACE_TEXT == nPrefix)
{
if (IsXMLToken(sLocalName, XML_START_VALUE))
{
sal_Int32 nTmp;
if (SvXMLUnitConverter::convertNumber(nTmp, sAttrValue))
{
nNumRestartAt = static_cast< sal_Int16 >( nTmp ) - 1;
bNumRestart = sal_True;
}
}
else if( IsXMLToken( sLocalName, XML_NOTE_CLASS ) )
{
if( IsXMLToken( sAttrValue, XML_ENDNOTE ) )
bEndnote = sal_True;
}
}
else if (XML_NAMESPACE_STYLE == nPrefix)
{
if (IsXMLToken(sLocalName, XML_NUM_PREFIX))
{
sNumPrefix = sAttrValue;
bNumOwn = sal_True;
}
else if (IsXMLToken(sLocalName, XML_NUM_SUFFIX))
{
sNumSuffix = sAttrValue;
bNumOwn = sal_True;
}
else if (IsXMLToken(sLocalName, XML_NUM_FORMAT))
{
sNumFormat = sAttrValue;
bNumOwn = sal_True;
}
else if (IsXMLToken(sLocalName, XML_NUM_LETTER_SYNC))
{
sNumLetterSync = sAttrValue;
bNumOwn = sal_True;
}
}
}
// OK, now we have all values and can fill the XMLPropertyState vector
Any aAny;
aAny.setValue( &bNumOwn, ::getBooleanCppuType() );
sal_Int32 nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_OWN : CTF_SECTION_FOOTNOTE_NUM_OWN );
XMLPropertyState aNumOwn( nIndex, aAny );
rProperties.push_back( aNumOwn );
aAny.setValue( &bNumRestart, ::getBooleanCppuType() );
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_RESTART : CTF_SECTION_FOOTNOTE_NUM_RESTART );
XMLPropertyState aNumRestart( nIndex, aAny );
rProperties.push_back( aNumRestart );
aAny <<= nNumRestartAt;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_RESTART_AT :
CTF_SECTION_FOOTNOTE_NUM_RESTART_AT );
XMLPropertyState aNumRestartAtState( nIndex, aAny );
rProperties.push_back( aNumRestartAtState );
sal_Int16 nNumType = NumberingType::ARABIC;
GetImport().GetMM100UnitConverter().convertNumFormat( nNumType,
sNumFormat,
sNumLetterSync );
aAny <<= nNumType;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_TYPE : CTF_SECTION_FOOTNOTE_NUM_TYPE );
XMLPropertyState aNumFormatState( nIndex, aAny );
rProperties.push_back( aNumFormatState );
aAny <<= sNumPrefix;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_PREFIX : CTF_SECTION_FOOTNOTE_NUM_PREFIX );
XMLPropertyState aPrefixState( nIndex, aAny );
rProperties.push_back( aPrefixState );
aAny <<= sNumSuffix;
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_NUM_SUFFIX : CTF_SECTION_FOOTNOTE_NUM_SUFFIX );
XMLPropertyState aSuffixState( nIndex, aAny );
rProperties.push_back( aSuffixState );
aAny.setValue( &bEnd, ::getBooleanCppuType() );
nIndex = rMapper->FindEntryIndex( bEndnote ?
CTF_SECTION_ENDNOTE_END : CTF_SECTION_FOOTNOTE_END );
XMLPropertyState aEndState( nIndex, aAny );
rProperties.push_back( aEndState );
}
<|endoftext|> |
<commit_before>/**
* \file TubeFilter.cpp
*/
#include "TubeFilter.h"
#include <cassert>
#include <ATK/Utility/SimplifiedVectorizedNewtonRaphson.h>
#include <ATK/Utility/VectorizedNewtonRaphson.h>
namespace ATK
{
template <typename DataType_>
class TubeFunction
{
protected:
const DataType_ mu;
const DataType_ K;
const DataType_ Kp;
const DataType_ Kvb;
const DataType_ Kg;
const DataType_ Ex;
DataType_ Lb(DataType_ Vbe, DataType_ Vce)
{
if(mu * Vbe + Vce > 0)
return K * std::pow(mu * Vbe + Vce, 1.5);
return 0;
}
DataType_ Lb_Vbe(DataType_ Vbe, DataType_ Vce)
{
if (mu * Vbe + Vce > 0)
return 0;
return 0;
}
DataType_ Lb_Vce(DataType_ Vbe, DataType_ Vce)
{
if (mu * Vbe + Vce > 0)
return 0;
return 0;
}
DataType_ Lc(DataType_ Vbe, DataType_ Vce)
{
if (Vce > 0)
{
DataType_ E1 = Vce / Kp * std::log(1 + std::exp(Kp * (1/mu + Vbe / std::sqrt(Kvb + Vce * Vce))));
return 2 / Kg * std::pow(E1, Ex);
}
return 0;
}
DataType_ Lc_Vbe(DataType_ Vbe, DataType_ Vce)
{
if (Vce > 0)
return 0;
return 0;
}
DataType_ Lc_Vce(DataType_ Vbe, DataType_ Vce)
{
if (Vce > 0)
return 0;
return 0;
}
TubeFunction(DataType_ mu, DataType_ K, DataType_ Kp, DataType_ Kvb, DataType_ Kg, DataType_ Ex)
:mu(mu), K(K), Kp(Kp), Kvb(Kvb), Kg(Kg), Ex(Ex)
{
}
};
template <typename DataType_>
class TubeFilter<DataType_>::CommonCathodeTriodeFunction : public TubeFunction<DataType_>
{
const DataType_ dt;
const DataType_ Rp;
const DataType_ Rg;
const DataType_ Ro;
const DataType_ Rk;
const DataType_ VBias;
const DataType_ Co;
const DataType_ Ck;
public:
typedef DataType_ DataType;
typedef Eigen::Matrix<DataType, 4, 1> Vector;
typedef Eigen::Matrix<DataType, 4, 4> Matrix;
CommonCathodeTriodeFunction(DataType dt, DataType Rp, DataType Rg, DataType Ro, DataType Rk, DataType VBias, DataType Co, DataType Ck, DataType_ mu, DataType_ K, DataType_ Kp, DataType_ Kvb, DataType_ Kg, DataType_ Ex)
:TubeFunction<DataType_>(mu, K, Kp, Kvb, Kg, Ex), dt(dt), Rp(Rp), Rg(Rg), Ro(Ro), Rk(Rk), VBias(VBias), Co(Co), Ck(Ck)
{
}
Vector estimate(int64_t i, const DataType* const * ATK_RESTRICT input, DataType* const * ATK_RESTRICT output)
{
Vector y0 = Vector::Zero();
for(int j = 0; j < 4; ++j)
{
y0.data()[j] = output[j][i-1];
}
return y0;
}
std::pair<Vector, Matrix> operator()(int64_t i, const DataType* const * ATK_RESTRICT input, DataType* const * ATK_RESTRICT output, const Vector& y1)
{
auto Ib_old = Lb(output[3][i-1] - output[0][i-1], output[2][i-1] - output[0][i-1]);
auto Ic_old = Lc(output[3][i-1] - output[0][i-1], output[2][i-1] - output[0][i-1]);
auto Ib = Lb(y1(3) - y1(0), y1(2) - y1(0));
auto Ic = Lc(y1(3) - y1(0), y1(2) - y1(0));
auto Ib_Vbe = Lb_Vbe(y1(3) - y1(0), y1(2) - y1(0));
auto Ib_Vce = Lb_Vce(y1(3) - y1(0), y1(2) - y1(0));
auto Ic_Vbe = Lc_Vbe(y1(3) - y1(0), y1(2) - y1(0));
auto Ic_Vce = Lc_Vce(y1(3) - y1(0), y1(2) - y1(0));
auto f1_old = - output[0][i-1] / (Rk * Ck) + (Ib_old + Ic_old) / Ck;
auto f2_old = - (output[1][i-1] + output[2][i-1]) / (Ro * Co);
auto f1 = - y1(0) / (Rk * Ck) + (Ib + Ic) / Ck;
auto f2 = - (y1(1) + y1(2)) / (Ro * Co);
auto g1 = y1(2) + Rp * (Ic + (y1(1) + y1(2)) / Ro) - VBias;
auto g2 = y1(3) - input[0][i] + Rg * Ib;
Vector F(Vector::Zero());
F << (dt / 2 * (f1 + f1_old) + output[0][i-1] - y1(0)),
(dt / 2 * (f2 + f2_old) + output[1][i-1] - y1(1)),
(g1),
(g2);
Matrix M(Matrix::Zero());
M << (-1 -dt/2/(Rk * Ck)) - dt/2*((Ib_Vbe + Ic_Vbe + Ib_Vce + Ic_Vce)/ Ck), 0, dt/2*(Ib_Vce + Ic_Vce) / Ck, dt/2*(Ib_Vbe + Ic_Vbe) / Ck,
0, -1 -dt/2*(Ro * Co), -dt/2*(Ro * Co), 0,
-Rp * (Ic_Vbe + Ic_Vce), Rp / Ro, 1 + Rp / Ro + Rp * Ic_Vce, Rp * Ic_Vbe,
-Rg * (Ib_Vbe + Ib_Vce), 0, Rg * Ib_Vce, Rg * Ib_Vbe + 1;
return std::make_pair(F, M);
}
};
template <typename DataType_>
class CommonCathodeTriodeInitialFunction : public TubeFunction<DataType_>
{
const DataType_ Rp;
const DataType_ Rg;
const DataType_ Ro;
const DataType_ Rk;
const DataType_ VBias;
public:
typedef DataType_ DataType;
typedef Eigen::Matrix<DataType, 3, 1> Vector;
typedef Eigen::Matrix<DataType, 3, 3> Matrix;
CommonCathodeTriodeInitialFunction(DataType Rp, DataType Rg, DataType Ro, DataType Rk, DataType VBias, DataType_ mu, DataType_ K, DataType_ Kp, DataType_ Kvb, DataType_ Kg, DataType_ Ex)
:TubeFunction<DataType_>(mu, K, Kp, Kvb, Kg, Ex), Rp(Rp), Rg(Rg), Ro(Ro), Rk(Rk), VBias(VBias)
{
}
std::pair<Vector, Matrix> operator()(const Vector& y1)
{
auto Ib = Lb(y1(0) - y1(1), y1(0) - y1(2));
auto Ic = Lc(y1(0) - y1(1), y1(0) - y1(2));
auto Ib_Vbe = Lb_Vbe(y1(0) - y1(1), y1(0) - y1(2));
auto Ib_Vce = Lb_Vce(y1(0) - y1(1), y1(0) - y1(2));
auto Ic_Vbe = Lc_Vbe(y1(0) - y1(1), y1(0) - y1(2));
auto Ic_Vce = Lc_Vce(y1(0) - y1(1), y1(0) - y1(2));
Vector F(Vector::Zero());
F << y1(0) - VBias + Ic * Rp,
Ib * Rg + y1(1),
y1(2) - (Ib + Ic) * Rk;
Matrix M(Matrix::Zero());
M << 1 + Rp * (Ic_Vbe + Ic_Vce), -Rp * Ic_Vbe, -Rp * Ic_Vce,
(Ib_Vbe + Ib_Vce) * Rg, 1 - Rg * Ib_Vbe, -Rg * Ib_Vce,
-(Ic_Vbe + Ic_Vce + Ib_Vbe + Ib_Vce) * Rk, (Ic_Vbe + Ib_Vbe) * Rk, 1 + (Ic_Vce + Ib_Vce) * Rk;
return std::make_pair(F, M);
}
};
template <typename DataType>
TubeFilter<DataType>::TubeFilter(DataType Rp, DataType Rg, DataType Ro, DataType Rk, DataType VBias, DataType Co, DataType Ck, DataType mu, DataType K, DataType Kp, DataType Kvb, DataType Kg, DataType Ex)
:Parent(1, 5), Rp(Rp), Rg(Rg), Ro(Ro), Rk(Rk), VBias(VBias), Co(Co), Ck(Ck), mu(mu), K(K), Kp(Kp), Kvb(Kvb), Kg(Kg), Ex(Ex)
{
input_delay = output_delay = 1;
}
template <typename DataType>
TubeFilter<DataType>::TubeFilter(TubeFilter&& other)
:Parent(std::move(other)), Rp(other.Rp), Rg(other.Rg), Ro(other.Ro), Rk(other.Rk), VBias(other.VBias), Co(other.Co), Ck(other.Ck), mu(other.mu), K(other.K), Kp(other.Kp), Kvb(other.Kvb), Kg(other.Kg), Ex(other.Ex)
{
}
template<typename DataType_>
void TubeFilter<DataType_>::setup()
{
Parent::setup();
optimizer.reset(new VectorizedNewtonRaphson<CommonCathodeTriodeFunction, 4, 10, true>(CommonCathodeTriodeFunction(static_cast<DataType>(1. / input_sampling_rate),
Rp, Rg, Ro, Rk, //R
VBias, // VBias
Co, Ck, // C
mu, K, Kp, Kvb, Kg, Ex // tube
)));
}
template<typename DataType_>
void TubeFilter<DataType_>::full_setup()
{
Parent::full_setup();
// setup default_output
SimplifiedVectorizedNewtonRaphson<CommonCathodeTriodeInitialFunction<DataType_>, 3, 10> custom(CommonCathodeTriodeInitialFunction<DataType_>(
Rp, Rg, Ro, Rk, //R
VBias, // VBias
mu, K, Kp, Kvb, Kg, Ex // tube
));
auto stable = custom.optimize();
default_output[0] = 0;
default_output[1] = stable(2);
default_output[2] = -stable(0);
default_output[3] = stable(0);
default_output[4] = stable(1);
}
template<typename DataType_>
void TubeFilter<DataType_>::process_impl(int64_t size) const
{
assert(input_sampling_rate == output_sampling_rate);
for(int64_t i = 0; i < size; ++i)
{
optimizer->optimize(i, converted_inputs.data(), outputs.data() + 1);
outputs[0][i] = outputs[2][i] + outputs[3][i];
}
}
template<typename DataType_>
TubeFilter<DataType_> TubeFilter<DataType_>::build_standard_filter()
{
return TubeFilter<DataType_>(100e3, 220e3, 22e3, 2.7e3, //R
400, // VBias
20e-9, 10e-6, // C
88.5, 1.73e-6, 600, 300, 1060, 1.4 // transistor
);
}
template class TubeFilter<float>;
template class TubeFilter<double>;
}
<commit_msg>First one should be easy enough!<commit_after>/**
* \file TubeFilter.cpp
*/
#include "TubeFilter.h"
#include <cassert>
#include <ATK/Utility/SimplifiedVectorizedNewtonRaphson.h>
#include <ATK/Utility/VectorizedNewtonRaphson.h>
namespace ATK
{
template <typename DataType_>
class TubeFunction
{
protected:
const DataType_ mu;
const DataType_ K;
const DataType_ Kp;
const DataType_ Kvb;
const DataType_ Kg;
const DataType_ Ex;
DataType_ Lb(DataType_ Vbe, DataType_ Vce)
{
if(mu * Vbe + Vce > 0)
return K * std::pow(mu * Vbe + Vce, 1.5);
return 0;
}
DataType_ Lb_Vbe(DataType_ Vbe, DataType_ Vce)
{
if (mu * Vbe + Vce > 0)
return K * mu * 1.5 * std::sqrt(mu * Vbe + Vce);
return 0;
}
DataType_ Lb_Vce(DataType_ Vbe, DataType_ Vce)
{
if (mu * Vbe + Vce > 0)
return K * 1.5 * std::sqrt(mu * Vbe + Vce);;
return 0;
}
DataType_ Lc(DataType_ Vbe, DataType_ Vce)
{
if (Vce > 0)
{
DataType_ E1 = Vce / Kp * std::log(1 + std::exp(Kp * (1/mu + Vbe / std::sqrt(Kvb + Vce * Vce))));
return 2 / Kg * std::pow(E1, Ex);
}
return 0;
}
DataType_ Lc_Vbe(DataType_ Vbe, DataType_ Vce)
{
if (Vce > 0)
return 0;
return 0;
}
DataType_ Lc_Vce(DataType_ Vbe, DataType_ Vce)
{
if (Vce > 0)
return 0;
return 0;
}
TubeFunction(DataType_ mu, DataType_ K, DataType_ Kp, DataType_ Kvb, DataType_ Kg, DataType_ Ex)
:mu(mu), K(K), Kp(Kp), Kvb(Kvb), Kg(Kg), Ex(Ex)
{
}
};
template <typename DataType_>
class TubeFilter<DataType_>::CommonCathodeTriodeFunction : public TubeFunction<DataType_>
{
const DataType_ dt;
const DataType_ Rp;
const DataType_ Rg;
const DataType_ Ro;
const DataType_ Rk;
const DataType_ VBias;
const DataType_ Co;
const DataType_ Ck;
public:
typedef DataType_ DataType;
typedef Eigen::Matrix<DataType, 4, 1> Vector;
typedef Eigen::Matrix<DataType, 4, 4> Matrix;
CommonCathodeTriodeFunction(DataType dt, DataType Rp, DataType Rg, DataType Ro, DataType Rk, DataType VBias, DataType Co, DataType Ck, DataType_ mu, DataType_ K, DataType_ Kp, DataType_ Kvb, DataType_ Kg, DataType_ Ex)
:TubeFunction<DataType_>(mu, K, Kp, Kvb, Kg, Ex), dt(dt), Rp(Rp), Rg(Rg), Ro(Ro), Rk(Rk), VBias(VBias), Co(Co), Ck(Ck)
{
}
Vector estimate(int64_t i, const DataType* const * ATK_RESTRICT input, DataType* const * ATK_RESTRICT output)
{
Vector y0 = Vector::Zero();
for(int j = 0; j < 4; ++j)
{
y0.data()[j] = output[j][i-1];
}
return y0;
}
std::pair<Vector, Matrix> operator()(int64_t i, const DataType* const * ATK_RESTRICT input, DataType* const * ATK_RESTRICT output, const Vector& y1)
{
auto Ib_old = Lb(output[3][i-1] - output[0][i-1], output[2][i-1] - output[0][i-1]);
auto Ic_old = Lc(output[3][i-1] - output[0][i-1], output[2][i-1] - output[0][i-1]);
auto Ib = Lb(y1(3) - y1(0), y1(2) - y1(0));
auto Ic = Lc(y1(3) - y1(0), y1(2) - y1(0));
auto Ib_Vbe = Lb_Vbe(y1(3) - y1(0), y1(2) - y1(0));
auto Ib_Vce = Lb_Vce(y1(3) - y1(0), y1(2) - y1(0));
auto Ic_Vbe = Lc_Vbe(y1(3) - y1(0), y1(2) - y1(0));
auto Ic_Vce = Lc_Vce(y1(3) - y1(0), y1(2) - y1(0));
auto f1_old = - output[0][i-1] / (Rk * Ck) + (Ib_old + Ic_old) / Ck;
auto f2_old = - (output[1][i-1] + output[2][i-1]) / (Ro * Co);
auto f1 = - y1(0) / (Rk * Ck) + (Ib + Ic) / Ck;
auto f2 = - (y1(1) + y1(2)) / (Ro * Co);
auto g1 = y1(2) + Rp * (Ic + (y1(1) + y1(2)) / Ro) - VBias;
auto g2 = y1(3) - input[0][i] + Rg * Ib;
Vector F(Vector::Zero());
F << (dt / 2 * (f1 + f1_old) + output[0][i-1] - y1(0)),
(dt / 2 * (f2 + f2_old) + output[1][i-1] - y1(1)),
(g1),
(g2);
Matrix M(Matrix::Zero());
M << (-1 -dt/2/(Rk * Ck)) - dt/2*((Ib_Vbe + Ic_Vbe + Ib_Vce + Ic_Vce)/ Ck), 0, dt/2*(Ib_Vce + Ic_Vce) / Ck, dt/2*(Ib_Vbe + Ic_Vbe) / Ck,
0, -1 -dt/2*(Ro * Co), -dt/2*(Ro * Co), 0,
-Rp * (Ic_Vbe + Ic_Vce), Rp / Ro, 1 + Rp / Ro + Rp * Ic_Vce, Rp * Ic_Vbe,
-Rg * (Ib_Vbe + Ib_Vce), 0, Rg * Ib_Vce, Rg * Ib_Vbe + 1;
return std::make_pair(F, M);
}
};
template <typename DataType_>
class CommonCathodeTriodeInitialFunction : public TubeFunction<DataType_>
{
const DataType_ Rp;
const DataType_ Rg;
const DataType_ Ro;
const DataType_ Rk;
const DataType_ VBias;
public:
typedef DataType_ DataType;
typedef Eigen::Matrix<DataType, 3, 1> Vector;
typedef Eigen::Matrix<DataType, 3, 3> Matrix;
CommonCathodeTriodeInitialFunction(DataType Rp, DataType Rg, DataType Ro, DataType Rk, DataType VBias, DataType_ mu, DataType_ K, DataType_ Kp, DataType_ Kvb, DataType_ Kg, DataType_ Ex)
:TubeFunction<DataType_>(mu, K, Kp, Kvb, Kg, Ex), Rp(Rp), Rg(Rg), Ro(Ro), Rk(Rk), VBias(VBias)
{
}
std::pair<Vector, Matrix> operator()(const Vector& y1)
{
auto Ib = Lb(y1(0) - y1(1), y1(0) - y1(2));
auto Ic = Lc(y1(0) - y1(1), y1(0) - y1(2));
auto Ib_Vbe = Lb_Vbe(y1(0) - y1(1), y1(0) - y1(2));
auto Ib_Vce = Lb_Vce(y1(0) - y1(1), y1(0) - y1(2));
auto Ic_Vbe = Lc_Vbe(y1(0) - y1(1), y1(0) - y1(2));
auto Ic_Vce = Lc_Vce(y1(0) - y1(1), y1(0) - y1(2));
Vector F(Vector::Zero());
F << y1(0) - VBias + Ic * Rp,
Ib * Rg + y1(1),
y1(2) - (Ib + Ic) * Rk;
Matrix M(Matrix::Zero());
M << 1 + Rp * (Ic_Vbe + Ic_Vce), -Rp * Ic_Vbe, -Rp * Ic_Vce,
(Ib_Vbe + Ib_Vce) * Rg, 1 - Rg * Ib_Vbe, -Rg * Ib_Vce,
-(Ic_Vbe + Ic_Vce + Ib_Vbe + Ib_Vce) * Rk, (Ic_Vbe + Ib_Vbe) * Rk, 1 + (Ic_Vce + Ib_Vce) * Rk;
return std::make_pair(F, M);
}
};
template <typename DataType>
TubeFilter<DataType>::TubeFilter(DataType Rp, DataType Rg, DataType Ro, DataType Rk, DataType VBias, DataType Co, DataType Ck, DataType mu, DataType K, DataType Kp, DataType Kvb, DataType Kg, DataType Ex)
:Parent(1, 5), Rp(Rp), Rg(Rg), Ro(Ro), Rk(Rk), VBias(VBias), Co(Co), Ck(Ck), mu(mu), K(K), Kp(Kp), Kvb(Kvb), Kg(Kg), Ex(Ex)
{
input_delay = output_delay = 1;
}
template <typename DataType>
TubeFilter<DataType>::TubeFilter(TubeFilter&& other)
:Parent(std::move(other)), Rp(other.Rp), Rg(other.Rg), Ro(other.Ro), Rk(other.Rk), VBias(other.VBias), Co(other.Co), Ck(other.Ck), mu(other.mu), K(other.K), Kp(other.Kp), Kvb(other.Kvb), Kg(other.Kg), Ex(other.Ex)
{
}
template<typename DataType_>
void TubeFilter<DataType_>::setup()
{
Parent::setup();
optimizer.reset(new VectorizedNewtonRaphson<CommonCathodeTriodeFunction, 4, 10, true>(CommonCathodeTriodeFunction(static_cast<DataType>(1. / input_sampling_rate),
Rp, Rg, Ro, Rk, //R
VBias, // VBias
Co, Ck, // C
mu, K, Kp, Kvb, Kg, Ex // tube
)));
}
template<typename DataType_>
void TubeFilter<DataType_>::full_setup()
{
Parent::full_setup();
// setup default_output
SimplifiedVectorizedNewtonRaphson<CommonCathodeTriodeInitialFunction<DataType_>, 3, 10> custom(CommonCathodeTriodeInitialFunction<DataType_>(
Rp, Rg, Ro, Rk, //R
VBias, // VBias
mu, K, Kp, Kvb, Kg, Ex // tube
));
auto stable = custom.optimize();
default_output[0] = 0;
default_output[1] = stable(2);
default_output[2] = -stable(0);
default_output[3] = stable(0);
default_output[4] = stable(1);
}
template<typename DataType_>
void TubeFilter<DataType_>::process_impl(int64_t size) const
{
assert(input_sampling_rate == output_sampling_rate);
for(int64_t i = 0; i < size; ++i)
{
optimizer->optimize(i, converted_inputs.data(), outputs.data() + 1);
outputs[0][i] = outputs[2][i] + outputs[3][i];
}
}
template<typename DataType_>
TubeFilter<DataType_> TubeFilter<DataType_>::build_standard_filter()
{
return TubeFilter<DataType_>(100e3, 220e3, 22e3, 2.7e3, //R
400, // VBias
20e-9, 10e-6, // C
88.5, 1.73e-6, 600, 300, 1060, 1.4 // transistor
);
}
template class TubeFilter<float>;
template class TubeFilter<double>;
}
<|endoftext|> |
<commit_before>#include <iostream>
#include <pcap.h>
#include <string>
#include <cstring>
#include <cstdlib>
#include <stack>
#include "util.h"
#include "packetheader.h"
#include "handlepacket.h"
using namespace std;
#define max_number_of_operands 7007
namespace {
u_int16_t number_of_operands;
int32_t operands[max_number_of_operands];
u_int8_t operators[max_number_of_operands-1]; // Defined by the MATH_OPERATOR_* constants
u_int8_t number_of_operators_after_operand[max_number_of_operands]; // The positions of the operators is as required for Reverse Polish Notation.
int32_t answer = 0;
const u_int16_t end_packet_magic_number = 21845;
};
int calcans () {
stack<int> S;
int operators_iterator = 0;
int nooao = 0;
for ( int i = 0; i < number_of_operands; i++ ) {
S.push(operands[i]);
nooao = number_of_operators_after_operand[i];
while ( nooao > 0 ) {
int b = S.top();
S.pop();
int a = S.top();
S.pop();
switch ( operators[operators_iterator] ) {
case MATH_OPERATOR_PLUS:
S.push(a+b);
break;
case MATH_OPERATOR_MINUS:
S.push(a-b);
break;
case MATH_OPERATOR_MULTIPLY:
S.push(a*b);
break;
case MATH_OPERATOR_DIVIDE:
S.push(a/b);
break;
case MATH_OPERATOR_MODULO:
S.push(a%b);
break;
case MATH_OPERATOR_BITWISE_AND:
S.push(a&b);
break;
case MATH_OPERATOR_BITWISE_OR:
S.push(a|b);
break;
case MATH_OPERATOR_BITWISE_XOR:
S.push(a^b);
break;
}
operators_iterator++;
nooao--;
}
}
return S.top();
}
void fill_array_from_packet( u_int8_t buffer[] ) {
int lengthread = 0;
memcpy(operands,buffer,number_of_operands*4);
lengthread += number_of_operands*4;
memcpy(operators,buffer+lengthread,number_of_operands-1);
lengthread += (number_of_operands-1);
memcpy(number_of_operators_after_operand,buffer+lengthread,number_of_operands);
lengthread += number_of_operands;
memcpy(&answer,buffer+lengthread,4);
}
void server (pcap_t *handle) {
MathPacketHeader header;
//get packet
//send ack
answer = calcans();
//send ans
//wait for ack
}<commit_msg>add function to do various server side functions<commit_after>#include <iostream>
#include <pcap.h>
#include <string>
#include <cstring>
#include <cstdlib>
#include <stack>
#include "util.h"
#include "packetheader.h"
#include "handlepacket.h"
using namespace std;
#define max_number_of_operands 7007
namespace {
u_int16_t number_of_operands;
int32_t operands[max_number_of_operands];
u_int8_t operators[max_number_of_operands-1]; // Defined by the MATH_OPERATOR_* constants
u_int8_t number_of_operators_after_operand[max_number_of_operands]; // The positions of the operators is as required for Reverse Polish Notation.
int32_t answer = 0;
const u_int16_t end_packet_magic_number = 21845;
u_int32_t user_id_of_requester;
u_int32_t user_id_of_sender;
u_int32_t request_id;
};
int calcans () {
stack<int> S;
int operators_iterator = 0;
int nooao = 0;
for ( int i = 0; i < number_of_operands; i++ ) {
S.push(operands[i]);
nooao = number_of_operators_after_operand[i];
while ( nooao > 0 ) {
int b = S.top();
S.pop();
int a = S.top();
S.pop();
switch ( operators[operators_iterator] ) {
case MATH_OPERATOR_PLUS:
S.push(a+b);
break;
case MATH_OPERATOR_MINUS:
S.push(a-b);
break;
case MATH_OPERATOR_MULTIPLY:
S.push(a*b);
break;
case MATH_OPERATOR_DIVIDE:
S.push(a/b);
break;
case MATH_OPERATOR_MODULO:
S.push(a%b);
break;
case MATH_OPERATOR_BITWISE_AND:
S.push(a&b);
break;
case MATH_OPERATOR_BITWISE_OR:
S.push(a|b);
break;
case MATH_OPERATOR_BITWISE_XOR:
S.push(a^b);
break;
}
operators_iterator++;
nooao--;
}
}
return S.top();
}
void fill_array_from_packet( u_int8_t buffer[] ) {
int lengthread = 0;
memcpy(operands,buffer,number_of_operands*4);
lengthread += number_of_operands*4;
memcpy(operators,buffer+lengthread,number_of_operands-1);
lengthread += (number_of_operands-1);
memcpy(number_of_operators_after_operand,buffer+lengthread,number_of_operands);
lengthread += number_of_operands;
memcpy(&answer,buffer+lengthread,4);
}
namespace {
void send_packet ( pcap_t *handle, MathPacketHeader header ) {
u_int8_t buffer[900];
if ( header.type_of_packet == MATH_TYPE_SEND_ANSWER ) {
int packet_size = 0;
memcpy(buffer,operands,number_of_operands*4);
packet_size += number_of_operands*4;
memcpy(buffer+packet_size,operators,number_of_operands-1);
packet_size += (number_of_operands-1);
memcpy(buffer+packet_size,number_of_operators_after_operand,number_of_operands);
packet_size += number_of_operands;
memcpy(buffer+packet_size,&answer,4);
packet_size += 4;
memcpy(buffer+packet_size,&end_packet_magic_number,2);
packet_size += 2;
send_packet_with_data(handle,header,buffer,packet_size);
} else if ( header.type_of_packet == MATH_TYPE_ACK_REQUEST ) {
send_ack_packet(handle,header);
}
}
bool get_ack (pcap_t *handle) {
MathPacketHeader temphead;
return ( get_ack_packet(handle,&temphead) &&
temphead.type_of_packet == MATH_TYPE_ACK_ANSWER &&
is_request_id_same(temphead,request_id) );
}
bool get_req_packet (pcap_t *handle, MathPacketHeader *header, u_int8_t pktbuf[]) {
return ( get_packet(handle,header,pktbuf) &&
header->type_of_packet == MATH_TYPE_REQUEST);
}
};
void server (pcap_t *handle) {
MathPacketHeader header;
u_int8_t buffer[1000];
user_id_of_sender = get_user_id_of_sender();
user_id_of_requester = 0;
request_id = 0;
//get packet
while ( !get_req_packet(handle,&header,buffer) );
display_message_related_to_packet("Answer requested by a client.");
header.user_id_of_sender = user_id_of_sender;
user_id_of_requester = header.user_id_of_requester;
request_id = header.request_id;
number_of_operands = header.number_of_operands;
fill_array_from_packet(buffer);
display_message_related_to_packet("Sending request arrived acknowledgement.");
for ( int i = 0; i < 1000; i++ ) {
header.type_of_packet = MATH_TYPE_ACK_REQUEST;
send_packet(handle,header);
}
display_message_related_to_packet("Calulating answer.");
answer = calcans();
display_message_related_to_packet("Sending answer to the client.");
header.type_of_packet = MATH_TYPE_SEND_ANSWER;
send_packet(handle,header);
int c = 0;
while ( !get_ack(handle) ) {
header.type_of_packet = MATH_TYPE_SEND_ANSWER;
c = (c+1)%100;
if ( c == 0 )
send_packet(handle,header);
}
ack_message("Answer received by client.");
}
<|endoftext|> |
<commit_before>//
// Created by sancar koyunlu on 6/17/13.
// Copyright (c) 2013 hazelcast. All rights reserved.
#include "hazelcast/client/spi/LifecycleService.h"
#include "hazelcast/client/spi/PartitionService.h"
#include "hazelcast/client/spi/ClientContext.h"
#include "hazelcast/client/spi/InvocationService.h"
#include "hazelcast/client/spi/ClusterService.h"
#include "hazelcast/client/ClientConfig.h"
#include "hazelcast/client/connection/ConnectionManager.h"
#include "hazelcast/client/LifecycleListener.h"
namespace hazelcast {
namespace client {
namespace spi {
LifecycleService::LifecycleService(ClientContext &clientContext, const ClientConfig &clientConfig)
:clientContext(clientContext)
, active(false) {
std::set<LifecycleListener *> const &lifecycleListeners = clientConfig.getLifecycleListeners();
listeners.insert(lifecycleListeners.begin(), lifecycleListeners.end());
fireLifecycleEvent(LifecycleEvent::STARTING);
};
bool LifecycleService::start() {
active = true;
fireLifecycleEvent(LifecycleEvent::STARTED);
if (!clientContext.getConnectionManager().start()) {
return false;
}
if (!clientContext.getClusterService().start()) {
return false;
}
clientContext.getInvocationService().start();
if (!clientContext.getPartitionService().start()) {
return false;
}
return true;
}
void LifecycleService::shutdown() {
util::LockGuard lg(lifecycleLock);
if (!active)
return;
active = false;
fireLifecycleEvent(LifecycleEvent::SHUTTING_DOWN);
clientContext.getConnectionManager().stop();
clientContext.getClusterService().stop();
clientContext.getPartitionService().stop();
fireLifecycleEvent(LifecycleEvent::SHUTDOWN);
};
void LifecycleService::addLifecycleListener(LifecycleListener *lifecycleListener) {
util::LockGuard lg(listenerLock);
listeners.insert(lifecycleListener);
};
bool LifecycleService::removeLifecycleListener(LifecycleListener *lifecycleListener) {
util::LockGuard lg(listenerLock);
return listeners.erase(lifecycleListener) == 1;
};
void LifecycleService::fireLifecycleEvent(const LifecycleEvent &lifecycleEvent) {
util::LockGuard lg(listenerLock);
util::ILogger &logger = util::ILogger::getLogger();
switch (lifecycleEvent.getState()) {
case LifecycleEvent::STARTING :
logger.info("LifecycleService::LifecycleEvent STARTING");
break;
case LifecycleEvent::STARTED :
logger.info("LifecycleService::LifecycleEvent STARTED");
break;
case LifecycleEvent::SHUTTING_DOWN :
logger.info("LifecycleService::LifecycleEvent SHUTTING_DOWN");
break;
case LifecycleEvent::SHUTDOWN :
logger.info("LifecycleService::LifecycleEvent SHUTDOWN");
break;
case LifecycleEvent::CLIENT_CONNECTED :
logger.info("LifecycleService::LifecycleEvent CLIENT_CONNECTED");
break;
case LifecycleEvent::CLIENT_DISCONNECTED :
logger.info("LifecycleService::LifecycleEvent CLIENT_DISCONNECTED");
break;
}
for (std::set<LifecycleListener *>::iterator it = listeners.begin(); it != listeners.end(); ++it) {
(*it)->stateChanged(lifecycleEvent);
}
};
bool LifecycleService::isRunning() {
return active;
};
}
}
}
<commit_msg>small improvement in logs<commit_after>//
// Created by sancar koyunlu on 6/17/13.
// Copyright (c) 2013 hazelcast. All rights reserved.
#include "hazelcast/client/spi/LifecycleService.h"
#include "hazelcast/client/spi/PartitionService.h"
#include "hazelcast/client/spi/ClientContext.h"
#include "hazelcast/client/spi/InvocationService.h"
#include "hazelcast/client/spi/ClusterService.h"
#include "hazelcast/client/ClientConfig.h"
#include "hazelcast/client/connection/ConnectionManager.h"
#include "hazelcast/client/LifecycleListener.h"
namespace hazelcast {
namespace client {
namespace spi {
LifecycleService::LifecycleService(ClientContext &clientContext, const ClientConfig &clientConfig)
:clientContext(clientContext)
, active(false) {
std::set<LifecycleListener *> const &lifecycleListeners = clientConfig.getLifecycleListeners();
listeners.insert(lifecycleListeners.begin(), lifecycleListeners.end());
};
bool LifecycleService::start() {
fireLifecycleEvent(LifecycleEvent::STARTING);
active = true;
if (!clientContext.getConnectionManager().start()) {
return false;
}
if (!clientContext.getClusterService().start()) {
return false;
}
clientContext.getInvocationService().start();
if (!clientContext.getPartitionService().start()) {
return false;
}
fireLifecycleEvent(LifecycleEvent::STARTED);
return true;
}
void LifecycleService::shutdown() {
util::LockGuard lg(lifecycleLock);
if (!active)
return;
active = false;
fireLifecycleEvent(LifecycleEvent::SHUTTING_DOWN);
clientContext.getConnectionManager().stop();
clientContext.getClusterService().stop();
clientContext.getPartitionService().stop();
fireLifecycleEvent(LifecycleEvent::SHUTDOWN);
};
void LifecycleService::addLifecycleListener(LifecycleListener *lifecycleListener) {
util::LockGuard lg(listenerLock);
listeners.insert(lifecycleListener);
};
bool LifecycleService::removeLifecycleListener(LifecycleListener *lifecycleListener) {
util::LockGuard lg(listenerLock);
return listeners.erase(lifecycleListener) == 1;
};
void LifecycleService::fireLifecycleEvent(const LifecycleEvent &lifecycleEvent) {
util::LockGuard lg(listenerLock);
util::ILogger &logger = util::ILogger::getLogger();
switch (lifecycleEvent.getState()) {
case LifecycleEvent::STARTING :
logger.info("LifecycleService::LifecycleEvent STARTING");
break;
case LifecycleEvent::STARTED :
logger.info("LifecycleService::LifecycleEvent STARTED");
break;
case LifecycleEvent::SHUTTING_DOWN :
logger.info("LifecycleService::LifecycleEvent SHUTTING_DOWN");
break;
case LifecycleEvent::SHUTDOWN :
logger.info("LifecycleService::LifecycleEvent SHUTDOWN");
break;
case LifecycleEvent::CLIENT_CONNECTED :
logger.info("LifecycleService::LifecycleEvent CLIENT_CONNECTED");
break;
case LifecycleEvent::CLIENT_DISCONNECTED :
logger.info("LifecycleService::LifecycleEvent CLIENT_DISCONNECTED");
break;
}
for (std::set<LifecycleListener *>::iterator it = listeners.begin(); it != listeners.end(); ++it) {
(*it)->stateChanged(lifecycleEvent);
}
};
bool LifecycleService::isRunning() {
return active;
};
}
}
}
<|endoftext|> |
<commit_before>/** @file camera.hpp
@brief Implements a basic free-fly camera to help testing. Uses SFML.
*/
#ifndef CAMERA_HPP
#define CAMERA_HPP
#include <cmath>
#include <SFML/Window.hpp>
namespace oglwrap {
/// Purely virtual interface class for cameras.
class Camera {
public:
/// Returns the camera matrix.
virtual glm::mat4 cameraMatrix() const = 0;
/// Returns the camera's position.
virtual glm::vec3 getPos() const = 0;
/// Returns the camera's target.
virtual glm::vec3 getTarget() const = 0;
/// Returns the looking direction of the camera
virtual glm::vec3 getForward() const {
return glm::normalize(getTarget() - getPos());
}
/// Returns the camera's CCW rotation angle around the X Euler axe.
/** Assuming that (0,1,0) is up, angle 0 is neg Z (forwards), Pi/2 is pos Y (up) */
virtual float getRotx() const {
return asin(getForward().y);
}
/// Returns the camera's CCW rotation angle around the Y Euler axe.
/** Assuming that (0,1,0) is up, angle 0 is pos X (right), Pi/2 is pos Z (backwards) */
virtual float getRoty() const {
glm::vec3 fwd = getForward();
return atan2(fwd.z, fwd.x);
}
/// Returns the camera's CCW rotation angle around the Z Euler axe.
/** Assuming that (0,1,0) is up, angle 0 is neg Z (forwards), Pi/2 is pos Y (up) */
virtual float getRotz() const {
return 0;
}
};
/// A simple free-fly camera class using SFML. It's rather for testing than serious use.
/** It can be controlled with the WASD keys and the mouse */
class FreeFlyCamera : public Camera {
/// The camera's position and the normalized forward vector
glm::vec3 pos, fwd;
/// Rotation angles(in radians) around the x and y Euler axes.
float rotx, roty;
/// Private constant numbers
const float speedPerSec, maxPitchAngle, mouseSensitivity;
public:
/// @brief Creates the free-fly camera.
/// @param pos - The position of the camera.
/// @param target - The position of the camera's target (what it is looking at).
/// @param speedPerSec - Move speed in OpenGL units per second
FreeFlyCamera(const glm::vec3& pos,
const glm::vec3& target = glm::vec3(),
float speedPerSec = 5.0f,
float mouseSensitivity = 1.0f)
: pos(pos)
, fwd(glm::normalize(target - pos))
, rotx(asin(fwd.y))
, roty(atan2(fwd.z, fwd.x))
, speedPerSec(speedPerSec)
, maxPitchAngle(85./90. * M_PI_2)
, mouseSensitivity(mouseSensitivity) {
assert(fabs(rotx) < maxPitchAngle);
}
/// Updates the camera's position and rotation.
/// @param window - The currently active SFML window.
/// @param fixMouse - Specifies if the mouse should be locked into the middle of the screen.
void update(const sf::Window& window, bool fixMouse = false) {
using namespace glm;
static sf::Clock clock;
static float prevTime;
float time = clock.getElapsedTime().asSeconds();
float dt = time - prevTime;
prevTime = time;
sf::Vector2i loc = sf::Mouse::getPosition(window);
sf::Vector2i diff;
if(fixMouse) {
sf::Vector2i screenHalf = sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2);
diff = loc - screenHalf;
sf::Mouse::setPosition(screenHalf, window);
} else {
static sf::Vector2i prevLoc;
diff = loc - prevLoc;
prevLoc = loc;
}
static bool firstExec = true, lastFixMouse = fixMouse;
if(firstExec || lastFixMouse != fixMouse) {
firstExec = false;
lastFixMouse = fixMouse;
return;
}
// Mouse movement - update the coordinate system
if(diff.x || diff.y) {
roty += diff.x * mouseSensitivity * 0.0035f;
rotx += -diff.y * mouseSensitivity * 0.0035f;
if(fabs(rotx) > maxPitchAngle)
rotx = rotx/fabs(rotx) * maxPitchAngle;
}
// WASD movement
float ds = dt * speedPerSec;
fwd = vec3(
cos(rotx) * cos(roty),
sin(rotx),
cos(rotx) * sin(roty)
);
vec3 right = normalize(cross(fwd, vec3(0.0f, 1.0f, 0.0f)));
if(sf::Keyboard::isKeyPressed(sf::Keyboard::W))
pos += fwd * ds;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::S))
pos -= fwd * ds;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::D))
pos += right * ds;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::A))
pos -= right * ds;
}
/// Returns the camera matrix.
glm::mat4 cameraMatrix() const {
return glm::lookAt(pos, pos + fwd, glm::vec3(0.0f, 1.0f, 0.0f));
}
/// Returns the camera's target.
glm::vec3 getTarget() const {
return pos + fwd;
}
/// Returns the camera's position.
glm::vec3 getPos() const {
return pos;
}
/// Returns the camera's CCW rotation angle around the X Euler axe.
float getRotx() const {
return rotx;
}
/// Returns the camera's CCW rotation angle around the Y Euler axe.
float getRoty() const {
return roty;
}
}; // FreeFlyCamera
/// A simple camera class using SFML. Its position depends on an external target, usually a character.
/** It can be controlled with the WASD keys and the mouse */
class ThirdPersonalCamera : public Camera {
// The target's position and the normalized forward vector
glm::vec3 target, fwd;
// Rotation angles(in radians) relative to the pos Z axis in the XZ and YZ planes.
float rotx, roty;
// Initial distance between the camera and target, and the current and destination distance modifier.
/* It's nearly a must to interpolate this, it looks very ugly without it */
float currDistMod, destDistMod;
// Don't interpolate at the first updateTarget call.
bool firstCall;
// Private constant number
const float initialDistance, maxPitchAngle, mouseSensitivity, mouseScrollSensitivity;
public:
/// @brief Creates the third-personal camera.
/// @param pos - The position of the camera.
/// @param target - The position of the camera's target (what it is looking at).
/// @param speedPerSec - Move speed in OpenGL units per second
ThirdPersonalCamera(const glm::vec3& pos,
const glm::vec3& target = glm::vec3(),
float mouseSensitivity = 1.0f,
float mouseScrollSensitivity = 1.0f)
: target(pos)
, fwd(glm::normalize(target - pos))
, rotx(asin(fwd.y))
, roty(atan2(fwd.z, fwd.x))
, currDistMod(1.0)
, destDistMod(1.0)
, firstCall(true)
, initialDistance(glm::length(target - pos))
, maxPitchAngle(60./90. * M_PI_2)
, mouseSensitivity(mouseSensitivity)
, mouseScrollSensitivity(mouseScrollSensitivity) {
assert(fabs(rotx) < maxPitchAngle);
}
/// Updates the camera's position and rotation.
/// @param window - The currently active SFML window.
/// @param fixMouse - Specifies if the mouse should be locked into the middle of the screen.
void updateRotation(float time, const sf::Window& window, bool fixMouse = false) {
using namespace glm;
static float lastTime = 0;
float dt = time - lastTime;
lastTime = time;
sf::Vector2i loc = sf::Mouse::getPosition(window);
sf::Vector2i diff;
if(fixMouse) {
sf::Vector2i screenHalf = sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2);
diff = loc - screenHalf;
sf::Mouse::setPosition(screenHalf, window);
} else {
static sf::Vector2i prevLoc;
diff = loc - prevLoc;
prevLoc = loc;
}
// We get invalid diff values at the startup or if fixMouse has just changed
static bool firstExec = true, lastFixMouse = fixMouse;
if(firstExec || lastFixMouse != fixMouse) {
firstExec = false;
lastFixMouse = fixMouse;
diff = sf::Vector2i(0, 0);
}
// Mouse movement - update the coordinate system
if(diff.x || diff.y) {
roty += diff.x * mouseSensitivity * 0.0035f;
rotx += -diff.y * mouseSensitivity * 0.0035f;
if(fabs(rotx) > maxPitchAngle)
rotx = rotx/fabs(rotx) * maxPitchAngle;
}
float distDiffMod = destDistMod - currDistMod;
if(fabs(distDiffMod) > 1e-2) {
int sign = distDiffMod / fabs(distDiffMod);
currDistMod += sign * dt * mouseScrollSensitivity;
}
fwd = (initialDistance * currDistMod) * vec3(
cos(rotx) * cos(roty),
sin(rotx),
cos(rotx) * sin(roty)
);
}
/// Changes the distance in which the camera should follow the target.
/// @param mouseWheelTicks - The number of ticks, the mouse wheel was scrolled. Expect positive on up scroll.
void scrolling(int mouseWheelTicks) {
destDistMod -= mouseWheelTicks / 10.0f * mouseScrollSensitivity;
if(destDistMod < 0.5f)
destDistMod = 0.5f;
else if(destDistMod > 2.0f)
destDistMod = 2.0f;
}
/// Updates the target of the camera. Is expected to be called every frame.
/// @param target - the position of the object the camera should follow.
void updateTarget(const glm::vec3& _target) {
if(firstCall) {
target = _target;
firstCall = false;
return;
}
target = glm::vec3(_target.x, target.y, _target.z);
float diff = _target.y - target.y;
const float offs = std::max(fabs(diff * diff / 5.0), 0.1);
if(fabs(diff) > offs) { // FIXME @ this constant
target.y += diff / fabs(diff) * offs;
}
}
/// Returns the camera matrix.
glm::mat4 cameraMatrix() const {
return glm::lookAt(target - fwd, target, glm::vec3(0.0f, 1.0f, 0.0f));
}
/// Returns the camera's target.
glm::vec3 getTarget() const {
return target;
}
/// Returns the camera's position.
glm::vec3 getPos() const {
return target - fwd;
}
/// Returns the camera's CCW rotation angle around the X Euler axe.
float getRotx() const {
return rotx;
}
/// Returns the camera's CCW rotation angle around the Y Euler axe.
float getRoty() const {
return roty;
}
}; // ThirdPersonalCamera
} // namespace oglwrap
#endif // header guard
<commit_msg>Small changes.<commit_after>/** @file camera.hpp
@brief Implements a basic free-fly camera to help testing. Uses SFML.
*/
#ifndef CAMERA_HPP
#define CAMERA_HPP
#include <cmath>
#include <SFML/Window.hpp>
namespace oglwrap {
/// Purely virtual interface class for cameras.
class Camera {
public:
/// Returns the camera matrix.
virtual glm::mat4 cameraMatrix() const = 0;
/// Returns the camera's position.
virtual glm::vec3 getPos() const = 0;
/// Returns the camera's target.
virtual glm::vec3 getTarget() const = 0;
/// Returns the looking direction of the camera
virtual glm::vec3 getForward() const {
return glm::normalize(getTarget() - getPos());
}
/// Returns the camera's CCW rotation angle around the X Euler axe.
/** Assuming that (0,1,0) is up, angle 0 is neg Z (forwards), Pi/2 is pos Y (up) */
virtual float getRotx() const {
return asin(getForward().y);
}
/// Returns the camera's CCW rotation angle around the Y Euler axe.
/** Assuming that (0,1,0) is up, angle 0 is pos X (right), Pi/2 is pos Z (backwards) */
virtual float getRoty() const {
glm::vec3 fwd = getForward();
return atan2(fwd.z, fwd.x);
}
/// Returns the camera's CCW rotation angle around the Z Euler axe.
/** Assuming that (0,1,0) is up, angle 0 is neg Z (forwards), Pi/2 is pos Y (up) */
virtual float getRotz() const {
return 0;
}
};
/// A simple free-fly camera class using SFML. It's rather for testing than serious use.
/** It can be controlled with the WASD keys and the mouse */
class FreeFlyCamera : public Camera {
/// The camera's position and the normalized forward vector
glm::vec3 pos, fwd;
/// Rotation angles(in radians) around the x and y Euler axes.
float rotx, roty;
/// Private constant numbers
const float speedPerSec, maxPitchAngle, mouseSensitivity;
public:
/// @brief Creates the free-fly camera.
/// @param pos - The position of the camera.
/// @param target - The position of the camera's target (what it is looking at).
/// @param speedPerSec - Move speed in OpenGL units per second
FreeFlyCamera(const glm::vec3& pos,
const glm::vec3& target = glm::vec3(),
float speedPerSec = 5.0f,
float mouseSensitivity = 1.0f)
: pos(pos)
, fwd(glm::normalize(target - pos))
, rotx(asin(fwd.y))
, roty(atan2(fwd.z, fwd.x))
, speedPerSec(speedPerSec)
, maxPitchAngle(85./90. * M_PI_2)
, mouseSensitivity(mouseSensitivity) {
assert(fabs(rotx) < maxPitchAngle);
}
/// Updates the camera's position and rotation.
/// @param window - The currently active SFML window.
/// @param fixMouse - Specifies if the mouse should be locked into the middle of the screen.
void update(const sf::Window& window, bool fixMouse = false) {
using namespace glm;
static sf::Clock clock;
static float prevTime;
float time = clock.getElapsedTime().asSeconds();
float dt = time - prevTime;
prevTime = time;
sf::Vector2i loc = sf::Mouse::getPosition(window);
sf::Vector2i diff;
if(fixMouse) {
sf::Vector2i screenHalf = sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2);
diff = loc - screenHalf;
sf::Mouse::setPosition(screenHalf, window);
} else {
static sf::Vector2i prevLoc;
diff = loc - prevLoc;
prevLoc = loc;
}
static bool firstExec = true, lastFixMouse = fixMouse;
if(firstExec || lastFixMouse != fixMouse) {
firstExec = false;
lastFixMouse = fixMouse;
return;
}
// Mouse movement - update the coordinate system
if(diff.x || diff.y) {
roty += diff.x * mouseSensitivity * 0.0035f;
rotx += -diff.y * mouseSensitivity * 0.0035f;
if(fabs(rotx) > maxPitchAngle)
rotx = rotx/fabs(rotx) * maxPitchAngle;
}
// WASD movement
float ds = dt * speedPerSec;
fwd = vec3(
cos(rotx) * cos(roty),
sin(rotx),
cos(rotx) * sin(roty)
);
vec3 right = normalize(cross(fwd, vec3(0.0f, 1.0f, 0.0f)));
if(sf::Keyboard::isKeyPressed(sf::Keyboard::W))
pos += fwd * ds;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::S))
pos -= fwd * ds;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::D))
pos += right * ds;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::A))
pos -= right * ds;
}
/// Returns the camera matrix.
glm::mat4 cameraMatrix() const {
return glm::lookAt(pos, pos + fwd, glm::vec3(0.0f, 1.0f, 0.0f));
}
/// Returns the camera's target.
glm::vec3 getTarget() const {
return pos + fwd;
}
/// Returns the camera's position.
glm::vec3 getPos() const {
return pos;
}
/// Returns the camera's CCW rotation angle around the X Euler axe.
float getRotx() const {
return rotx;
}
/// Returns the camera's CCW rotation angle around the Y Euler axe.
float getRoty() const {
return roty;
}
}; // FreeFlyCamera
/// A simple camera class using SFML. Its position depends on an external target, usually a character.
/** It can be controlled with the WASD keys and the mouse */
class ThirdPersonalCamera : public Camera {
// The target's position and the normalized forward vector
glm::vec3 target, fwd;
// Rotation angles(in radians) relative to the pos Z axis in the XZ and YZ planes.
float rotx, roty;
// Initial distance between the camera and target, and the current and destination distance modifier.
/* It's nearly a must to interpolate this, it looks very ugly without it */
float currDistMod, destDistMod;
// Don't interpolate at the first updateTarget call.
bool firstCall;
// Private constant number
const float initialDistance, maxPitchAngle, mouseSensitivity, mouseScrollSensitivity;
public:
/// @brief Creates the third-personal camera.
/// @param pos - The position of the camera.
/// @param target - The position of the camera's target (what it is looking at).
/// @param speedPerSec - Move speed in OpenGL units per second
ThirdPersonalCamera(const glm::vec3& pos,
const glm::vec3& target = glm::vec3(),
float mouseSensitivity = 1.0f,
float mouseScrollSensitivity = 1.0f)
: target(pos)
, fwd(glm::normalize(target - pos))
, rotx(asin(fwd.y))
, roty(atan2(fwd.z, fwd.x))
, currDistMod(1.0)
, destDistMod(1.0)
, firstCall(true)
, initialDistance(glm::length(target - pos))
, maxPitchAngle(60./90. * M_PI_2)
, mouseSensitivity(mouseSensitivity)
, mouseScrollSensitivity(mouseScrollSensitivity) {
assert(fabs(rotx) < maxPitchAngle);
}
/// Updates the camera's position and rotation.
/// @param window - The currently active SFML window.
/// @param fixMouse - Specifies if the mouse should be locked into the middle of the screen.
void updateRotation(float time, const sf::Window& window, bool fixMouse = false) {
using namespace glm;
static float lastTime = 0;
float dt = time - lastTime;
lastTime = time;
sf::Vector2i loc = sf::Mouse::getPosition(window);
sf::Vector2i diff;
if(fixMouse) {
sf::Vector2i screenHalf = sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2);
diff = loc - screenHalf;
sf::Mouse::setPosition(screenHalf, window);
} else {
static sf::Vector2i prevLoc;
diff = loc - prevLoc;
prevLoc = loc;
}
// We get invalid diff values at the startup or if fixMouse has just changed
static bool firstExec = true, lastFixMouse = fixMouse;
if(firstExec || lastFixMouse != fixMouse) {
firstExec = false;
lastFixMouse = fixMouse;
diff = sf::Vector2i(0, 0);
}
// Mouse movement - update the coordinate system
if(diff.x || diff.y) {
roty += diff.x * mouseSensitivity * 0.0035f;
rotx += -diff.y * mouseSensitivity * 0.0035f;
if(fabs(rotx) > maxPitchAngle)
rotx = rotx/fabs(rotx) * maxPitchAngle;
}
float distDiffMod = destDistMod - currDistMod;
if(fabs(distDiffMod) > 1e-2) {
int sign = distDiffMod / fabs(distDiffMod);
currDistMod += sign * dt * mouseScrollSensitivity;
}
fwd = (initialDistance * currDistMod) * vec3(
cos(rotx) * cos(roty),
sin(rotx),
cos(rotx) * sin(roty)
);
}
/// Changes the distance in which the camera should follow the target.
/// @param mouseWheelTicks - The number of ticks, the mouse wheel was scrolled. Expect positive on up scroll.
void scrolling(int mouseWheelTicks) {
destDistMod -= mouseWheelTicks / 10.0f * mouseScrollSensitivity;
if(destDistMod < 0.5f)
destDistMod = 0.5f;
else if(destDistMod > 2.0f)
destDistMod = 2.0f;
}
/// Updates the target of the camera. Is expected to be called every frame.
/// @param target - the position of the object the camera should follow.
void updateTarget(const glm::vec3& _target) {
if(firstCall) {
target = _target;
firstCall = false;
return;
}
target = glm::vec3(_target.x, target.y, _target.z);
float diff = _target.y - target.y;
const float offs = std::max(fabs(diff * diff / 5.0), 0.05);
if(fabs(diff) > offs) { // FIXME @ this constant
target.y += diff / fabs(diff) * offs;
}
}
/// Returns the camera matrix.
glm::mat4 cameraMatrix() const {
return glm::lookAt(target - fwd, target, glm::vec3(0, 1, 0));
}
/// Returns the camera's target.
glm::vec3 getTarget() const {
return target;
}
/// Returns the camera's position.
glm::vec3 getPos() const {
return target - fwd;
}
/// Returns the camera's CCW rotation angle around the X Euler axe.
float getRotx() const {
return rotx;
}
/// Returns the camera's CCW rotation angle around the Y Euler axe.
float getRoty() const {
return roty;
}
}; // ThirdPersonalCamera
} // namespace oglwrap
#endif // header guard
<|endoftext|> |
<commit_before>#include "carta.h"
#include <iostream>
#include <C:\SDL2-2.0.5\x86_64-w64-mingw32\include\SDL2\SDL.h>
#include <C:\SDL2-2.0.5\x86_64-w64-mingw32\include\SDL2\SDL_image.h>
#include "textura.h"
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
using namespace std;
int main(){
// Janela principal
SDL_Window* gWindow = NULL;
// Renderizador principal
SDL_Renderer* gRenderer = NULL;
// Classe texture
// Textura t = NULL;
// Eventos
SDL_Event event;
// Responsavel pelo loop principal
bool quit = false;
// Cria a janela
gWindow = SDL_CreateWindow("Presidente", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if(gWindow == NULL){
cout << "Window could not be created. SDL Error: " << SDL_GetError() << endl;
} else {
// Cria o renderizador
gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED);
if(gRenderer == NULL) {
cout << "Renderer could not be created. SDL Error: " << SDL_GetError() << endl;
} else {
// Inicializa a cor do renderizador
SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
// Inicializa o carregamento de PNG
int imgFlags = IMG_INIT_PNG;
if(!(IMG_Init(imgFlags) & imgFlags)){
cout << "SDL could not initialize image. SDL Error: " << IMG_GetError() << endl;
}
}
}
Carta c = Carta(23, gRenderer);
/*if(t == NULL){
cout << "Failed to load texture." << endl;
}*/
// Loop principal
while(!quit){
// Responsavel pelos eventos em espera
while(SDL_PollEvent(&event) != 0){
// Evento de saída
if( event.type == SDL_QUIT)
quit = true;
}
// Limpa a tela
SDL_RenderClear(gRenderer);
// Renderiza a carta
c.renderCard();
// Atualiza a tela
SDL_RenderPresent(gRenderer);
}
// Destroi a janela
SDL_DestroyRenderer(gRenderer);
SDL_DestroyWindow(gWindow);
gRenderer = NULL;
gWindow = NULL;
// Sai dos subsistemas
IMG_Quit();
SDL_Quit();
return 0;
}
<commit_msg>Desnecessário o include do SDL<commit_after>#include "carta.h"
#include <iostream>
#include "textura.h"
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
using namespace std;
int main(){
// Janela principal
SDL_Window* gWindow = NULL;
// Renderizador principal
SDL_Renderer* gRenderer = NULL;
// Classe texture
// Textura t = NULL;
// Eventos
SDL_Event event;
// Responsavel pelo loop principal
bool quit = false;
// Cria a janela
gWindow = SDL_CreateWindow("Presidente", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if(gWindow == NULL){
cout << "Window could not be created. SDL Error: " << SDL_GetError() << endl;
} else {
// Cria o renderizador
gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED);
if(gRenderer == NULL) {
cout << "Renderer could not be created. SDL Error: " << SDL_GetError() << endl;
} else {
// Inicializa a cor do renderizador
SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
// Inicializa o carregamento de PNG
int imgFlags = IMG_INIT_PNG;
if(!(IMG_Init(imgFlags) & imgFlags)){
cout << "SDL could not initialize image. SDL Error: " << IMG_GetError() << endl;
}
}
}
Carta c = Carta(23, gRenderer);
/*if(t == NULL){
cout << "Failed to load texture." << endl;
}*/
// Loop principal
while(!quit){
// Responsavel pelos eventos em espera
while(SDL_PollEvent(&event) != 0){
// Evento de saída
if( event.type == SDL_QUIT)
quit = true;
}
// Limpa a tela
SDL_RenderClear(gRenderer);
// Renderiza a carta
c.renderCard();
// Atualiza a tela
SDL_RenderPresent(gRenderer);
}
// Destroi a janela
SDL_DestroyRenderer(gRenderer);
SDL_DestroyWindow(gWindow);
gRenderer = NULL;
gWindow = NULL;
// Sai dos subsistemas
IMG_Quit();
SDL_Quit();
return 0;
}
<|endoftext|> |
<commit_before>#pragma once
#ifndef SCOPEEXIT_HPP
# define SCOPEEXIT_HPP
#include <utility>
/* This counts the number of args */
#define NARGS_SEQ(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define NARGS(...) NARGS_SEQ(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
/* This will let macros expand before concating them */
#define PRIMITIVE_CAT(x, y) x ## y
#define CAT(x, y) PRIMITIVE_CAT(x, y)
/* This will pop the last argument off */
#define POP_LAST(...) CAT(POP_LAST_, NARGS(__VA_ARGS__))(__VA_ARGS__)
#define POP_LAST_1(x1)
#define POP_LAST_2(x1, x2) x1
#define POP_LAST_3(x1, x2, x3) x1, x2
#define POP_LAST_4(x1, x2, x3, x4) x1, x2, x3
#define POP_LAST_5(x1, x2, x3, x4, x5) x1, x2, x3, x4
#define POP_LAST_6(x1, x2, x3, x4, x5, x6) x1, x2, x3, x4, x5
#define POP_LAST_7(x1, x2, x3, x4, x5, x6, x7) x1, x2, x3, x4, x5, x6
#define POP_LAST_8(x1, x2, x3, x4, x5, x6, x7, x8) x1, x2, x3, x4, x5, x6, x7
#define POP_LAST_9(x1, x2, x3, x4, x5, x6, x7, x8, x9) x1, x2, x3, x4, x5, x6, x7, x8
#define POP_LAST_10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) x1, x2, x3, x4, x5, x6, x7, x8, x9
/* This will return the last argument */
#define LAST(...) CAT(LAST_, NARGS(__VA_ARGS__))(__VA_ARGS__)
#define LAST_1(x1) x1
#define LAST_2(x1, x2) x2
#define LAST_3(x1, x2, x3) x3
#define LAST_4(x1, x2, x3, x4) x4
#define LAST_5(x1, x2, x3, x4, x5) x5
#define LAST_6(x1, x2, x3, x4, x5, x6) x6
#define LAST_7(x1, x2, x3, x4, x5, x6, x7) x7
#define LAST_8(x1, x2, x3, x4, x5, x6, x7, x8) x8
#define LAST_9(x1, x2, x3, x4, x5, x6, x7, x8, x9) x9
#define LAST_10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) x10
namespace detail
{
template <typename T>
class scope_exit
{
public:
explicit scope_exit(T&& f) : f_(std::move(f)) { }
scope_exit(scope_exit&& other) : f_(std::move(other.f_)) { }
~scope_exit() { f_(); }
private:
T const f_;
};
class scope_exit_helper { };
template<typename T>
inline scope_exit<T> make_scope_exit(T&& f)
{
return scope_exit<T>(std::forward<T>(f));
}
template<typename T>
inline scope_exit<T> operator+(scope_exit_helper&&, T&& f)
{
return scope_exit<T>(std::forward<T>(f));
}
}
#define SCOPE_EXIT(...) auto const CAT(scope_exit_, __LINE__)\
(::detail::make_scope_exit([POP_LAST(__VA_ARGS__)]{LAST(__VA_ARGS__);}))
#define SCOPE_EXIT2(...) auto const CAT(scope_exit_, __LINE__)\
=::detail::scope_exit_helper()+[__VA_ARGS__]
#endif // SCOPEEXIT_HPP
<commit_msg>some styles fixes<commit_after>#pragma once
#ifndef SCOPEEXIT_HPP
# define SCOPEEXIT_HPP
#include <utility>
/* This counts the number of args */
#define NARGS_SEQ(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define NARGS(...) NARGS_SEQ(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
/* This will let macros expand before concating them */
#define PRIMITIVE_CAT(x, y) x ## y
#define CAT(x, y) PRIMITIVE_CAT(x, y)
/* This will pop the last argument off */
#define POP_LAST(...) CAT(POP_LAST_, NARGS(__VA_ARGS__))(__VA_ARGS__)
#define POP_LAST_1(x1)
#define POP_LAST_2(x1, x2) x1
#define POP_LAST_3(x1, x2, x3) x1, x2
#define POP_LAST_4(x1, x2, x3, x4) x1, x2, x3
#define POP_LAST_5(x1, x2, x3, x4, x5) x1, x2, x3, x4
#define POP_LAST_6(x1, x2, x3, x4, x5, x6) x1, x2, x3, x4, x5
#define POP_LAST_7(x1, x2, x3, x4, x5, x6, x7) x1, x2, x3, x4, x5, x6
#define POP_LAST_8(x1, x2, x3, x4, x5, x6, x7, x8) x1, x2, x3, x4, x5, x6, x7
#define POP_LAST_9(x1, x2, x3, x4, x5, x6, x7, x8, x9) x1, x2, x3, x4, x5, x6, x7, x8
#define POP_LAST_10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) x1, x2, x3, x4, x5, x6, x7, x8, x9
/* This will return the last argument */
#define LAST(...) CAT(LAST_, NARGS(__VA_ARGS__))(__VA_ARGS__)
#define LAST_1(x1) x1
#define LAST_2(x1, x2) x2
#define LAST_3(x1, x2, x3) x3
#define LAST_4(x1, x2, x3, x4) x4
#define LAST_5(x1, x2, x3, x4, x5) x5
#define LAST_6(x1, x2, x3, x4, x5, x6) x6
#define LAST_7(x1, x2, x3, x4, x5, x6, x7) x7
#define LAST_8(x1, x2, x3, x4, x5, x6, x7, x8) x8
#define LAST_9(x1, x2, x3, x4, x5, x6, x7, x8, x9) x9
#define LAST_10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) x10
namespace detail
{
template <typename T>
class scope_exit
{
public:
explicit scope_exit(T&& f) : f_(std::move(f))
{
static_assert(noexcept(f_()), "throwing functors are unsupported");
}
scope_exit(scope_exit&& other) : f_(std::move(other.f_)) { }
~scope_exit() { f_(); }
private:
T const f_;
};
class scope_exit_helper { };
template<typename T>
inline scope_exit<T> make_scope_exit(T&& f)
{
return scope_exit<T>(std::forward<T>(f));
}
template<typename T>
inline scope_exit<T> operator+(scope_exit_helper&&, T&& f)
{
return scope_exit<T>(std::forward<T>(f));
}
}
#define SCOPE_EXIT(...) auto const CAT(scope_exit_, __LINE__) \
(::detail::make_scope_exit([POP_LAST(__VA_ARGS__)]() noexcept\
{ LAST(__VA_ARGS__); }))
#define SCOPE_EXIT2(...) auto const CAT(scope_exit_, __LINE__)\
=::detail::scope_exit_helper()+[__VA_ARGS__]() noexcept
#endif // SCOPEEXIT_HPP
<|endoftext|> |
<commit_before>#include "stdafx.h"
#include "csgo_net_chan.h"
#include "WrpConsole.h"
#include "addresses.h"
#include <SourceInterfaces.h>
#include <csgo/bitbuf/demofilebitbuf.h>
#include <build/protobuf/csgo/netmessages.pb.h>
#include <shared/AfxDetours.h>
#include <Windows.h>
#include <deps/release/Detours/src/detours.h>
int g_i_MirvPov = 0;
struct csgo_bf_read {
char const* m_pDebugName;
bool m_bOverflow;
int m_nDataBits;
size_t m_nDataBytes;
unsigned int m_nInBufWord;
int m_nBitsAvail;
unsigned int const* m_pDataIn;
unsigned int const* m_pBufferEnd;
unsigned int const* m_pData;
};
typedef const SOURCESDK::QAngle& (__fastcall *csgo_C_CSPlayer_EyeAngles_t)(SOURCESDK::C_BaseEntity_csgo* This, void* Edx);
csgo_C_CSPlayer_EyeAngles_t Truecsgo_C_CSPlayer_EyeAngles;
const SOURCESDK::QAngle& __fastcall Mycsgo_C_CSPlayer_EyeAngles(SOURCESDK::C_BaseEntity_csgo * This, void * Edx)
{
if (g_i_MirvPov)
{
if (This->entindex() == g_i_MirvPov)
{
DWORD ofs = AFXADDR_GET(csgo_C_CSPlayer_ofs_m_angEyeAngles);
return *((SOURCESDK::QAngle*)((char *)This + ofs));
}
}
return Truecsgo_C_CSPlayer_EyeAngles(This, Edx);
}
typedef void csgo_CNetChan_t;
typedef int(__fastcall* csgo_CNetChan_ProcessMessages_t)(csgo_CNetChan_t* This, void* edx, csgo_bf_read * pReadBuf, bool bWasReliable);
csgo_CNetChan_ProcessMessages_t Truecsgo_CNetChan_ProcessMessages = 0;
int __fastcall Mycsgo_CNetChan_ProcessMessages(csgo_CNetChan_t* This, void* Edx, csgo_bf_read* pReadBuf, bool bWasReliable)
{
if (g_i_MirvPov)
{
SOURCESDK::CSGO::CBitRead readBuf(pReadBuf->m_pData, pReadBuf->m_nDataBytes);
while (0 < readBuf.GetNumBytesLeft())
{
int packet_cmd = readBuf.ReadVarInt32();
int packet_size = readBuf.ReadVarInt32();
if (packet_size < readBuf.GetNumBytesLeft())
{
switch (packet_cmd)
{
case svc_ServerInfo:
{
CSVCMsg_ServerInfo msg;
msg.ParseFromArray(readBuf.GetBasePointer() + readBuf.GetNumBytesRead(), packet_size);
if (msg.has_is_hltv())
{
msg.set_is_hltv(false);
}
if (msg.has_player_slot())
{
msg.set_player_slot(g_i_MirvPov - 1);
}
msg.SerializePartialToArray(const_cast<unsigned char*>(readBuf.GetBasePointer()) + readBuf.GetNumBytesRead(), packet_size);
}
break;
case svc_SetView:
{
CSVCMsg_SetView msg;
msg.ParseFromArray(readBuf.GetBasePointer() + readBuf.GetNumBytesRead(), packet_size);
if (msg.has_entity_index())
{
msg.set_entity_index(g_i_MirvPov);
}
msg.SerializePartialToArray(const_cast<unsigned char*>(readBuf.GetBasePointer()) + readBuf.GetNumBytesRead(), packet_size);
}
break;
}
readBuf.SeekRelative(packet_size * 8);
}
else
break;
}
}
bool result = Truecsgo_CNetChan_ProcessMessages(This, Edx, pReadBuf, bWasReliable);
if (g_i_MirvPov)
{
static WrpConVarRef cvarClPredict;
cvarClPredict.RetryIfNull("cl_predict"); // GOTV would have this on 0, so force it too.
cvarClPredict.SetDirectHack(0);
}
return result;
}
bool csgo_CNetChan_ProcessMessages_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_CNetChan_ProcessMessages))
{
LONG error = NO_ERROR;
Truecsgo_CNetChan_ProcessMessages = (csgo_CNetChan_ProcessMessages_t)AFXADDR_GET(csgo_CNetChan_ProcessMessages);
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Truecsgo_CNetChan_ProcessMessages, Mycsgo_CNetChan_ProcessMessages);
error = DetourTransactionCommit();
firstResult = NO_ERROR == error;
}
return firstResult;
}
bool csgo_C_CSPlayer_EyeAngles_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_C_CSPlayer_vtable))
{
AfxDetourPtr((PVOID*)&(((DWORD*)AFXADDR_GET(csgo_C_CSPlayer_vtable))[169]), Mycsgo_C_CSPlayer_EyeAngles, (PVOID*)&Truecsgo_C_CSPlayer_EyeAngles);
firstResult = true;
}
return firstResult;
}
typedef int(__fastcall* csgo_DamageIndicator_MessageFunc_t)(void* This, void* Edx, const char * pMsg);
csgo_DamageIndicator_MessageFunc_t Truecsgo_DamageIndicator_MessageFunc = 0;
bool __fastcall MYcsgo_DamageIndicator_MessageFunc(void* This, void* Edx, const char* pMsg)
{
if (g_i_MirvPov)
{
bool abort = false;
__asm mov eax, pMsg
__asm mov eax, [eax + 0x10]
__asm cmp eax, g_i_MirvPov
__asm jz __cont
__asm mov abort, 1
__asm __cont:
if (abort) return true;
}
return Truecsgo_DamageIndicator_MessageFunc(This, Edx, pMsg);
}
bool csgo_DamageIndicator_MessageFunc_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_DamageIndicator_MessageFunc))
{
LONG error = NO_ERROR;
Truecsgo_DamageIndicator_MessageFunc = (csgo_DamageIndicator_MessageFunc_t)AFXADDR_GET(csgo_DamageIndicator_MessageFunc);
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Truecsgo_DamageIndicator_MessageFunc, MYcsgo_DamageIndicator_MessageFunc);
error = DetourTransactionCommit();
firstResult = NO_ERROR == error;
}
return firstResult;
}
typedef void(__fastcall* csgo_C_CSPlayer_UpdateOnRemove_t)(SOURCESDK::C_BasePlayer_csgo* This, void* Edx);
csgo_C_CSPlayer_UpdateOnRemove_t Truecsgo_C_CSPlayer_UpdateOnRemove = nullptr;
typedef void(__fastcall* csgo_C_BasePlayer_SetAsLocalPlayer_t)(void* Ecx, void* Edx);
void __fastcall Mycsgo_C_CSPlayer_UpdateOnRemove(SOURCESDK::C_BasePlayer_csgo* This, void* Edx)
{
if (g_i_MirvPov && This->entindex() == g_i_MirvPov)
{
if (SOURCESDK::IClientEntity_csgo* ce1 = SOURCESDK::g_Entitylist_csgo->GetClientEntity(1))
{
if (SOURCESDK::C_BaseEntity_csgo* be1 = ce1->GetBaseEntity())
{
if (be1->IsPlayer())
{
// The target fake local player is being deleted, emergency case, switch back to real one.
static csgo_C_BasePlayer_SetAsLocalPlayer_t setAsLocalPlayer = (csgo_C_BasePlayer_SetAsLocalPlayer_t)AFXADDR_GET(csgo_C_BasePlayer_SetAsLocalPlayer);
setAsLocalPlayer(be1, 0);
}
}
}
}
Truecsgo_C_CSPlayer_UpdateOnRemove(This, Edx);
}
bool csgo_C_CSPlayer_UpdateOnRemove_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_C_CSPlayer_vtable))
{
AfxDetourPtr((PVOID*)&(((DWORD*)AFXADDR_GET(csgo_C_CSPlayer_vtable))[126]), Mycsgo_C_CSPlayer_UpdateOnRemove, (PVOID*)&Truecsgo_C_CSPlayer_UpdateOnRemove);
firstResult = true;
}
return firstResult;
}
CON_COMMAND(mirv_pov, "Forces a POV on a GOTV demo.")
{
if (!(AFXADDR_GET(csgo_C_CSPlayer_ofs_m_angEyeAngles)
&& csgo_CNetChan_ProcessMessages_Install()
&& csgo_C_CSPlayer_EyeAngles_Install()
&& csgo_DamageIndicator_MessageFunc_Install()
&& csgo_C_CSPlayer_UpdateOnRemove_Install()
&& AFXADDR_GET(csgo_C_BasePlayer_SetAsLocalPlayer)
))
{
Tier0_Warning("Not supported for your engine / missing hooks,!\n");
return;
}
int argC = args->ArgC();
if (2 <= argC)
{
g_i_MirvPov = atoi(args->ArgV(1));
unsigned char* pData = (unsigned char *)AFXADDR_GET(csgo_crosshair_localplayer_check) + 15;
MdtMemBlockInfos mbis;
MdtMemAccessBegin(pData, 2, &mbis);
if (g_i_MirvPov)
{
pData[0] = 0x90;
pData[1] = 0x90;
}
else
{
pData[0] = 0x74;
pData[1] = 0xcc;
}
MdtMemAccessEnd(&mbis);
return;
}
Tier0_Msg(
"mirv_pov <iPlayerEntityIndex> - Needs to be set before loading demo / connecting! Forces POV on a GOTV to the given player entity index, set 0 to disable.\n"
"Current value: %i\n"
, g_i_MirvPov
);
}<commit_msg>Fixes #402 mirv_pov and FOV zooming<commit_after>#include "stdafx.h"
#include "csgo_net_chan.h"
#include "WrpConsole.h"
#include "addresses.h"
#include <SourceInterfaces.h>
#include <csgo/bitbuf/demofilebitbuf.h>
#include <build/protobuf/csgo/netmessages.pb.h>
#include <shared/AfxDetours.h>
#include <Windows.h>
#include <deps/release/Detours/src/detours.h>
int g_i_MirvPov = 0;
struct csgo_bf_read {
char const* m_pDebugName;
bool m_bOverflow;
int m_nDataBits;
size_t m_nDataBytes;
unsigned int m_nInBufWord;
int m_nBitsAvail;
unsigned int const* m_pDataIn;
unsigned int const* m_pBufferEnd;
unsigned int const* m_pData;
};
typedef const SOURCESDK::QAngle& (__fastcall *csgo_C_CSPlayer_EyeAngles_t)(SOURCESDK::C_BaseEntity_csgo* This, void* Edx);
csgo_C_CSPlayer_EyeAngles_t Truecsgo_C_CSPlayer_EyeAngles;
const SOURCESDK::QAngle& __fastcall Mycsgo_C_CSPlayer_EyeAngles(SOURCESDK::C_BaseEntity_csgo * This, void * Edx)
{
if (g_i_MirvPov)
{
if (This->entindex() == g_i_MirvPov)
{
DWORD ofs = AFXADDR_GET(csgo_C_CSPlayer_ofs_m_angEyeAngles);
return *((SOURCESDK::QAngle*)((char *)This + ofs));
}
}
return Truecsgo_C_CSPlayer_EyeAngles(This, Edx);
}
typedef void csgo_CNetChan_t;
typedef int(__fastcall* csgo_CNetChan_ProcessMessages_t)(csgo_CNetChan_t* This, void* edx, csgo_bf_read * pReadBuf, bool bWasReliable);
csgo_CNetChan_ProcessMessages_t Truecsgo_CNetChan_ProcessMessages = 0;
int __fastcall Mycsgo_CNetChan_ProcessMessages(csgo_CNetChan_t* This, void* Edx, csgo_bf_read* pReadBuf, bool bWasReliable)
{
if (g_i_MirvPov)
{
SOURCESDK::CSGO::CBitRead readBuf(pReadBuf->m_pData, pReadBuf->m_nDataBytes);
while (0 < readBuf.GetNumBytesLeft())
{
int packet_cmd = readBuf.ReadVarInt32();
int packet_size = readBuf.ReadVarInt32();
if (packet_size < readBuf.GetNumBytesLeft())
{
switch (packet_cmd)
{
case svc_ServerInfo:
{
CSVCMsg_ServerInfo msg;
msg.ParseFromArray(readBuf.GetBasePointer() + readBuf.GetNumBytesRead(), packet_size);
if (msg.has_is_hltv())
{
msg.set_is_hltv(false);
}
if (msg.has_player_slot())
{
msg.set_player_slot(g_i_MirvPov - 1);
}
msg.SerializePartialToArray(const_cast<unsigned char*>(readBuf.GetBasePointer()) + readBuf.GetNumBytesRead(), packet_size);
}
break;
case svc_SetView:
{
CSVCMsg_SetView msg;
msg.ParseFromArray(readBuf.GetBasePointer() + readBuf.GetNumBytesRead(), packet_size);
if (msg.has_entity_index())
{
msg.set_entity_index(g_i_MirvPov);
}
msg.SerializePartialToArray(const_cast<unsigned char*>(readBuf.GetBasePointer()) + readBuf.GetNumBytesRead(), packet_size);
}
break;
}
readBuf.SeekRelative(packet_size * 8);
}
else
break;
}
}
bool result = Truecsgo_CNetChan_ProcessMessages(This, Edx, pReadBuf, bWasReliable);
if (g_i_MirvPov)
{
static WrpConVarRef cvarClPredict;
cvarClPredict.RetryIfNull("cl_predict"); // GOTV would have this on 0, so force it too.
cvarClPredict.SetDirectHack(0);
}
return result;
}
bool csgo_CNetChan_ProcessMessages_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_CNetChan_ProcessMessages))
{
LONG error = NO_ERROR;
Truecsgo_CNetChan_ProcessMessages = (csgo_CNetChan_ProcessMessages_t)AFXADDR_GET(csgo_CNetChan_ProcessMessages);
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Truecsgo_CNetChan_ProcessMessages, Mycsgo_CNetChan_ProcessMessages);
error = DetourTransactionCommit();
firstResult = NO_ERROR == error;
}
return firstResult;
}
bool csgo_C_CSPlayer_EyeAngles_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_C_CSPlayer_vtable))
{
AfxDetourPtr((PVOID*)&(((DWORD*)AFXADDR_GET(csgo_C_CSPlayer_vtable))[169]), Mycsgo_C_CSPlayer_EyeAngles, (PVOID*)&Truecsgo_C_CSPlayer_EyeAngles);
firstResult = true;
}
return firstResult;
}
typedef float(__fastcall* csgo_C_CS_Player__GetFOV_t)(SOURCESDK::C_BasePlayer_csgo* This, void* Edx);
csgo_C_CS_Player__GetFOV_t True_csgo_C_CS_Player__GetFOV;
float __fastcall My_csgo_C_CS_Player__GetFOV(SOURCESDK::C_BasePlayer_csgo * This, void* Edx)
{
if (g_i_MirvPov && This->entindex() == g_i_MirvPov)
{
bool* pIsLocalPlayer = (bool*)((char*)This + AFXADDR_GET(csgo_C_BasePlayer_ofs_m_bIsLocalPlayer));
bool oldIsLocalPlayer = *pIsLocalPlayer;
*pIsLocalPlayer = false;
float result = True_csgo_C_CS_Player__GetFOV(This, Edx);
*pIsLocalPlayer = oldIsLocalPlayer;
return result;
}
return True_csgo_C_CS_Player__GetFOV(This, Edx);
}
bool Install_csgo_C_CS_Player__GetFOVs(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_C_CSPlayer_vtable))
{
AfxDetourPtr((PVOID*)&(((DWORD*)AFXADDR_GET(csgo_C_CSPlayer_vtable))[331]), My_csgo_C_CS_Player__GetFOV, (PVOID*)&True_csgo_C_CS_Player__GetFOV);
firstResult = true;
}
return firstResult;
}
typedef int(__fastcall* csgo_DamageIndicator_MessageFunc_t)(void* This, void* Edx, const char * pMsg);
csgo_DamageIndicator_MessageFunc_t Truecsgo_DamageIndicator_MessageFunc = 0;
bool __fastcall MYcsgo_DamageIndicator_MessageFunc(void* This, void* Edx, const char* pMsg)
{
if (g_i_MirvPov)
{
bool abort = false;
__asm mov eax, pMsg
__asm mov eax, [eax + 0x10]
__asm cmp eax, g_i_MirvPov
__asm jz __cont
__asm mov abort, 1
__asm __cont:
if (abort) return true;
}
return Truecsgo_DamageIndicator_MessageFunc(This, Edx, pMsg);
}
bool csgo_DamageIndicator_MessageFunc_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_DamageIndicator_MessageFunc))
{
LONG error = NO_ERROR;
Truecsgo_DamageIndicator_MessageFunc = (csgo_DamageIndicator_MessageFunc_t)AFXADDR_GET(csgo_DamageIndicator_MessageFunc);
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Truecsgo_DamageIndicator_MessageFunc, MYcsgo_DamageIndicator_MessageFunc);
error = DetourTransactionCommit();
firstResult = NO_ERROR == error;
}
return firstResult;
}
typedef void(__fastcall* csgo_C_CSPlayer_UpdateOnRemove_t)(SOURCESDK::C_BasePlayer_csgo* This, void* Edx);
csgo_C_CSPlayer_UpdateOnRemove_t Truecsgo_C_CSPlayer_UpdateOnRemove = nullptr;
typedef void(__fastcall* csgo_C_BasePlayer_SetAsLocalPlayer_t)(void* Ecx, void* Edx);
void __fastcall Mycsgo_C_CSPlayer_UpdateOnRemove(SOURCESDK::C_BasePlayer_csgo* This, void* Edx)
{
if (g_i_MirvPov && This->entindex() == g_i_MirvPov)
{
if (SOURCESDK::IClientEntity_csgo* ce1 = SOURCESDK::g_Entitylist_csgo->GetClientEntity(1))
{
if (SOURCESDK::C_BaseEntity_csgo* be1 = ce1->GetBaseEntity())
{
if (be1->IsPlayer())
{
// The target fake local player is being deleted, emergency case, switch back to real one.
static csgo_C_BasePlayer_SetAsLocalPlayer_t setAsLocalPlayer = (csgo_C_BasePlayer_SetAsLocalPlayer_t)AFXADDR_GET(csgo_C_BasePlayer_SetAsLocalPlayer);
setAsLocalPlayer(be1, 0);
}
}
}
}
Truecsgo_C_CSPlayer_UpdateOnRemove(This, Edx);
}
bool csgo_C_CSPlayer_UpdateOnRemove_Install(void)
{
static bool firstResult = false;
static bool firstRun = true;
if (!firstRun) return firstResult;
firstRun = false;
if (AFXADDR_GET(csgo_C_CSPlayer_vtable))
{
AfxDetourPtr((PVOID*)&(((DWORD*)AFXADDR_GET(csgo_C_CSPlayer_vtable))[126]), Mycsgo_C_CSPlayer_UpdateOnRemove, (PVOID*)&Truecsgo_C_CSPlayer_UpdateOnRemove);
firstResult = true;
}
return firstResult;
}
CON_COMMAND(mirv_pov, "Forces a POV on a GOTV demo.")
{
if (!(AFXADDR_GET(csgo_C_CSPlayer_ofs_m_angEyeAngles)
&& csgo_CNetChan_ProcessMessages_Install()
&& csgo_C_CSPlayer_EyeAngles_Install()
&& csgo_DamageIndicator_MessageFunc_Install()
&& csgo_C_CSPlayer_UpdateOnRemove_Install()
&& Install_csgo_C_CS_Player__GetFOVs()
&& AFXADDR_GET(csgo_C_BasePlayer_SetAsLocalPlayer)
))
{
Tier0_Warning("Not supported for your engine / missing hooks,!\n");
return;
}
int argC = args->ArgC();
if (2 <= argC)
{
g_i_MirvPov = atoi(args->ArgV(1));
unsigned char* pData = (unsigned char *)AFXADDR_GET(csgo_crosshair_localplayer_check) + 15;
MdtMemBlockInfos mbis;
MdtMemAccessBegin(pData, 2, &mbis);
if (g_i_MirvPov)
{
pData[0] = 0x90;
pData[1] = 0x90;
}
else
{
pData[0] = 0x74;
pData[1] = 0xcc;
}
MdtMemAccessEnd(&mbis);
return;
}
Tier0_Msg(
"mirv_pov <iPlayerEntityIndex> - Needs to be set before loading demo / connecting! Forces POV on a GOTV to the given player entity index, set 0 to disable.\n"
"Current value: %i\n"
, g_i_MirvPov
);
}<|endoftext|> |
<commit_before>/*
* File: main.cpp
* Author: vlad
*
* Created on December 12, 2013, 10:38 PM
*/
#include <iostream>
#include "qpp.h"
//#include "matlab.h" // support for MATLAB
// TODO: expandout function
// TODO: dyad function
// TODO: proj (dya) function
// TODO: ip (inner product function) function, make it general to return matrices
// TODO: Error class
// TODO: change all for(s) to column major order
// TODO: use .data() raw pointer instead of looping
using namespace std;
using namespace qpp;
using namespace qpp::types;
//int main(int argc, char **argv)
int main()
{
_init();
// Display formatting
std::cout << std::fixed; // use fixed format for nice formatting
// std::cout << std::scientific;
std::cout << std::setprecision(4); // only for fixed or scientific modes
cout << "Starting qpp..." << endl;
// TIMING
Timer t,total; // start the timer
size_t N = 10000;
cmat testmat = cmat::Random(N, N);
t.toc();
cout << "It took me " << t.ticks() << " ticks (" << t.secs()
<< " seconds) to initialize a " << N << " x " << N
<< " random complex matrix."<<endl;
t.reset();
cout << "The norm of a " << N << " x " << N
<< " random complex matrix is: "<<endl;
cout << norm(testmat) << endl;
t.toc(); // read the time
cout << "It took me " << t.ticks() << " ticks (" << t.secs()
<< " seconds) to compute the norm." << endl;
cout << "Total time: " << total.ticks() << " ticks (" << total.secs()
<< " seconds)." << endl;
// END TIMING
cout << endl << "Exiting qpp..." << endl;
}
<commit_msg>commit<commit_after>/*
* File: main.cpp
* Author: vlad
*
* Created on December 12, 2013, 10:38 PM
*/
#include <iostream>
#include "qpp.h"
//#include "matlab.h" // support for MATLAB
// TODO: expandout function
// TODO: dyad function
// TODO: proj (dya) function
// TODO: ip (inner product function) function, make it general to return matrices
// TODO: Error class
// TODO: change all for(s) to column major order
// TODO: use .data() raw pointer instead of looping
using namespace std;
using namespace qpp;
using namespace qpp::types;
//int main(int argc, char **argv)
int main()
{
_init();
// Display formatting
std::cout << std::fixed; // use fixed format for nice formatting
// std::cout << std::scientific;
std::cout << std::setprecision(4); // only for fixed or scientific modes
cout << "Starting qpp..." << endl;
// TIMING
Timer t,total; // start the timer
size_t N = 10000;
cmat testmat = cmat::Random(N, N);
t.toc();
cout << "It took me " << t.ticks() << " ticks (" << t.secs()
<< " seconds) to initialize a " << N << " x " << N
<< " random complex matrix."<<endl;
t.reset();
cout << "The norm of a " << N << " x " << N
<< " random complex matrix is: "<<endl;
cout << norm(testmat) << endl;
t.toc(); // read the time
cout << "It took me " << t.ticks() << " ticks (" << t.secs()
<< " seconds) to compute the norm." << endl;
total.toc();
cout << "Total time: " << total.ticks() << " ticks (" << total.secs()
<< " seconds)." << endl;
// END TIMING
cout << endl << "Exiting qpp..." << endl;
}
<|endoftext|> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.